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/>.
********************************************************************************************/

#ifndef SCRIPTGLOBAL_H
#define SCRIPTGLOBAL_H

#include <QObject>
#include <QVariant>
#include <QJSValue>

// Scripting Interface for MapGrid
class MapGrid; // forward
class MapGridWrapper: public QObject
{
    Q_OBJECT
    Q_PROPERTY(int valid READ isValid)
    Q_PROPERTY(QString name READ name)
public:
    MapGridWrapper(QObject *parent=0);
    ~MapGridWrapper();
    static void addToScriptEngine(QJSEngine &engine);
    MapGrid *map() const { return mMap; } ///< acccess for C++ classes
    bool isValid() const; ///< returns true if map is successfully loaded
    QString name() const;
    //

public slots:
    // query
    double area(int id); ///< retrieve the area (m2) of the polygon denoted by 'id'
    // actions
    void load(QString file_name);
    void saveAsImage(QString file);
    void paint(double min_value, double max_value);
    // active modifications of the map
    void clear(); ///< clears the map (set all values to 0)
    void clearProjectArea(); ///< clear the project area (set to 0), but copy mask with pixels from "outside of project area" (i.e., -1, -2)
    /// paint a shape on the stand grid with id stand_id
    /// paint_function is a valid expression (paramters: x, y as *metric* coordinates)
    /// if wrap_around=true, then the shape is wrapped around the edges of the simulated area (torus)
    void createStand(int stand_id, QString paint_function, bool wrap_around);

    /// copy a bit of the source-map 'source' to this map. The
    /// source rectangle is given by coordinates (x1/y1) to (x2/y2).
    /// The rectangle will be blitted to the new coordinates destx/desty (moved from x1/y1).
    /// id_in: the id of the polygon to copy, id: the id of the pixels in the target
    /// return the size (ha) of the valid thing
    double copyPolygonFromRect(MapGridWrapper *source, int id_in, int id, double destx, double desty, double x1, double y1, double x2, double y2);

    void createMapIndex(); ///< call after creating stands with copyPolygonFromRect

private:
    MapGrid *mMap;
    bool mCreated;

};

/** ScriptGlobal contains a set of
  functions and properties that are accessible by JavaScript.
  */
class Model;
class ScriptGlobal : public QObject
{
    Q_OBJECT
    // read only properties
    Q_PROPERTY(int year READ year)
    Q_PROPERTY(int resourceUnitCount READ resourceUnitCount)
    Q_PROPERTY(QString currentDir WRITE setCurrentDir READ currentDir)
    Q_PROPERTY(double worldX READ worldX)
    Q_PROPERTY(double worldY READ worldY)
    Q_PROPERTY(bool qt5 READ qt5)
    Q_PROPERTY(int msec READ msec)
    Q_PROPERTY(QJSValue viewOptions READ viewOptions WRITE setViewOptions)


public:
    ScriptGlobal(QObject *parent=0);
    static void setupGlobalScripting();
    // properties accesible by scripts
    bool qt5() const {return true; } ///< is this the qt5-model? (changes in script object creation)
    int msec() const; ///< the milliseconds since the start of the day
    int year() const; ///< current year in the model
    int resourceUnitCount() const; ///< get number of resource uinit
    QString currentDir() const { return mCurrentDir; } ///< current execution directory (default is the Script execution directory)
    void setCurrentDir(QString newDir) { mCurrentDir = newDir; } ///< set current working dir
    double worldX(); ///< extent of the world (without buffer) in meters (x-direction)
    double worldY(); ///< extent of the world (without buffer) in meters (y-direction)

    // general functions
    static void loadScript(const QString &fileName);
    static QString executeScript(QString cmd);
    static QString executeJSFunction(QString function);
    static QObject *scriptOutput; ///< public "pipe" for script output (is redirected to GUI if available)
    static QString formattedErrorMessage(const QJSValue &error_value, const QString &sourcecode);

