cmdimageplane.h

/*

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

  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 CMDIMAGEPLANE_H

#define CMDIMAGEPLANE_H

#include <shellp/shellcommand.h>
#include <shellp/shellcmdrealarg.h>
#include <shellp/shellcmdintarg.h>
#include <shellp/shellcmdstringarg.h>
#include <shellp/shellcmdboolarg.h>
#include <grale/vector2d.h>

namespace grale
{
        class GravitationalLens;
}

namespace shellp
{
        class IOSystem;
}

class CmdImagePlane : public shellp::ShellCommand
{
public:
        CmdImagePlane(const std::string &cmdname);
        ~CmdImagePlane();
protected:
        double GetX1() const                                                            { return x1arg->getValue(); }
        double GetX2() const                                                            { return x2arg->getValue(); }
        double GetY1() const                                                            { return y1arg->getValue(); }
        double GetY2() const                                                            { return y2arg->getValue(); }
        int GetNumX() const                                                             { return numxarg->getValue(); }
        int GetNumY() const                                                             { return numyarg->getValue(); }
protected:
        shellp::ShellCmdRealArg *x1arg,*y1arg,*x2arg,*y2arg;
        shellp::ShellCmdIntArg *numxarg,*numyarg;
};

class CmdImagePlaneLocal : public CmdImagePlane
{
public:
        CmdImagePlaneLocal(const std::string &cmdname);
        ~CmdImagePlaneLocal();
        bool execute();
};

class CmdImagePlaneRemote : public CmdImagePlane
{
public:
        CmdImagePlaneRemote(const std::string &cmdname);
        ~CmdImagePlaneRemote();
        bool execute();
private:
        shellp::ShellCmdStringArg *ipstrarg;
        shellp::ShellCmdIntArg *portarg;
};

class CmdImagePlanePlotGnuplot : public shellp::ShellCommand
{
public:
        CmdImagePlanePlotGnuplot(const std::string &cmdname);
        ~CmdImagePlanePlotGnuplot();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdBoolArg *imgarg,*srcarg,*critarg,*caustarg;
        shellp::ShellCmdStringArg *xlabelarg,*ylabelarg;
        shellp::ShellCmdBoolArg *colorarg;
        shellp::ShellCmdIntArg *fntsizearg;
        shellp::ShellCmdBoolArg *gridarg;
        shellp::ShellCmdIntArg *m_pSubSample;
        shellp::ShellCmdBoolArg *m_pFlipXArg;
};

class CmdImagePlanePlotPNG : public shellp::ShellCommand
{
public:
        CmdImagePlanePlotPNG(const std::string &cmdname);
        ~CmdImagePlanePlotPNG();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdBoolArg *imgarg,*srcarg,*critarg,*caustarg;
        shellp::ShellCmdIntArg *m_pSubSample;
};

class CmdImagePlanePlotAscii : public shellp::ShellCommand
{
public:
        CmdImagePlanePlotAscii(const std::string &cmdname);
        ~CmdImagePlanePlotAscii();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdBoolArg *imgarg,*srcarg,*critarg,*caustarg;
        shellp::ShellCmdIntArg *m_pSubSample;
};

class CmdImagePlanePlotFITS : public shellp::ShellCommand
{
public:
        CmdImagePlanePlotFITS(const std::string &cmdname);
        ~CmdImagePlanePlotFITS();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdIntArg *m_pSubSample;
        shellp::ShellCmdBoolArg *m_pPlotImages;
};

class CmdImagePlanePlotMagnification : public shellp::ShellCommand
{
public:
        CmdImagePlanePlotMagnification(const std::string &cmdname);
        ~CmdImagePlanePlotMagnification();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
};

class CmdImagePlaneLensPlane : public shellp::ShellCommand
{
public:
        CmdImagePlaneLensPlane(const std::string &cmdname);
        ~CmdImagePlaneLensPlane();
        bool execute();
};

class CmdImagePlaneTraceBase : public shellp::ShellCommand
{
public:
        CmdImagePlaneTraceBase(const std::string &cmdName);
        ~CmdImagePlaneTraceBase();
protected:
        void ListPoint(shellp::IOSystem *pIOSys, grale::Vector2D<double> point);
        void ListPoint(shellp::IOSystem *pIOSys, grale::Vector2D<double> point, double magnification);
};

class CmdImagePlaneTraceBeta : public CmdImagePlaneTraceBase
{
public:
        CmdImagePlaneTraceBeta(const std::string &cmdName);
        ~CmdImagePlaneTraceBeta();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pXArg;
        shellp::ShellCmdRealArg *m_pYArg;
        shellp::ShellCmdIntArg *m_pNumIterationsArg;
        shellp::ShellCmdBoolArg *m_pMagnificationArg;
};

class CmdImagePlaneTraceTheta : public CmdImagePlaneTraceBase
{
public:
        CmdImagePlaneTraceTheta(const std::string &cmdName);
        ~CmdImagePlaneTraceTheta();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pXArg;
        shellp::ShellCmdRealArg *m_pYArg;
};

class CmdImagePlaneTimeDelay : public shellp::ShellCommand
{
public:
        CmdImagePlaneTimeDelay(const std::string &cmdName);
        ~CmdImagePlaneTimeDelay();
        bool execute();
private:
        void ListPoint(shellp::IOSystem *pIOSys, grale::Vector2D<double> point, double timeDelay);

        shellp::ShellCmdRealArg *m_pLensRedshiftArg;
        shellp::ShellCmdRealArg *m_pXArg;
        shellp::ShellCmdRealArg *m_pYArg;
        shellp::ShellCmdIntArg *m_pNumIterationsArg;
};

class CmdImagePlaneTraceImgData : public shellp::ShellCommand
{
public:
        CmdImagePlaneTraceImgData(const std::string &cmdName);
        ~CmdImagePlaneTraceImgData();
        bool execute();
private:
        shellp::ShellCmdStringArg *m_pFileNameArg;
};

#endif // CMDIMAGEPLANE_H