fmtreelist.h

Go to the documentation of this file.

/********************************************************************************************
**    iLand - an individual based forest landscape and disturbance model
**    http://iland-model.org
**    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/>.
********************************************************************************************/
#ifndef FMTREELIST_H
#define FMTREELIST_H
 
#include <QObject>
#include "scriptglobal.h"
#include "grid.h"
#include "scripttree.h"
 
class Tree; // forward
class Expression;
 
namespace ABE {
class FMStand;
 
class FMTreeList : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int stand READ standId) 
    Q_PROPERTY(int count READ count) 
    Q_PROPERTY(bool simulate READ simulate WRITE setSimulate) 
public:
 
    explicit FMTreeList(QObject *parent = 0);
    explicit FMTreeList(FMStand *stand, QObject *parent = 0);
    ~FMTreeList();
    int standId() const { return mStandId; }
    void setStand(FMStand *stand);
    bool simulate() const {return mOnlySimulate; }
    void setSimulate(bool do_simulate) {mOnlySimulate = do_simulate; }
    int count() const { return mTrees.count(); }
 
    int loadFromRect(ResourceUnit *ru, const QRectF &rect);
 
    int loadFromRU(ResourceUnit *ru, bool append=false);
 
    const QVector<QPair<Tree*, double> > trees() const { return mTrees; }
 
    Grid<float> &localGrid() { prepareGrids(); return mLocalGrid; }
 
signals:
 
public slots:
    // loading of trees
    int loadAll() { return load(QString()); }
    int load(const QString &filter);
 
    int filter(QString filter);
 
    int spatialFilter(QJSValue grid, QString filter);
 
    int removeMarkedTrees();
 
    int resetMarks();
 
    QJSValue tree(int index);
    QJSValue treeObject(int index);
 
 
//    int killPct(int pctfrom, int pctto, int number);
//    int killAll(); ///< kill all trees in the list
//    int kill(QString filter, double fraction);
    // management
//    int managePct(int pctfrom, int pctto, int number);
//    int manageAll(); ///< manage all trees in the list
    int kill(QString filter=QString());
 
    int harvest(QString filter=QString(), double fraction=1.);
 
    double percentile(int pct); 
//    void killSaplings(MapGridWrapper *wrap, int key); ///< kill all saplings that are on the area denoted by 'key' of the given grid (script access)
 
//    void removeSoilCarbon(MapGridWrapper *wrap, int key, double SWDfrac, double DWDfrac, double litterFrac, double soilFrac);
//    void slashSnags(MapGridWrapper *wrap, int key, double slash_fraction);
    void sort(QString statement); 
//    int filter(QString filter); ///< apply a filter on the list of trees (expression), return number of remaining trees.
//    int filterIdList(QVariantList idList); ///< apply filter in form of a list of ids, return number of remaining trees
    void randomize(); 
 
    double mean(QString expression, QString filter=QString()) { return aggregate_function( expression, filter, "mean"); }
    double sum(QString expression, QString filter=QString()) { return aggregate_function( expression, filter, "sum"); }
 
    void prepareStandGrid(QString type, QString custom_expression=QString());
    void exportStandGrid(QString file_name);
    FloatGrid &standGrid() {return mStandGrid; }
 
    int killSaplings(QString expression);
    double meanSaplings(QString expression, QString filter=QString()) { return aggregate_function_sapling(expression, filter, "mean"); }
    double sumSaplings(QString expression, QString filter=QString()) { return aggregate_function_sapling(expression, filter, "sum"); }
 
 
 
private:
    bool trace() const;
    int remove_percentiles(int pctfrom, int pctto, int number, bool management);
    int remove_trees(QString expression, double fraction, bool management);
    double aggregate_function(QString expression, QString filter, QString type);
    double aggregate_function_sapling(QString expression, QString filter, QString type);
    bool remove_single_tree(int index, bool harvest=true);
    void check_locks();
 
    // grid functions
    void prepareGrids();
    void runGrid(void (*func)(float &, int &, const Tree *, const FMTreeList *) );
 
    QVector<QPair<Tree*, double> > mTrees; 
    bool mResourceUnitsLocked;
    int mRemoved;
    FMStand *mStand; 
    int mStandId; 
    int mNumberOfStems; 
    bool mOnlySimulate; 
    QRectF mStandRect;
    FloatGrid mStandGrid; 
    Grid<int> mTreeCountGrid; 
    Grid<float> mLocalGrid; 
    Expression *mRunGridCustom;
    double *mRunGridCustomCell;
    friend void rungrid_custom(float &cell, int &n, const Tree *tree, const FMTreeList *list);
 
    QJSValue mTreeValue;
    ScriptTree *mTree;
 
 
    friend class ActThinning;
};
 
} // namespace
#endif // FMTREELIST_H