PhotonMapEnergy.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __PHOTON_MAP_ENERGY_H
#define __PHOTON_MAP_ENERGY_H

#include <esg/energy/EnergyCoat.h>
#include <esg/geometry/BVList.h>
#include <esg/geometry/FDH6.h>
#include <esg/energy/Photon.h>
#include <esg/energy/PhotonMap.h>
#include <esg/energy/IrradianceCache.h>

namespace esg {

class OGSCENE_EXPORT PhotonMapEnergy : public EnergyCoat {
protected:
        vector<Photon>    _globalPhotons;
        vector<Photon>    _causticPhotons;
        PhotonMap *       _pGlobalMap;
        PhotonMap *       _pCausticsMap;
        IrradianceCache * _pIrradCache;
    
public:
        PhotonMapEnergy()
            : EnergyCoat(NULL),
              _pGlobalMap(NULL),
              _pCausticsMap(NULL),
              _pIrradCache(NULL) {}

        virtual ~PhotonMapEnergy() {}

        virtual Type type(void) const { return MAP3D; }


        const PhotonMap* getGlobalMap() const { return _pGlobalMap; }

        const PhotonMap* getCausticsMap() const { return _pCausticsMap; }

        IrradianceCache* const getIrradianceCache() { return _pIrradCache; }
        
        void storeGlobalPhoton(const Photon& photon) {
            if (!_pGlobalMap) _globalPhotons.push_back(photon);
        }

        void storeCausticPhoton(const Photon& photon) {
            if (!_pCausticsMap) _causticPhotons.push_back(photon);
        }

        bool buildGlobalMap() {
            if (_pGlobalMap) return false;
            _pGlobalMap = new PhotonMap(_globalPhotons);
            _globalPhotons.clear();
            return true;
        }

        bool buildCausticsMap() {
            if (_pCausticsMap) return false;
            _pCausticsMap = new PhotonMap(_causticPhotons);
            _causticPhotons.clear();
            return true;
        }

        bool buildIrradianceCache(float wFactor, float dist) {
            if (_pIrradCache) {
                delete _pIrradCache;
                _pIrradCache = NULL;
            }
            try {
                _pIrradCache = new IrradianceCache(wFactor, dist);
            } catch(invalid_argument e1) {
                cerr << e1.what() << endl;
                return false;
            } catch(runtime_error e2) {
                cerr << e2.what() << endl;
                return false;
            }
            return true;
        }

        bool isGlobalMapBuilt() const {
            return ((_pGlobalMap) ? true : false);
        }
        
        bool isCausticsMapBuilt() const {
            return ((_pCausticsMap) ? true : false);
        }

        unsigned numGlobalPhotons() const {
            return ((_pGlobalMap) ? _pGlobalMap->numPhotons() : 0);
        }

        unsigned numCausticPhotons() const {
            return ((_pCausticsMap) ? _pCausticsMap->numPhotons() : 0);
        }

        PhotonsIterator* globalMapIterator() const {
            return ((_pGlobalMap) ? _pGlobalMap->iterator() : NULL);
        }

        PhotonsIterator* causticsMapIterator() const {
            return ((_pCausticsMap) ? _pCausticsMap->iterator() : NULL);
        }


    /*
     * Average irradiance at the surface point
     */
    //Vector3 irradiance (const NearestPhotons& /* vicinity of point */,
        //              const Vector3*        /* oriented normal   */);

}; // PhotonMapEnergy

}; // namespace

#endif // __PHOTON_MAP_ENERGY_H

---