QGIS » QGIS Application

/***************************************************************************

qgsgcpdataset.cpp - This is a container class that represents an entire set of

 GCP's associated with a specific reference model or a specific extraction

 and cross-referencing operation.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

%Import QtCore/QtCoremod.sip 

class QgsGCPDataSet

{

%TypeHeaderCode

#include <qgsgcpdataset.h>

%End

public:

  QgsGCPDataSet();

  virtual ~QgsGCPDataSet();

  void addGcp(QgsGCP* point);

  void updateGcp(QgsGCP* oldPoint, QgsGCP* newPoint);

  void removeGcp(QgsGCP* point);  

  void clear();

  int size() const;   

  const QList<QgsGCP*>& constList() const;

  QList<QgsGCP*> list();

};

/***************************************************************************

qgselevationmanager.sip - The ElevationManager contains a Digital Elevation

 Model of a specific reference image and allows sampling of the ground

 elevation at different coordinates. This DEM is used in the orthorectification

 process as well as chip projection.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsElevationManager

{

%TypeHeaderCode

#include <qgselevationmanager.h>

%End

public:

    QgsElevationManager();

    double sampleHeight(int,int);

    void openDEMFile(QString);

    virtual ~QgsElevationManager();

};

/***************************************************************************

qgsgcp.sip - A Ground Control Point (GCP) abstraction contains information about

 a specific GCP such as the reference and associated raw coordinates of this

 GCP, as well as additional elevation and other information. This object is

 also the container for the GCP chip data.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: James Meyer

Email : [email protected]

E

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsImageChip : QgsImageDataSet

{

%TypeHeaderCode

#include <qgsimagechip.h>

#include <qgsimagedataset.h>

%End

public:

//   static QgsImageChip* createImageChip(int width, int height, int type,  int bands = 3);

  ~QgsImageChip();

  QgsImageChip(const QgsImageChip& other);

  void* data();

};

/***************************************************************************

qgscrosscorrelator.cpp - This class handles the cross correlation of two

subimages.

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

Date : 12-July-2010

Copyright : (C) 2010 by FoxHat Solutions

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsCrossCorrelator

{

%TypeHeaderCode

#include <qgscrosscorrelator.h>

%End

public:

       /**\brief QgsCrossCorrelator Constructor

       Constructs the correlator with the given chip images

	   */

       QgsCrossCorrelator(QgsImageDataSet* ref, QgsImageDataSet* raw);

       /**\brief QgsCrossCorrelator Destructor

	   Destroys the QgsCrossCorrelator instance, releasing any owned resources.

	   */

       virtual ~QgsCrossCorrelator();

       double correlationValue();

}; 

%Module qgis.autogcp 0

%Import QtCore/QtCoremod.sip

%Import QtGui/QtGuimod.sip

%Import QtXml/QtXmlmod.sip

%Import core/core.sip

%Include qgsautogcpmanager.sip

%Include qgsdatarow.sip

%Include qgselevationmanager.sip

%Include qgsgcp.sip

%Include qgsgcpdataset.sip

%Include qgsimageanalyzer.sip

%Include qgsimagedataset.sip

%Include qgsorthorectification.sip

%Include qgswaveletextractor.sip

%Include qgssalientpoint.sip

%Include qgsimagechip.sip

%Include qgsprojectionmanager.sip

%Include qgscrosscorrelator.sip

/***************************************************************************

qgsimageanalyzer.sip - The ImageAnalyzer class is responsible for the physical

 analysis and processing of image data. This included detecting and extracting

 GCP's and GCP chips from images, as well as searching for these reference

 GCP chips on a raw image.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsImageAnalyzer

{

%TypeHeaderCode

#include <qgsimageanalyzer.h>

%End

public:

  /*! \brief QgsImageAnalyzer Constructor

  Constructs an analyzer for the supplied image, ready to perform processing on this image.

  */

	QgsImageAnalyzer(QgsImageDataSet* image = 0);

  /*! \brief Extracts ground control points from the assigned image.

  This method allocates a new QgsGCPDataSet and transfers ownership to the caller.

  The GCP's contained in this set will have geographic reference coordinates and a usable Chip for matching.

  If this method fails it returns an ampty set.

  */

	QgsGCPDataSet* extractGcps(int amount);

  /*! \brief Matches the supplied GCP set to the image dataset, using the GCP chips.

  If the method was successful the supplied GCP set will have it's raw coordinates updated.

  \param A pointer to the GCP set to use and update.

  \return A pointer to the supplied GCP set, with updated coordinates, or NULL on failure

  */

	QgsGCPDataSet* matchGcps(QgsGCPDataSet* gcpSet);

  /*! \brief Sets the image dataset of this analyzer.

  This can be used to change the image between operations, to enable reuse of the same QgsImageAnalyzer object.

  */

	void setImage(QgsImageDataSet* image);

  /*! \brief QgsImageAnalyzer Destructor

  */

	virtual ~QgsImageAnalyzer();

};

