sourceimage.h

/*

  This file is a part of GRALE, a library to facilitate the simulation
  and inversion of gravitational lenses.

  Copyright (C) 2008-2012 Jori Liesenborgs

  Contact: jori.liesenborgs@gmail.com
  
  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 2 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, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  
*/

#ifndef GRALE_SOURCEIMAGE_H

#define GRALE_SOURCEIMAGE_H

#include "graleconfig.h"
#include "sourceplane.h"
#include "constants.h"
#include <string>

namespace grale
{

class GRALE_IMPORTEXPORT SourceImage : public errut::ErrorBase
{
public:
        enum SourceType { Circle, Ellipse, Polygon, Discrete, Point };
protected:      
        // angle is specified in degrees
        SourceImage(SourceType t, Vector2D<double> angularpos, double angle, double brightnessScale);
public:
        virtual ~SourceImage();

        SourceType getSourceType() const                                        { return stype; }
        
        // creates an unattached copy
        virtual SourceImage *createCopy() const = 0;
        virtual bool isSerializable() const                                     { return false; }
                
        bool attach(SourcePlane *parentplane, uint16_t srcid);
        bool release();
        SourcePlane *getParentPlane()                                           { return parentplane; }
        uint64_t getID() const                                                  { return id; }
        
        double getIntensity(Vector2D<double> beta) const;
        bool isSourceInRange(Vector2D<double> beta, double radius) const; 

        double getD_s() const                                                   { return parentplane->getD_s(); }
        double getD_ds() const                                                  { return parentplane->getD_ds(); }
        Vector2D<double> getAngularPosition() const                             { return pos; }
        void addToAngularPosition(Vector2D<double> p)                           { pos += p; }
        void setAngularPosition(Vector2D<double> p)                             { pos = p; }
        void addToAngle(double ang)                                             { angle += ang; theta = (angle/180.0)*CONST_PI; }
        void setAngle(double ang)                                               { angle = ang; theta = (angle/180.0)*CONST_PI; }
        double getAngle() const                                                 { return angle; }
        
        bool write(serut::SerializationInterface &si) const;
        static bool read(serut::SerializationInterface &si,SourceImage **source,std::string &errstr);
protected:
        double getBrightnessScale() const                                       { return m_brightnessScale; }
        
        virtual bool writeInternal(serut::SerializationInterface &si) const;
        virtual bool readInternal(serut::SerializationInterface &si);
        virtual double getIntensityInternal(Vector2D<double> diff) const                { return 0; }
        virtual double getMaxRadius() const                                             { return 0; }
private:
        Vector2D<double> pos;
        double angle,theta;
        SourcePlane *parentplane;
        SourceType stype;
        uint16_t id;
        double m_brightnessScale;
        
        friend class SourcePlane;
};

inline double SourceImage::getIntensity(Vector2D<double> beta) const
{
        Vector2D<double> diff = beta - pos;
        Vector2D<double> diff2(diff.getX()*COS(theta) + diff.getY()*SIN(theta), 
                              -diff.getX()*SIN(theta) + diff.getY()*COS(theta));
        
        return m_brightnessScale*getIntensityInternal(diff2);
}

inline bool SourceImage::isSourceInRange(Vector2D<double> beta, double radius) const
{
        Vector2D<double> diff = beta - pos;
        Vector2D<double> diff2(diff.getX()*COS(theta) + diff.getY()*SIN(theta), 
                              -diff.getX()*SIN(theta) + diff.getY()*COS(theta));
        
        double d = diff2.getLength() - radius;

        if (d < getMaxRadius())
                return true;
        return false;
}

} // end namespace

#endif // GRALE_SOURCEIMAGE_H