Subversion Repositories public iLand

/********************************************************************************************
**    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 "abe_global.h"
#include "actplanting.h"

#include "fmstp.h"
#include "fmstand.h"
#include "fomescript.h"
#include "fmtreelist.h"
#include "forestmanagementengine.h"

#include "model.h"
#include "mapgrid.h"
#include "resourceunit.h"
#include "resourceunitspecies.h"

#include "debugtimer.h"

namespace ABE {

/** @class ActPlanting
    @ingroup abe
    The ActPlanting class implements artificial regeneration (i.e., planting of trees).

  */


// Planting patterns
QVector<QPair<QString, int> > planting_patterns =QVector<QPair<QString, int> >()
<< QPair<QString, int>(
        "11"\
        "11", 2)
<< QPair<QString, int>("11111"\
                       "11111"\
                       "11111"\
                       "11111"\
                       "11111", 5)
<< QPair<QString, int>("1111111111"\
                       "1111111111"\
                       "1111111111"\
                       "1111111111"\
                       "1111111111"\
                       "1111111111"\
                       "1111111111"\
                       "1111111111"\
                       "1111111111"\
                       "1111111111", 10)
<< QPair<QString, int>("00110"\
                       "11110"\
                       "11111"\
                       "01111"\
                       "00110", 5)
<< QPair<QString, int>("0000110000"\
                       "0011111100"\
                       "0111111110"\
                       "0111111110"\
                       "1111111111"\
                       "1111111111"\
                       "0111111110"\
                       "0011111110"\
                       "0011111100"\
                       "0000110000", 10);
QStringList planting_pattern_names = QStringList() << "rect2" << "rect10" << "rect20" << "circle5" << "circle10";

QStringList ActPlanting::mAllowedProperties;


ActPlanting::ActPlanting(FMSTP *parent): Activity(parent)
{
    //mBaseActivity.setIsScheduled(true); // use the scheduler
    //mBaseActivity.setDoSimulate(true); // simulate per default
    if (mAllowedProperties.isEmpty())
        mAllowedProperties = QStringList() << Activity::mAllowedProperties
                                           << "species" << "fraction" << "height" << "age" << "clear"
                                           << "pattern" << "spacing" << "offset" << "random" << "n";

}

void ActPlanting::setup(QJSValue value)
{
    // check if regeneration is enabled
    if (GlobalSettings::instance()->model()->settings().regenerationEnabled == false)
        throw IException("Cannot set up planting acitivities when iLand regeneration module is disabled.");
    Activity::setup(value); // setup base events

    QJSValue items = FMSTP::valueFromJs(value, "items");
    mItems.clear();
    // iterate over array or over single object
    if ((items.isArray() || items.isObject()) && !items.isCallable()) {
        QJSValueIterator it(items);
        while (it.hasNext()) {
            it.next();
            if (it.name()==QStringLiteral("length"))
                continue;

            mItems.append(SPlantingItem());
            SPlantingItem &item = mItems.last();
            qDebug() << it.name() << ": " << FomeScript::JStoString(it.value());
            FMSTP::checkObjectProperties(it.value(), mAllowedProperties, "setup of planting activity:" + name() + "; " + it.name());

            item.setup(it.value());
        }
    } else {
        mItems.append(SPlantingItem());
        SPlantingItem &item = mItems.last();
        FMSTP::checkObjectProperties(items, mAllowedProperties, "setup of planting activity:" + name());

        item.setup(items);
    }
    mRequireLoading = false;
    for (QVector<SPlantingItem>::const_iterator it=mItems.constBegin(); it!=mItems.constEnd(); ++it) {
        if (it->clear == true)
            mRequireLoading = true;
    }
}

bool ActPlanting::execute(FMStand *stand)
{
    qCDebug(abe) << stand->context() << "execute of planting activity....";
    DebugTimer time("ABE:ActPlanting:execute");

    for (int s=0;s<mItems.count();++s) {
        mItems[s].run(stand);
    }


    return true;
}

QStringList ActPlanting::info()
{
    QStringList lines = Activity::info();

    foreach(const SPlantingItem &item, mItems) {
        lines << "-";
        lines << QString("species: %1").arg(item.species->id());
        lines << QString("fraction: %1").arg(item.fraction);
        lines << QString("clear: %1").arg(item.clear);
        lines << QString("pattern: %1").arg(item.group_type>-1?planting_pattern_names[item.group_type]:"");
        lines << QString("spacing: %1").arg(item.spacing);
        lines << QString("offset: %1").arg(item.offset);
        lines << QString("random: %1").arg(item.group_random_count>0);
        lines << "/-";
    }
    return lines;
}

void ActPlanting::runSinglePlantingItem(FMStand *stand, QJSValue value)
{
    if (!stand) return;
    if (FMSTP::verbose())
        qCDebug(abe()) << "run Single Planting Item for Stand" << stand->id();
    DebugTimer time("ABE:runSinglePlantingItem");
    SPlantingItem item;
    item.setup(value);

    item.run(stand);

}