/***************************************************************************

qgsimagedataset.sip - This class contains all external data related to an image

 including the sensor model associated to the particular image.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class GDALDataset;

class QgsImageDataSet

{

%TypeHeaderCode

#include <qgsimagedataset.h>

%End

public:

    QgsImageDataSet(QString path);

    QgsImageDataSet(GDALDataset* path);

    virtual ~QgsImageDataSet();

    	/**\brief Returns a pointer to the internal GDALDataset instance or NULL if initialization failed*/

	//GDALDataset* gdalDataset();

	/**\brief Returns true if this object failed to initialize with the given file*/

	bool failed() const;

	/**\brief Returns the same as failed()*/

//	bool operator!() const;

  /*!\brief Gets the width and height of the raster image in pixels

  Returns the width through the xSize reference parameter and the height through ySize.

  If the image did not load or initialize correctly it does nothing.

  Use failed() to check validity of the object.

**/

  void imageSize(int& xSize, int& ySize) const;

  int imageXSize() const;

  int imageYSize() const;

  /*! \brief Gets the number of raster bands in the image.

  Returns the number of rasterbands in the image or 0 if it hasn't been initialized.

  */

  int rasterBands();

  /*! \brief Reads the value of the image at a specified point  

  */

  double readValue(int band, int xPixel, int yLine);

};

/***************************************************************************

qgsgcpconnector.sip - This is an abstract class that provides an interface for

 dealing directly with the underlying database. This includes methods for

 creating, reading, updating and deleting data. This class must be extended

 for specific database engines. Two included specialisations are planned,

 namely the PostgreSQLConnector and the SQLiteConnector.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsGCPConnector

{

%TypeHeaderCode

#include <qgsconnector.h>

%End

public:

    QgsGCPConnector();

    virtual void insertRow(QgsDataRow);

    virtual void updateRow(QgsDataRow);

    virtual void selectRow(QgsDataRow);

    virtual void deleteRow(QgsDataRow);

};

/***************************************************************************

qgsautogcpmanager.sip - This class manages the operations that need to be performed by

 the plug-in interface. Due to the clear separation of the core analysis

 classes and the plugin-specific user interface classes, a bridge is required

 between these different libraries. This class acts as the bridge, and removes

 any business logic from the presentational duties of the UI classes. This is

 done by delegating more specific operations to dedicated classes in the core

 package.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

Last Modified: 25/07/2010

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

struct IMAGE_INFO

{

%TypeHeaderCode

#include <qgsautogcpmanager.h>

%End

  QString pFileName;

  QString pFilePath;

  QString pFileFormat;

  QString pFileSize;

  QString pRasterWidth;

  QString pRasterHeight;

  QString pOriginCoordinates;

  QString pPixelSize;

  QDateTime pDateCreated;

  QDateTime pDateModified;

  QDateTime pDateRead;

  QString pRasterBands;

  QString pProjectionInfo;

};

class QgsAutoGCPManager

{

%TypeHeaderCode

#include <qgsautogcpmanager.h>

%End

public:

  QgsAutoGCPManager();

  /*! \brief  Opens the sensed (raw) image to use

  */

  bool openSensedImage(QString path);

  /*! \brief  Opens the reference (control) image to use

  */

  bool openReferenceImage(QString path);

  /*! \brief  Sets the Sensor model string

  The actual sensor model will be loaded from the registry using this string.

  */

  void setSensorModel(QString sensorModel);

  /*! \brief  Sets the amount of GCP's to extract from the reference image.

  */

  void setGcpCount(int count);

  void clearGcpSet();

  /*! \brief  Performs the extraction of Ground Control Points from the reference image.

  This class is the owner of the returned dataset and destroys it when itself is destroyed.

  \return A pointer to the managed GCP set.

  */

  QgsGCPDataSet* extractControlPoints();

  /*! \brief  Matches the current set of owned GCP's to the raw image

  This class is the owner of the returned dataset and destroys it when itself is destroyed.

  \return A pointer to the managed GCP set, or NULL if the operation failed.

  */

  QgsGCPDataSet* matchControlPoints();

  /*! \brief  Gets a pointer to the managed GCP set

  This class is the owner of the returned dataset and destroys it when itself is destroyed.

  \return A pointer to the managed GCP set.

  */

  QgsGCPDataSet* gcpSet();

   /*! \brief  Returns the raw image. 

  Return a pointer to the QgsImageDataSet containing the raw image dataset.

  */

  QgsImageDataSet* rawImage();

  /*! \brief  Returns the reference image. 

  Return a pointer to the QgsImageDataSet containing the reference image dataset.

  */

  QgsImageDataSet* referenceImage();

  /*! \brief  QgsAutoGCPManager destructor. 

  Deallocates all datasets created from any operations.

  */

  virtual ~QgsAutoGCPManager();

  void projectGCPs();

  bool setProjection(QgsImageDataSet *imageDataset, PROJ_INFO *projectionInfo);

  bool exportGcpSet(QString path);

  bool exportGcpSet(QgsGCPDataSet *gcpSet, QString path);

  void addGcp(QgsGCP *gcp);

  void updateGcp(QgsGCP *gcp);

  void removeGcp(QgsGCP *gcp);

  IMAGE_INFO imageInfo(QString path);

};

