Subversion Repositories public iLand

#ifndef SPATIALANALYSIS_H
#define SPATIALANALYSIS_H

/********************************************************************************************
**    iLand - an individual based forest landscape and disturbance model
**    http://iland.boku.ac.at
**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl
**
**    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 3 of the License, or
**    (at your option) any later version.
**
**    This program is distributed in the hope that it will be useful,
**    but WITHOUT ANY WARRANTY; without even the implied warranty of
**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**    GNU General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program.  If not, see <http://www.gnu.org/licenses/>.
********************************************************************************************/
#include "grid.h"
#include "layeredgrid.h"

#include <QObject>
#include <QJSValue>

class RumpleIndex; // forward
class SpatialLayeredGrid; // forward
/**
 * @brief The SpatialAnalysis class is the scripting class related to extra spatial analysis functions.
 * rumpleIndex: ratio crown surface area / ground area for the whole project area.
 * saveRumpleGrid(): save RU-based grid of rumple indices to an ASCII grid file.
 */
class SpatialAnalysis: public QObject
{
    Q_OBJECT
    Q_PROPERTY(double rumpleIndex READ rumpleIndexFullArea)
    Q_PROPERTY(QList<int> patchsizes READ patchsizes)

public:
    SpatialAnalysis(QObject *parent=0): QObject(parent), mRumple(0) {}
    ~SpatialAnalysis();
    static void addToScriptEngine();

    double rumpleIndexFullArea(); ///< retrieve the rumple index for the full landscape (one value)
    /// extract patches ('clumps') and save the resulting grid to 'fileName' (if not empty). Returns a vector with
    /// the number of pixels for each patch-id
    QList<int> extractPatches(Grid<double> &src, int min_size, QString fileName);
    QList<int> patchsizes() const { return mLastPatches; }
public slots:
    // API for Javascript
    void saveRumpleGrid(QString fileName); ///< save a grid of rumple index values (resource unit level) to a ESRI grid file (ascii)
    void saveCrownCoverGrid(QString fileName); ///< save a grid if crown cover percentages (RU level) to a ESRI grid file (ascii)
    QJSValue patches(QJSValue grid, int min_size);

private:
    void calculateCrownCover();
    RumpleIndex *mRumple;
    SpatialLayeredGrid *mLayers;
    FloatGrid mCrownCoverGrid;
    Grid<int> mClumpGrid;
    QList<int> mLastPatches;
    friend class SpatialLayeredGrid;

};

/** The RumpleIndex is a spatial index relating surface area to ground area.
 *  In forestry, it is a indicator of vertical heterogeneity. In iLand, the Rumple Index is
 *  the variability of the maximum tree height on 10m level (i.e. the "Height"-Grid).
 *  The RumpleIndex is calculated for each resource unit and also for the full project area.
 **/
class RumpleIndex
{
public:
    RumpleIndex(): mLastYear(-1) {}
    void setup(); ///< sets up the grid
    void calculate(); ///< calculates (or re-calculates) index values
    double value(const bool force_recalculate=false); ///< calculates rumple index for the full project area
    const FloatGrid &rumpleGrid()  { value(); /* calculate if necessary */ return mRumpleGrid; } ///< return the rumple index for the full project area
    //
    double test_triangle_area();
private:
    double calculateSurfaceArea(const float *heights, const float cellsize);
    FloatGrid mRumpleGrid;
    double mRumpleIndex;
    int mLastYear;
};



class SpatialLayeredGrid: public LayeredGridBase
{
public:
    SpatialLayeredGrid() { setup(); }
    void setup(); ///< initial setup of the grid
    int addGrid(const QString name, FloatGrid *grid); ///< adds a 'grid' named 'name'. returns index of the newly added grid.
    const QStringList &gridNames() { return mGridNames; }

    double value(const float x, const float y, const int index) const { checkGrid(index); return mGrids[index]->constValueAt(x,y); }
    double value(const QPointF &world_coord, const int index) const { checkGrid(index); return mGrids[index]->constValueAt(world_coord); }
    double value(const int ix, const int iy, const int index) const { checkGrid(index); return mGrids[index]->constValueAtIndex(ix,iy);}
    double value(const int grid_index, const int index) const {  checkGrid(index); return mGrids[index]->constValueAtIndex(grid_index);}
    void range(double &rMin, double &rMax, const int index) const { rMin=9999999999.; rMax=-99999999999.;
                                                              for (int i=0;i<mGrids[index]->count(); ++i) {
                                                                  rMin=qMin(rMin, value(i, index));
                                                                  rMax=qMax(rMax, value(i,index));}}

private:
    inline void checkGrid(const int grid_index) const { if (mGrids[grid_index]==0) const_cast<SpatialLayeredGrid*>(this)->createGrid(grid_index); } ///< helper function that checks if grids are to be created
    void createGrid(const int grid_index); ///< create (if necessary) the actual grid
    QStringList mGridNames; ///< the list of grid names
    QVector<FloatGrid*> mGrids; ///< the grid


};
#endif // SPATIALANALYSIS_H