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 "barkbeetlescript.h"

#include "barkbeetlemodule.h"
#include "outputmanager.h"
#include "helper.h"
#include "spatialanalysis.h"
#include "scriptgrid.h"
#include "mapgrid.h"
#include "scriptglobal.h"

/** @class BarkBeetleScript
    @ingroup beetlemodule
    BarkBeetleScript is the scripting shell for the bark beetle module.
  */

BarkBeetleScript::BarkBeetleScript(QObject *)
{
    mBeetle = 0;
}

void BarkBeetleScript::test(QString value)
{
    qDebug() << value;
}

void BarkBeetleScript::init(QJSValue fun)
{
    QJSValueList args = QJSValueList() << 0 << 0;

    if (!fun.isCallable()) {
        qDebug() << "no valid function in init!!";
        return;
    }
    for (int y=0;y < mBeetle->mGrid.sizeY(); ++y)
        for (int x=0;x < mBeetle->mGrid.sizeX(); ++x) {
            args[0] = x; args[1] = y;
            double result = fun.call(args).toNumber();
            mBeetle->mGrid.valueAtIndex(x,y).n = result;
        }
}

void BarkBeetleScript::run(QJSValue fun)
{
    QJSValueList args = QJSValueList() << 0 << 0;

    if (!fun.isCallable()) {
        qDebug() << "no valid function in run!!";
        return;
    }
    for (int y=0;y < mBeetle->mGrid.sizeY(); ++y)
        for (int x=0;x < mBeetle->mGrid.sizeX(); ++x) {
            args[0] = x; args[1] = y;
            fun.call(args);
        }
}

double BarkBeetleScript::pixelValue(int ix, int iy)
{
    if (mBeetle->mGrid.isIndexValid(ix,iy)) {
        return mBeetle->mGrid.valueAtIndex(ix, iy).n;
    } else {
        return -9999;
    }
}

void BarkBeetleScript::setPixelValue(int ix, int iy, double val)
{
    if (mBeetle->mGrid.isIndexValid(ix,iy)) {
        mBeetle->mGrid.valueAtIndex(ix, iy).n = val;
    }
}

double BarkBeetleScript::generations(int ix, int iy)
{
    if (mBeetle->mGrid.isIndexValid(ix,iy)) {
        return mBeetle->mRUGrid.valueAt( mBeetle->mGrid.cellCenterPoint(QPoint(ix,iy)) ).generations;
    } else {
        return -9999;
    }

}

void BarkBeetleScript::reloadSettings()
{
    mBeetle->loadParameters();
}

void BarkBeetleScript::newYear()
{
    int y = mBeetle->manualYearBegin();
    qDebug() << "Barkbeetle-module: year=" << y;
}

void BarkBeetleScript::runBB(int iteration)
{
    qDebug() << "running bark beetle module....";
    mBeetle->run(iteration);
    GlobalSettings::instance()->outputManager()->save(); // just make sure database outputs are properly written
}

void BarkBeetleScript::clear()
{
    qDebug() << "clear bark beetle module....";
    mBeetle->clearGrids();
    mBeetle->loadParameters();
    mBeetle->loadAllVegetation();
}

bool BarkBeetleScript::gridToFile(QString type, QString filename)
{
    if (!GlobalSettings::instance()->model())
        return false;
    QString result;
    result = gridToESRIRaster(mBeetle->mLayers, type); // use a specific value function (see above)

    if (result.isEmpty()) {
        result = gridToESRIRaster(mBeetle->mRULayers, type); // try RU-level indicators
    }

    if (!result.isEmpty()) {
        filename = GlobalSettings::instance()->path(filename);
        Helper::saveToTextFile(filename, result);
        qDebug() << "saved grid to " << filename;
        return true;
    }
    qDebug() << "could not save gridToFile because" << type << "is not a valid grid.";
    return false;

}

QJSValue BarkBeetleScript::grid(QString type)
{
    int idx = mBeetle->mLayers.indexOf(type);
    if (idx<0)
        qDebug() << "ERROR: BarkBeetleScript:grid(): invalid grid" << type;
    // this is a copy
    Grid<double> *damage_grid = mBeetle->mLayers.copyGrid(idx);

    QJSValue g = ScriptGrid::createGrid(damage_grid, type);
    return g;
}

int BarkBeetleScript::damagedArea(int threshold, QString fileName)
{
    // get damage grid:
    Grid<double> *damage_grid = mBeetle->mLayers.copyGrid(mBeetle->mLayers.indexOf("dead"));
    SpatialAnalysis spat;
    QList<int> patches = spat.extractPatches(*damage_grid, threshold+1, fileName);
    int n=0, size=0;
    for (int i=0;i<patches.count();++i)
        if (patches[i]>threshold) {
            size+=patches[i];
            n++;
        }
    qDebug() << "BarkBeetleScript:damagedArea:" << n << "patches (area=" << size << ") above threshold" << threshold;
    delete damage_grid;
    return size;

}

int BarkBeetleScript::clearInfestedPixels(QJSValue standmap, int stand_id, double fraction)
{
    MapGridWrapper *gr = qobject_cast<MapGridWrapper*> ( standmap.toQObject() );
    if (!gr || !gr->map()) {
        qDebug() << "BarkBeetleScript::clearInfestedPixels: no valid stand-map!";
        return 0;
    }
    QRectF box = gr->map()->boundingBox(stand_id);
    //GridRunner<BarkBeetleCell> runner(mBeetle->mGrid, box);
    GridRunner<int> runner(gr->map()->grid(), box);
    int n_cleared = 0;
    while (runner.next()) {
        if (*runner.current() == stand_id) {
            BarkBeetleCell &bbc = mBeetle->mGrid.valueAt( runner.currentCoord() );
            if (bbc.infested) {
                if (fraction==1. || drandom()<fraction) {
                    bbc.infested = false;
                    n_cleared++;
                }
            }
        }
    }
    return n_cleared;
}

bool BarkBeetleScript::setInfested(int x, int y)
{
    if (!mBeetle->mGrid.isIndexValid(QPoint(x,y))) {
        qDebug() << "invalid index in BarkBeetleScript::setInfested(): x:" << x << "y:" << y;
        return false;
    }
    BarkBeetleCell &c = mBeetle->mGrid.valueAtIndex(QPoint(x,y));
    if (!c.isHost() || c.killed)
        return false;
    c.setInfested(true);
    c.outbreakYear = mBeetle->internalYear();
    return true;
}

bool BarkBeetleScript::simulate()
{
    return mBeetle->simulate();
}

void BarkBeetleScript::setSimulate(bool do_simulate)
{
    mBeetle->setSimulate(do_simulate);
}

bool BarkBeetleScript::enabled()
{
    return mBeetle->enabled();
}

void BarkBeetleScript::setEnabled(bool do_set_enable)
{
    mBeetle->setEnabled(do_set_enable);
}