PhotonMap.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __PHOTON_MAP_H
#define __PHOTON_MAP_H

#include <esg/energy/Photon.h>
#include <esg/energy/PhotonsIterator.h>
#include <esg/List.h>
#include <vector>

namespace esg {

class OGSCENE_EXPORT PhotonMap {
        friend class Iterator;

    public:
        class Iterator : public PhotonsIterator {
            protected:
                const PhotonMap * _pMap;
                unsigned          _actPhoton;
                
            public:
                Iterator(const PhotonMap *pm)
                    : _pMap(pm), _actPhoton(1) {}

                virtual bool hasNext() {
                    return (_actPhoton <= _pMap->_storedPhotons);
                }
                
                virtual Photon* next() {
                    if (_actPhoton > _pMap->_storedPhotons)
                        return NULL;
                    Photon* ret = &(_pMap->_map[_actPhoton]);
                    _actPhoton++;
                    return ret;
                }
        };

        
    protected:
        Photon*  _map;           
        unsigned _storedPhotons; 
        float    _bboxMin[3];    
        float    _bboxMax[3];

        class NearestPhotons; 

    protected:
        void _build (const vector<Photon>&);
        void _median_split (Photon**, int, int, int, const int);
        void _balance_segment (Photon **, Photon **, int, int, int);
        void _locate_photons (NearestPhotons * const, unsigned) const;
        
    public:
        PhotonMap();

        PhotonMap(const vector<Photon>& photons);

        virtual ~PhotonMap();

        virtual void set(const vector<Photon>& photons);

        virtual unsigned numPhotons (void) const;
        
        virtual vector<Photon*>* getNeighbourhood(const Vector3& spoint,
                                                  const Vector3* snormal,
                                                  float          maxdist,
                                                  unsigned       nphotons
                                                  ) const;
        
        virtual bool getIrradiance(const Vector3& spoint,
                                   const Vector3* snormal,
                                   float          maxdist,
                                   unsigned       nphotons,
                                   Vector3&       irrad) const;

        virtual PhotonsIterator* iterator() const {
            return new PhotonMap::Iterator(this);
        }
};


class PhotonMap::NearestPhotons {
    public:
        int            max;
        int            found;
        bool           gotHeap;
        float          pos[3];
        float         *dist2;
        const Photon **index;
        const Photon  *photons; // original array of photons
        unsigned       halfStoredPhotons;

    public:
        NearestPhotons(unsigned n, const Vector3 p, float maxDist,
                       const Photon * pa, unsigned hsp)
            : max(n), found(0), gotHeap(false),
              photons(pa), halfStoredPhotons(hsp) {
            pos[0] = p.x; pos[1] = p.y; pos[2] = p.z;
            dist2 = new float [n+1];
            index = new const Photon* [n+1];
            dist2[0] = maxDist * maxDist;
        }
        
        ~NearestPhotons() { delete [] dist2; delete [] index; }
        
        Photon& operator ()(int i) const {
            return (Photon&) *(index[i+1]);
        }
        
        int numPhotons () const { return found-1; }
        
        Vector3 pointLocation() const { return Vector3(pos[0],pos[1],pos[2]); }
}; // class PhotoMap::NearestPhotons

    
}; // class PhotonMap

#endif // __PHOTON_MAP_H

---