/***************************************************************************

qgsorthorectification.sip - This class is used to perform actual ortho-correction on images using

 a supplied GCPSet, a SensorModel and, optionally, a Digital Elevation Model

(DEM).

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsOrthorectification

{

%TypeHeaderCode

#include <qgsorthorectification.h>

%End

public:

    QgsOrthorectification();

    QgsImageDataSet* orthorectify();

    ~QgsOrthorectification();

};

/***************************************************************************

qgsdatarow.sip - Represents each row of data stored in the Postgre and SQLite

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsDataRow

{

%TypeHeaderCode

#include <qgsdatarow.h>

%End

public:

    QgsDataRow();

    QMap<QString,QString>* values;

    virtual  ~QgsDataRow();

};

/***************************************************************************

qgsgcp.sip - A Ground Control Point (GCP) abstraction contains information about

 a specific GCP such as the reference and associated raw coordinates of this

 GCP, as well as additional elevation and other information. This object is

 also the container for the GCP chip data.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: James Meyer (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

%Import QtCore/QtCoremod.sip 

class QgsWaveletExtractor

{

%TypeHeaderCode

#include <qgswaveletextractor.h>

%End

public:

  /*! \brief QgsWaveletExtractor Constructor.

  Performs initialization.

  */

	QgsWaveletExtractor(QgsImageDataSet* image, double threshold = 1.0);

  QgsWaveletExtractor(QgsImageDataSet* image, int featureXSize, int featureYSize, double threshold = 1.0);

	/*!

  \brief QgsWaveletExtractor destructor

  This does not free the QgsImageDataSet object or any GCP data retrieved.

  */

	~QgsWaveletExtractor();

  /*! \brief performs the extraction of GCP's from the image

  This method is guaranteed to extract at least the number of GCP's required, but will likely extract more.

  The GCP's are ordered in decreasing order of saliency value (i.e. Sharpest points are first).

  The caller of this function is responsible for dealocating the data.

  */

	QList<QgsSalientPoint>* extractFeatures();

  /*! \brief Checks wether this extractor initialized correctly and is ready for extraction.

  If this method returns false, a likely reason is that the underlying image is invalid.

  */

  bool initialized();

};