    // view options
    /* View options:
     * * type: {...}
     * * species: bool
     * * shade: bool
     *
    */
    QJSValue viewOptions(); ///< retrieve current viewing options (JS - object)
    void setViewOptions(QJSValue opts); ///< set current view options

public slots:
    // system stuff
    QVariant setting(QString key); ///< get a value from the global xml-settings (returns undefined if not present)
    void set(QString key, QString value); ///< set the value of a setting
    void print(QString message); ///< print the contents of the message to the log
    void alert(QString message); ///< shows a message box to the user (if in GUI mode)
    void include(QString filename); ///< "include" the given script file and evaluate. The path is relative to the "script" path
    // file stuff
    QString defaultDirectory(QString dir); ///< get default directory of category 'dir'
    QString path(QString filename); ///< get a path relative to the project main folder
    QString loadTextFile(QString fileName); ///< load content from a text file in a String (@sa CSVFile)
    void saveTextFile(QString fileName, QString content); ///< save string (@p content) to a text file.
    bool fileExists(QString fileName); ///< return true if the given file exists.
    void systemCmd(QString command); ///< execute system command (e.g., copy files)
    // add trees
    int addSingleTrees(const int resourceIndex, QString content); ///< add single trees
    int addTrees(const int resourceIndex, QString content); ///< add tree distribution
    int addTreesOnMap(const int standID, QString content); ///< add trees (distribution mode) for stand 'standID'
    // add saplings
    int addSaplingsOnMap(MapGridWrapper *map, const int mapID, QString species, int px_per_hectare, double height, int age);
    // enable/disable outputs
    bool startOutput(QString table_name); ///< starts output 'table_name'. return true if successful
    bool stopOutput(QString table_name); ///< stops output 'table_name'. return true if successful
    // miscellaneous stuff
    void setViewport(double x, double y, double scale_px_per_m); ///< set the viewport of the main project area view
    bool screenshot(QString file_name); ///< make a screenshot from the central viewing widget
    void repaint(); ///< force a repainting of the GUI visualization (if available)
    bool gridToFile(QString grid_type, QString file_name); ///< create a "ESRI-grid" text file 'grid_type' is one of a fixed list of names, 'file_name' the ouptut file location

    /// return Javascript grid for given type
    QJSValue grid(QString type);
    /// return a grid with the basal area of the given species (resource unit resolution)
    QJSValue speciesShareGrid(QString species);
    /// return a grid (level of resource units) with the result of an expression evaluated in the context of the resource unit.
    QJSValue resourceUnitGrid(QString expression);

    // DOES NOT FULLY WORK
    bool seedMapToFile(QString species, QString file_name); ///< save the "seedmap" (i.e. a grid showing the seed distribution) as ESRI rastser file
    void wait(int milliseconds); ///< wait for 'milliseconds' or (if ms=-1 until a key is pressed)
    // vegetation snapshots
    bool saveModelSnapshot(QString file_name);
    bool loadModelSnapshot(QString file_name);
    bool saveStandSnapshot(int stand_id, QString file_name);
    bool loadStandSnapshot(int stand_id, QString file_name);
    // agent-based-model of forest management
    void reloadABE();

    // UI interface
    void setUIshortcuts(QJSValue shortcuts); ///< set a list of JS shortcuts in the UI

    void test_tree_mortality(double thresh, int years, double p_death);
private:
    void throwError(const QString &errormessage);
    QString mCurrentDir;
    Model *mModel;
};

/** The ScriptObjectFactory can instantiate objects of other C++ (QObject-based) types.
 *  This factory approach is used because the V8 (QJSEngine) does not work with
 *  the "new" way of creating objects.
*/
class ScriptObjectFactory: public QObject
{
    Q_OBJECT
public:
    ScriptObjectFactory(QObject *parent=0);
public slots:
    QJSValue newCSVFile(QString filename); ///< create a new instance of CSVFile and return it
    QJSValue newClimateConverter(); ///< create new instance of ClimateConverter and return it
    QJSValue newMap(); ///< create new instance of Map and return it
    int stats() {return mObjCreated;} ///< return the number of created objects
private:
    int mObjCreated;

};

#endif // SCRIPTGLOBAL_H