Subversion Repositories public iLand

#ifndef LIGHTROOM_H
#define LIGHTROOM_H

#include "grid.h"
#include "solarradiation.h"
#include "hemigrid.h"
#include "expression.h"

class LightRoomObject
{
public:
    LightRoomObject(): m_radiusFormula(0) {}
    ~LightRoomObject();
    /** Test if the ray starting at "p" hits the object.
        the ray has direction azimuth/elevation and starts from the position denoted by p_x, p_y and p_z
        @return 1: object is hit, 0: object is missed, -1: p is inside the object.*/
    int hittest(const double p_x, const double p_y, const double p_z,
                 const double azimuth_rad, const double elevation_rad);
    /** sets up a tree as the obstacle.
        @param height treehight in meter
        @param crownheight height of the start of crown (above ground) in meter
        @param formula (as string representation) that yields the radius as f(relativeheight).
              the variable of the formula is 0 for ground 1 for tree top. */
    void setuptree(const double height, const double crownheight, const QString &formula);
    /// returns true if there is no way that a ray hits the object starting from p.
    bool noHitGuaranteed(const double p_x, const double p_y, const double p_z);
    double maxHeight() const { return m_height; }
    double maxRadius() const { return m_baseradius; }
private:
    Expression *m_radiusFormula; ///< formula for calculation of crown widht as f(relative_height)
    double m_baseradius; ///< maximum radius of the crown (at the bottom of the crown) [m]
    double m_height; ///< treehight [m]
    double m_crownheight; ///< height of the beginning of the living crown [m]
    QVector<double> m_treeHeights;
};

/** virtual room to do some light-experiments.
  The basic use of this class is to derive the size/pattern of the light-influence FON for a single tree.
  It uses SolarRadiation for the calculation of global radiation and HemiGrid to calculate and store the results.
  This calculation is done for each node of a 3D space and afterwards accumulated into a 2D pattern. */
class LightRoom
{
public:
    LightRoom();
    ~LightRoom() { if (m_roomObject) delete m_roomObject; }
    /// setup the spatial grid.
    void setup(const double dimx, const double dimy, const double dimz,
               const double cellsize, const double hemigridsize,
               const double latitude=48., const double diffus_frac=0.5);
    void setLightRoomObject(LightRoomObject *lro) { if (m_roomObject) delete m_roomObject; m_roomObject = lro; }
    void setAggregationMode(const int mode ) { m_aggregationMode = mode; }
    /// calculate a full hemiview image from given point
    double calculateGridAtPoint(const double p_x, const double p_y, const double p_z, bool fillShadowGrid=true);
    /// calculate a hemigrid for each node of the grid (store results in m_3dvalues).
    /// @return fraction of "blocked" radiation [0..1]. -1: point inside the object
    void calculateFullGrid();
        /// access to the hemigrid
    const HemiGrid &shadowGrid() const { return m_shadowGrid; }
    const HemiGrid &solarGrid() const { return m_solarGrid; }
    const FloatGrid &result() const { return m_2dvalues; }
    double centerValue() const { return m_centervalue; }

private:
    //Grid< QVector<float> > m_3dvalues; ///< storage for resulting 3d light values
    FloatGrid m_2dvalues; ///< resulting 2d pattern (derived from 3dvalues)
    int m_countX; ///< size of the grid in x-direction
    int m_countY;
    int m_countZ;
    double m_cellsize; ///< length of the side of one cell (equal for all 3 directions)
    double m_solarrad_factor; ///< multiplier accounting for the difference of total radiation and the used part of the sky (45°)
    HemiGrid m_solarGrid; ///< grid used for solar radiation (direct + diffus)
    HemiGrid m_shadowGrid; ///< grid used for shadow calculations
   double m_centervalue; ///< value (shadow*height) of the tree center (relative) [-]
   int m_aggregationMode; ///< aggregation mod

    LightRoomObject *m_roomObject;
};

#endif // LIGHTROOM_H