bool ActPlanting::SPlantingItem::setup(QJSValue value)
{

    QString species_id = FMSTP::valueFromJs(value, "species",QString(), "setup of planting item for planting activity.").toString();
    species = GlobalSettings::instance()->model()->speciesSet()->species(species_id);
    if (!species)
        throw IException(QString("'%1' is not a valid species id for setting up a planting item.").arg(species_id));
    fraction = FMSTP::valueFromJs(value, "fraction", "0").toNumber();
    height = FMSTP::valueFromJs(value, "height", "0.05").toNumber();
    age = FMSTP::valueFromJs(value, "age", "1").toInt();
    clear = FMSTP::valueFromJs(value, "clear", "false").toBool();

    // pattern
    QString group = FMSTP::valueFromJs(value, "pattern", "").toString();
    group_type = planting_pattern_names.indexOf(group);
    if (!group.isEmpty() && group!="undefined" && group_type==-1)
        throw IException(QString("Planting-activity: the pattern '%1' is not valid!").arg(group));
    spacing = FMSTP::valueFromJs(value, "spacing", "0").toInt();
    offset = FMSTP::valueFromJs(value, "offset", "0").toInt();

    bool random = FMSTP::boolValueFromJs(value, "random", false);
    if (random)
        group_random_count = FMSTP::valueFromJs(value, "n", "0").toInt();
    else
        group_random_count = 0;

    grouped = group_type >= 0;
    return true;
}

void ActPlanting::SPlantingItem::run(FMStand *stand)
{
    QRectF box = ForestManagementEngine::instance()->standGrid()->boundingBox(stand->id());
    const MapGrid *sgrid = ForestManagementEngine::instance()->standGrid();
    Model *model = GlobalSettings::instance()->model();
    GridRunner<float> runner(model->grid(), box);
    if (!grouped) {
        // distribute saplings randomly.
        // this adds saplings to SaplingCell (only if enough slots are available)
        while (runner.next()) {
            if (sgrid->standIDFromLIFCoord(runner.currentIndex()) != stand->id())
                continue;
            //
            if (drandom() < fraction) {
                ResourceUnit *ru = model->ru(runner.currentCoord());
                ru->saplingCell(runner.currentIndex())->addSapling(height, age, species->index());
            }
        }
    } else {
        // grouped saplings
        const QString &pp = planting_patterns[group_type].first;
        int n = planting_patterns[group_type].second;

        if (spacing==0 && group_random_count == 0) {
            // pattern based planting (filled)
            runner.reset();
            while (runner.next()) {
                QPoint qp = runner.currentIndex();
                if (sgrid->standIDFromLIFCoord(qp) != stand->id())
                    continue;
                // check location in the pre-defined planting patterns
                int idx = (qp.x()+offset)%n + n*((qp.y()+offset)%n);
                if (pp[idx]=='1') {
                    ResourceUnit *ru = model->ru(runner.currentCoord());
                    SaplingCell *sc = ru->saplingCell(qp);

                    if (clear) {
                        // clear all sapling trees on the cell
                        model->saplings()->clearSaplings(sc,ru,true);
                    }
                    sc->addSapling(height,age,species->index());
                }
            }
        } else {
            // pattern based (with spacing / offset, random...)
            int ispacing = spacing / cPxSize;
            QPoint p = model->grid()->indexAt(box.topLeft())-QPoint(offset, offset);
            QPoint pstart = p;
            QPoint p_end = model->grid()->indexAt(box.bottomRight());
            QPoint po;
            p.setX(qMax(p.x(),0)); p.setY(qMax(p.y(),0));

            int n_ha = group_random_count * box.width()*box.height()/10000.;
            bool do_random = group_random_count>0;

            while( p.x() < p_end.x() && p.y() < p_end.y()) {
                if (do_random) {
                    // random position!
                    if (n_ha--<=0)
                        break;
                    // select a random position (2m grid index)
                    p = model->grid()->indexAt(QPointF( nrandom(box.left(), box.right()), nrandom(box.top(), box.bottom()) ));
                }

                // apply the pattern....
                for (int y=0;y<n;++y) {
                    for (int x=0;x<n;++x) {
                        po=p + QPoint(x,y);
                        if (sgrid->standIDFromLIFCoord(po) != stand->id())
                            continue;
                        ResourceUnit *ru = model->ru(model->grid()->cellCenterPoint(po));
                        SaplingCell *sc = ru->saplingCell(po);

                        if (clear) {
                            // clear all sapling trees
                            model->saplings()->clearSaplings(sc,ru,true);
                        }
                        sc->addSapling(height,age,species->index());
                    }
                }
                if (!do_random) {
                    // apply offset
                    p.rx() += ispacing;
                    if (p.x()>= p_end.x()) {
                        p.rx() = pstart.x();
                        p.ry() += ispacing;
                    }
                }
            }
        }
    }


}



} // namesapce