/***************************************************************************

qgsprojectionmanager.cpp - The ProjectionManager class is responsible for the

projection of GCPs using the projection information either contained within the

Metadata of the image, or as specified by the user.

This class uses the GDAL Warp library to perform the projection on the provided

GCP chip.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Email : [email protected]

Author: Francois Maass

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class GDALWarpOptions;

struct PROJ_INFO

{

%TypeHeaderCode

#include <qgsprojectionmanager.h>

%End

  QString pGeographicCSName;

  QString pProjectedCSName;

  QString pVariantName;

  QString pGeogName;

  QString pDatumName;

  QString pSpheroidName;

  QString pPMName;

  QString pAngularUnits;

  double pStdP1;

  double pStdP2;

  double pCenterLat;

  double pCenterLong;

  double pFalseEasting;

  double pFalseNorthing;

  double pStandardParallel;

  double pCentralMeridian;

  double pPseudoStdParallelLat;

  double pPseudoStdParallel1;

  double pSatelliteHeight;

  double pScale;

  double pAzimuth;

  double pRectToSkew;

  double pLat1;

  double pLong1;

  double pLat2;

  double pLong2;

  double pLatitudeOfOrigin;

  double pSemiMajor;

  double pInvFlattening;

  double pPMOffset;

  double pConvertToRadians;

  int pVariation;

  int pZone;

  int pNorth;

};

class QgsProjectionManager

{

%TypeHeaderCode

#include <qgsprojectionmanager.h>

%End

public:

  /*! \brief QgsProjectionManager Constructor

  Constructs a projection manager that will handle all projection related processes.

  \param A pointer to the GDAL reference image dataset.

  \param A pointer to the GDAL raw image dataset.

  */

        QgsProjectionManager(QgsImageDataSet *refImageDataset, QgsImageDataSet *rawImageDataset);

  /*! \brief QgsProjectionManager Constructor

  Constructs a projection manager that will handle all projection related processes.

  */

        QgsProjectionManager();

  /*! \brief Set the reference image dataset

  Sets the reference image to be used for the projection as a QgsImageDataSet

  \param A pointer to the GDAL reference image dataset.

  */

        void setReferenceImage(QgsImageDataSet *refImageDataset);

  /*! \brief Set the raw image dataset

  Sets the raw image to be used for the projection as a QgsImageDataSet

  \param A pointer to the GDAL raw image dataset.

  */

        void setRawImage(QgsImageDataSet *rawImageDataset);

  /*! \brief Get the reference image dataset

  Gets the reference image to be used for the projection as a QgsImageDataSet

  */

        QgsImageDataSet* referenceImage();

  /*! \brief Get the reference image dataset

  Gets the reference image to be used for the projection as a QgsImageDataSet

  */

        QgsImageDataSet* rawImage();

  /*! \brief Static initializer for projection manager

  Initializes the required projected- and geographic- Coordinate System data.  

  */     

        void initializeMaps();

  /*! \brief QgsProjectionManager Destructor

  */

        ~QgsProjectionManager();

  /*! \brief Notifier for error messages.

  Notifies QGSLogger of error that occured.

  \param The message describing the error.

  */

        void notifyFailure(QString message);

  /*! \brief Project a single GCP between coordinate systems

  A single GCP is projected between two defined coordinate systems as retrieved from

  the raw- and reference image dataset provided with the constructor. This function handles

  all the processes required to fully project the provided GCP chip.

  Note: It is assumed that both datasets have valid projection definitions when called.

  To check projection information, see QgsProjectionManager::checkProjectionInformation(...).

  \param A pointer to the QgsImageDataSet containing the chip.

  \param A pointer to the QgsImageDataSet in which the chip is to be returned

  */	

	bool projectGCPChip(QgsImageDataSet* chipIn, QgsImageDataSet* chipOut);

  /*! \brief Project a single GCP between coordinate systems

  A single GCP is projected between two defined coordinate systems as retrieved from

  the raw- and reference image dataset provided with the constructor. This function handles

  all the processes required to fully project the provided GCP chip.

  Note: It is assumed that both datasets have valid projection definitions when called.

  To check projection information, see QgsProjectionManager::checkProjectionInformation(...).

  \param A pointer to the QgsGCP object containing the extracted GCP chip.

  */

        void projectGCP(QgsGCP *originalGCP);

  /*! \brief Defines the warp options for projections

  Warp Options are defined based on information extracted from the source and destination

  datasets.

  \param The source GDAL dataset (original coordinate system)

  \param The destination GDAL dataset (desired coordinate system)

  \param True if a GDAL progress bar should be printed to standard output.

  */

        GDALWarpOptions* getWarpOptions(GDALDataset *srcDataset, GDALDataset *dstDataset, bool progressBar);

  /*! \brief Warp operation that handles projection

  The provided dataset is warped/projected using the projection options provided as well as

  information extracted from the GDAL raw- and reference image datasets.

  \param The warp options as defined by QgsProjectionManager::getWarpOptions(...).

  \param The dataset to be projected

  */

        void warpDatasets(GDALWarpOptions *pswops, GDALDataset *dstDataset);

  /*! \brief Warp data destroyer

  Cleans up all the additional data created for the projection process

  \param The warp options as defined by QgsProjectionManager::getWarpOptions(...).

  */

        void destroyWarpData(GDALWarpOptions *pswops);

  /*! \brief Checks for availability and validity of projection definition strings.

  The provided dataset is checked to see if it contains the projection definition string.

  \param The dataset to be checked.

  */

        bool checkProjectionInformation(QgsImageDataSet *imageDataset);

  /*! \brief Sets the projection definition string

  The projection definition string is derived from information contained in the projectionInfo

  container based on the options provided, and assigned to the dataset.

  \param The dataset to which the projection definition string is to be assigned.

  \param The projection Information container.

  */

    bool setProjectionInformation(QgsImageDataSet *imageDataset, PROJ_INFO *projectionInfo);

};

