cmdlensplane.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 CMDLENSPLANE_H

#define CMDLENSPLANE_H

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

class CmdLensPlane : public shellp::ShellCommand
{
public:
        CmdLensPlane(const std::string &cmdname);
        ~CmdLensPlane();
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 CmdLensPlaneLocal : public CmdLensPlane
{
public:
        CmdLensPlaneLocal(const std::string &cmdname);
        ~CmdLensPlaneLocal();
        bool execute();
};

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

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

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

class CmdLensPlaneScale : public shellp::ShellCommand
{
public:
        CmdLensPlaneScale(const std::string &cmdName);
        ~CmdLensPlaneScale();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pScaleArg;
};

class CmdLensPlanePlot : public shellp::ShellCommand
{
public:
        CmdLensPlanePlot(const std::string &cmdName);
        ~CmdLensPlanePlot();
protected:
        std::string getFileName() const                                         { return m_pFileNameArg->getValue(); }
        double getX1() const                                                    { return m_pX1Arg->getValue(); }
        double getY1() const                                                    { return m_pY1Arg->getValue(); }
        double getX2() const                                                    { return m_pX2Arg->getValue(); }
        double getY2() const                                                    { return m_pY2Arg->getValue(); }
        int getNumX() const                                                     { return m_pNumXArg->getValue(); }
        int getNumY() const                                                     { return m_pNumYArg->getValue(); }
        
        shellp::ShellCmdStringArg *m_pFileNameArg;
        shellp::ShellCmdRealArg *m_pX1Arg, *m_pY1Arg, *m_pX2Arg, *m_pY2Arg;
        shellp::ShellCmdIntArg *m_pNumXArg, *m_pNumYArg;
};

class CmdLensPlanePlotGnuplot : public CmdLensPlanePlot
{
public:
        CmdLensPlanePlotGnuplot(const std::string &cmdName);
        ~CmdLensPlanePlotGnuplot();
        bool execute();
private:
        shellp::ShellCmdBoolArg *m_pArg3D, *m_pColorArg;
        shellp::ShellCmdStringArg *m_pXLabelArg, *m_pYLabelArg;
};

class CmdLensPlanePlotFITS : public CmdLensPlanePlot
{
public:
        CmdLensPlanePlotFITS(const std::string &cmdName);
        ~CmdLensPlanePlotFITS();
        bool execute();
};

#endif // CMDLENSPLANE_H