/***************************************************************************

qgsgcp.sip - A Ground Control Point (GCP) abstraction contains information about

 a specific GCP such as the reference and associated raw coordinates of this

 GCP, as well as additional elevation and other information. This object is

 also the container for the GCP chip data.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: Christoph Stallmann (FoxHat Solutions)

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

class QgsGCP

{

%TypeHeaderCode

#include <qgsgcp.h>

%End

public:

  QgsGCP();

  ~QgsGCP();

  bool operator==(const QgsGCP& other) const;

  double refX() const;

  void setRefX(double value);

  double refY() const;

  void setRefY(double value);

  double refZ() const;

  void setRefZ(double value);

  double rawX() const;

  void setRawX(double value);

  double rawY() const;

  void setRawY(double value);

  QgsImageDataSet* gcpChip() const;

  void setGcpChip(QgsImageDataSet* value);

};

/**************************************************************************

qgsgcp.cpp - A Ground Control Point (GCP) abstraction contains information about

 a specific GCP such as the reference and associated raw coordinates of this

 GCP, as well as additional elevation and other information. This object is

 also the container for the GCP chip data.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Author: James Meyer

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

/*!

  This class represents any point of interest on a two-dimensional raster image.

*/

class QgsSalientPoint : QgsPoint

{

%TypeHeaderCode

#include <qgssalientpoint.h>

#include <qgspoint.h>

%End

  public:

    /*! \brief QgsFeature constructor

    constructs a feature point at the given x, y coordinates and optionally a saliency value.

  */

    QgsSalientPoint(double x = 0, double y = 0, double theSaliency = 0);

    /*! \brief Gets the Saliency value of this feature.

    */

    double saliency()const;

    /*! \brief Sets the Saliency value of this feature.

    */

    void setSaliency(double value);

};

# additional autogcp includes

INCLUDE_DIRECTORIES(

    ../src/autogcp

    ${CMAKE_BINARY_DIR}/src/autogcp

)

# autogcp module

FILE(GLOB sip_files_autogcp autogcp/*.sip)

set(SIP_EXTRA_FILES_DEPEND ${sip_files_core} ${sip_files_autogcp})

ADD_SIP_PYTHON_MODULE(qgis.autogcp autogcp/autogcp.sip qgis_core qgis_autogcp)

/***************************************************************************

qgselevationmanager.cpp - The ElevationManager contains a Digital Elevation

 Model of a specific reference image and allows sampling of the ground

 elevation at different coordinates. This DEM is used in the orthorectification

 process as well as chip projection.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

#ifndef QGSELEVATIONMANAGER_H

#define QGSELEVATIONMANAGER_H

#include <QString>

#include <QVector>

class QgsElevationManager

{

public:

    QgsElevationManager();

    double sampleHeight(int,int);

    void openDEMFile(QString);

    virtual ~QgsElevationManager();

private:

    QVector<double>* mElevation;

};

#endif // QGSELEVATIONMANAGER_H

/***************************************************************************

qgscrosscorrelator.cpp - This class handles the cross correlation of two

subimages.

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

Date : 12-July-2010

Copyright : (C) 2010 by FoxHat Solutions

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

#include "qgscrosscorrelator.h"

#include "qgsimagedataset.h"

#include <math.h>

#include <iostream>

#include <ios>

QgsCrossCorrelator::QgsCrossCorrelator(QgsImageDataSet* ref,  QgsImageDataSet* raw)

{

    refChip = ref;

    rawChip = raw;

}

QgsCrossCorrelator::~QgsCrossCorrelator()

{

}

double QgsCrossCorrelator::correlationValue()

{

    //find the band(s) with which to calculate each distinct image's grey level:

    int refbands = refChip->rasterBands();

    for (int i = 0; i < refbands; i++)

    {

        GDALRasterBand* band = refChip->gdalDataset()->GetRasterBand(1);

        GDALColorInterp color = band->GetColorInterpretation();

        switch ( color )

        {

            case GCI_GrayIndex:

            { greyRefBand = i+1; refConvert = GREY; }

            break;

            case GCI_RedBand:

            { redRefBand = i+1; refConvert = RGB; }

            break;

            case GCI_GreenBand:

            { greenRefBand = i+1; refConvert = RGB; }

            break;

            case GCI_BlueBand:

            { blueRefBand = i+1; refConvert = RGB; }

            break;

            case GCI_CyanBand:

            { cyanRefBand = i+1; refConvert = CMYK; }

            break;

            case GCI_MagentaBand:

            { magentaRefBand = i+1; refConvert = CMYK; }

            break;

            case GCI_YellowBand:

            { yellowRefBand = i+1;  refConvert = CMYK; }

            break;

            case GCI_BlackBand:

            { blackRefBand = i+1;  refConvert = CMYK; }

            break;

            default:

	    { 

		    if (refbands < 3)

		    {

			    greyRefBand = 1; refConvert = GREY;

		    }

		    else

		    {

			    redRefBand = 1; greenRefBand =  2; blueRefBand = 3; refConvert = RGB; 

		    }

	    }

	    break; //ASSUME RGB

        }

        if (color == GCI_GrayIndex) break;

    }

    int rawbands = rawChip->rasterBands();

    for (int j = 0; j < rawbands; j++)

    {

        GDALRasterBand* band = rawChip->gdalDataset()->GetRasterBand(j+1);

        GDALColorInterp color = band->GetColorInterpretation();

        switch ( color )

        {

            case GCI_GrayIndex:

            { greyRawBand = j+1; rawConvert = GREY; }

            break;

            case GCI_RedBand:

            { redRawBand = j+1; rawConvert = RGB; }

            break;

            case GCI_GreenBand:

            { greenRawBand = j+1; rawConvert = RGB; }

            break;

            case GCI_BlueBand:

            { blueRawBand = j+1; rawConvert = RGB; }

            break;

            case GCI_CyanBand:

            { cyanRawBand = j+1; rawConvert = CMYK; }

            break;

            case GCI_MagentaBand:

            { magentaRawBand = j+1; rawConvert = CMYK; }

            break;

            case GCI_YellowBand:

            { yellowRawBand = j+1; rawConvert = CMYK; }

            break;

            case GCI_BlackBand:

            { blackRawBand = j+1; rawConvert = CMYK; }

            break;

            default:

	    { 

		    if (rawbands < 3)

		    {

			    greyRawBand = 1; rawConvert = GREY;

		    }

		    else

		    {

			    redRawBand = 1; greenRawBand =  2; blueRawBand = 3; rawConvert = RGB; 

		    }

	    }

	    break; //ASSUME RGB

        }

        if (color == GCI_GrayIndex) break;

    }

    calculateAverages();

    return calculateCC();

}

//assumes that bands and Schemes have been set

void QgsCrossCorrelator::calculateAverages()

{

    refAvg = 0;

    rawAvg = 0;

    for (int i = 0; i < refChip->imageXSize(); i++)

    {

        for (int j = 0; j < refChip->imageYSize(); j++)

        {

		refAvg += greyLevel(true, i, j);

        }

    }

    refAvg = refAvg/(refChip->imageXSize()*refChip->imageYSize());

    for (int i = 0; i < rawChip->imageXSize(); i++)

    {

        for (int j = 0; j < rawChip->imageYSize(); j++)

        {

		rawAvg += greyLevel(false, i, j);

        }

    }

    rawAvg = rawAvg/(rawChip->imageXSize()*rawChip->imageYSize());

}

double QgsCrossCorrelator::calculateCC()

{

    double num = 0.0;

    double a = 0.0;

    double b = 0.0;

    for (int i = 0; i < refChip->imageXSize(); i++)

    {

        for (int j = 0; j < refChip->imageYSize(); j++)

        {

            //(ref's gray level - ref's avg gray level)*(raw's gray level - raw's avg gray level)

            num += (greyLevel(true,i,j) - refAvg)*(greyLevel(false,i,j) - rawAvg);

            //(ref's gray level - ref's avg gray level)

            a += pow((greyLevel(true,i,j) - refAvg),2);

            //(raw's gray level - raw's avg gray level)

            b += pow((greyLevel(false,i,j) - rawAvg),2);

        }

    }

    double denom = pow((a*b),0.5);

    return num/denom;

}

double QgsCrossCorrelator::greyLevel(bool isRef, int x, int y)

{

    if (isRef)

    {

        if (refConvert == GREY) return refChip->readValue(greyRefBand, x, y);

        if (refConvert == RGB)

        {

            return (refChip->readValue(redRefBand,x,y)*0.299 + refChip->readValue(greenRefBand,x,y)*0.587 + refChip->readValue(blueRefBand,x,y)*0.114);

        }

        else if (refConvert == CMYK)

        {

            return (refChip->readValue(cyanRefBand,x,y)*0.299 + refChip->readValue(magentaRefBand,x,y)*0.587 + refChip->readValue(yellowRefBand,x,y)*0.114 + refChip->readValue(blackRefBand,x,y));

        }

    }

    else

    {

        if (rawConvert == GREY) return rawChip->readValue(greyRawBand, x, y);

        if (rawConvert == RGB)

        {

            return (rawChip->readValue(redRawBand,x,y)*0.299 + rawChip->readValue(greenRawBand,x,y)*0.587 + rawChip->readValue(blueRawBand,x,y)*0.114);

        }

        else if (rawConvert == CMYK)

        {

            return (rawChip->readValue(cyanRawBand,x,y)*0.299 + rawChip->readValue(magentaRawBand,x,y)*0.587 + rawChip->readValue(yellowRawBand,x,y)*0.114 + rawChip->readValue(blackRawBand,x,y));

        }

	else return 0.0;

    }

}

#include "qgsfeatureextractor.h"

QgsFeatureExtractor::QgsFeatureExtractor()

{

}

QgsFeatureExtractor::~QgsFeatureExtractor()

{

}

/***************************************************************************

qgsimagedataset.cpp - This class contains all external data related to an image

 including the sensor model associated to the particular image.

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

Date : 07-May-2010

Copyright : (C) 2010 by FoxHat Solutions

Email : [email protected]

/***************************************************************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* (at your option) any later version. *

* *

***************************************************************************/

#include "qgsimagedataset.h"

#include "qgslogger.h"

#include <iostream>

#include <cstdlib>

QgsImageDataSet::QgsImageDataSet(QString path): 

  mFilePath(path),

  mBuffers(0),

  mDataset(0)

{

	if (!initialize())

	{

		mFail  = true;

    QgsLogger::debug("QgsImageDataSet::initialize() failed.");

	}else

	{

	  mFail = false;

	}

}

QgsImageDataSet::QgsImageDataSet(GDALDataset* dataset)

{

  if(!dataset)

  {

    mFail  = true;

    QgsLogger::debug("QgsImageDataSet::initialize() failed.");

  } else {

    mDataset = dataset;  

    mXSize = mDataset->GetRasterXSize();

    mYSize = mDataset->GetRasterYSize();   

    //Create Buffers

    int bandCount = mDataset->GetRasterCount();    

    mBuffers = new DataBuffer<mBufferCount>[bandCount];   

    mFail = false;

  }

}

bool QgsImageDataSet::initialize()

{

  registerGdalDrivers();

  const char* filename = mFilePath.toLatin1().data();

  GDALDatasetH handle =  GDALOpen(filename,GA_ReadOnly);

  if (handle)

  {

		mDataset = (GDALDataset*) handle;    

    mXSize = mDataset->GetRasterXSize();

    mYSize = mDataset->GetRasterYSize();   

    //Create Buffers

    int bandCount = mDataset->GetRasterCount();    

    mBuffers = new DataBuffer<mBufferCount>[bandCount];

    return true;

	}

	else

	{

    QgsLogger::debug(QString("Failed to open Image dataset. File path=")+mFilePath,1, "qgsimagedataset.cpp");

		return false;

	}

}//bool QgsImageDataSet::initialize()

QgsImageDataSet::~QgsImageDataSet()

{

  //printf("Deleting ImageDS\n");

    //delete mSensor;

	if (mDataset)

	{

    //printf("Closing GDAL DS\n");

    GDALClose((GDALDatasetH)mDataset);

    //printf("Closed GDAL DS\n");

	}

  finalize();

}

GDALDataset* QgsImageDataSet::gdalDataset()

{

	return mDataset;

}

void QgsImageDataSet::registerGdalDrivers()

{

	if (0 == GDALGetDriverCount())

	{

		GDALAllRegister();

	}

}//void QgsImageDataSet::registerGdalDrivers()

bool QgsImageDataSet::failed() const

{

	return mFail;

}

//Wrapper for failed()

bool QgsImageDataSet::operator!() const

{

	return failed();

}

QgsImageDataSet::operator bool() const

{

  return !failed();

}

void QgsImageDataSet::imageSize(int& xSize, int& ySize) const

{

  if (!failed())

  {

    xSize = mXSize;

    ySize = mYSize;

  }

}//bool QgsImageDataSet::operator!() const

int QgsImageDataSet::imageXSize() const

{

  return mXSize;

}

int QgsImageDataSet::imageYSize() const

{

  return mYSize;

}

void* QgsImageDataSet::readLine(int theBand, int line)

{  

  char message[100];

 //printf("READING BAND %d, line %d\n",theBand, line);

  if (theBand > mDataset->GetRasterCount() || theBand < 1)

  {

    //Log debug message

    return 0;

  } 

  DataBuffer<mBufferCount>& buffer = mBuffers[theBand - 1];

  for (int i = 0; i < mBufferCount; i++)

  {

    if (line ==buffer.line[i] && buffer.data[i])

    {//Has this line in the buffer already    

      sprintf(message, "In buffer: %d %d",line,i);

     // QgsLogger::debug(message,1,"QgsImageDataSet::readLine()");

      return buffer.data[i];

    }

  }

  //ELSE**************************************************

 //QgsLogger::debug(QString("Not Cached"));

  GDALRasterBand* band = mDataset->GetRasterBand(theBand);

  GDALDataType type = band->GetRasterDataType();

  //printf("%p \n", band);

  int blockX,blockY;

  if (line >= mYSize)

  {

    return 0;

  }

  band->GetBlockSize(&blockX,&blockY);

 // QgsLogger::debug(QString("is good "));

  int blocksToRead = mXSize / blockX; //Usually just one.  

  int yBlock = line / blockY; //Which block will be read

 // int toAlloc = blocksToRead * blockX * blockY * GDALGetDataTypeSize(band->GetRasterDataType());

  int toAlloc = 1 * mXSize * (GDALGetDataTypeSize(type) / 8);

  int curbuf = buffer.currentBuffer;

 //QgsLogger::debug(QString("TO Alloc:")+QString::number(toAlloc));

  if (!buffer.data[curbuf])

  {

    buffer.data[curbuf] = VSIMalloc(toAlloc);

  }

//QgsLogger::debug("Allocated Data",1,"QgsImageDataSet::readLine()");

  void* start;

  CPLErr result;

 /* for (int i = 0; i < blocksToRead; ++i)

  {

    start = dataIndex(buffer.data[curbuf], theBand, i * blockX); //Where to start reading data into

    result = band->ReadBlock(i,yBlock,start);    

  }*/

  band->RasterIO(GF_Read, 0, line, mXSize, 1, buffer.data[curbuf], mXSize, 1, type,0,0 );

 // QgsLogger::debug("Not in buffer");

  buffer.currentBuffer = ( curbuf  + 1) % mBufferCount;

  buffer.line[curbuf]  = line;

  return buffer.data[curbuf];  

}//void* QgsImageDataSet::readLine(int iband, int line)

/*WARNING does NO bounds checking.

Gets a pointer to the index'th element in the array pointed to by data.

*/

void* QgsImageDataSet::dataIndex(void* data,int band, int index)

{

  GDALDataType type = dataType(band);

  switch ( type )

  {

    case GDT_Byte:

      return ( void* ) &(( GByte * )data )[index];

      break;

    case GDT_UInt16:

      return ( void* ) &(( GUInt16 * )data )[index];

      break;

    case GDT_Int16:

      return ( void* ) &(( GInt16 * )data )[index];

      break;

    case GDT_UInt32:

      return ( void* ) &(( GUInt32 * )data )[index];

      break;

    case GDT_Int32:

      return ( void* ) &(( GInt32 * )data )[index];

      break;

    case GDT_Float32:

      return ( void* ) &(( float * )data )[index];

      break;

    case GDT_Float64:

    //  val = (( double * )data )[index];

      return ( void* ) &(( double * )data )[index];

      break;

    default:;

   //   QgsLogger::warning( "GDAL data type is not supported" );

  }

}//void* QgsWaveletExtractor::dataIndex(void* data, int index)

int QgsImageDataSet::rasterBands()

{

  if (mDataset)

  {

    return mDataset->GetRasterCount();

  } else 

  {

    return 0;

  }

}

double QgsImageDataSet::readValue(int band, int xPixel, int yLine)

{

  if (xPixel < 0 

    || xPixel >= mXSize 

    || yLine < 0

    || yLine >= mYSize) //Bounds check

  {

    return 0.0;

  }

  double value;

  void* data = readLine(band, yLine);

 // char message[100];

 // sprintf(message, "Data: %p", data);

 // QgsLogger::debug(message,1,"QgsImageDataSet::readValue()");

  GDALDataType type = dataType(band);

  //printf("Data TYPE: %s\n", GDALGetDataTypeName(type));

  switch ( type )

  {

    case GDT_Byte: