cmdimagesdata.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 CMDIMAGESDATA_H

#define CMDIMAGESDATA_H

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

class CmdImagesDataLoadSave : public shellp::ShellCommand
{
public:
        CmdImagesDataLoadSave(const std::string &cmdname);
        ~CmdImagesDataLoadSave();
protected:
        std::string GetFileName() const                                         { return fnamearg->getValue(); }
private:
        shellp::ShellCmdStringArg *fnamearg;
};

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

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

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

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

class CmdImagesDataImport : public shellp::ShellCommand
{
protected:
        CmdImagesDataImport(const std::string &cmdname);
public:
        ~CmdImagesDataImport();
protected:
        std::string GetFileName() const                                 { return fnamearg->getValue(); }
        std::string GetMaskFileName() const                             { if (masknamearg->getValue() == std::string("*")) return std::string(""); return masknamearg->getValue(); }
        double GetX1() const                                            { return x1arg->getValue(); }
        double GetY1() const                                            { return y1arg->getValue(); }
        double GetX2() const                                            { return x2arg->getValue(); }
        double GetY2() const                                            { return y2arg->getValue(); }
        bool UseNullSpace() const                                       { return nullarg->getValue(); }
        bool getTriangulationFlag() const                               { return m_pTriangArg->getValue(); }
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdStringArg *masknamearg;
        shellp::ShellCmdRealArg *x1arg,*y1arg,*x2arg,*y2arg;
        shellp::ShellCmdBoolArg *nullarg;
        shellp::ShellCmdBoolArg *m_pTriangArg;
};

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

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

class CmdImagesDataImportFITSAuto : public shellp::ShellCommand
{
public:
        CmdImagesDataImportFITSAuto(const std::string &cmdname);
        ~CmdImagesDataImportFITSAuto();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdStringArg *masknamearg;
        shellp::ShellCmdRealArg *unitmultarg;
        shellp::ShellCmdStringArg *unitbasearg;
        shellp::ShellCmdBoolArg *nullarg;
        shellp::ShellCmdBoolArg *m_pTriangArg;
};

class CmdImagesDataImportFITSWCS : public shellp::ShellCommand
{
public:
        CmdImagesDataImportFITSWCS(const std::string &cmdname);
        ~CmdImagesDataImportFITSWCS();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdStringArg *masknamearg;
        shellp::ShellCmdBoolArg *nullarg;
        shellp::ShellCmdBoolArg *m_pTriangArg;
};

class CmdImagesDataSourceImage : public shellp::ShellCommand
{
public:
        CmdImagesDataSourceImage(const std::string &cmdName);
        ~CmdImagesDataSourceImage();
        bool execute();
private:
        shellp::ShellCmdIntArg *m_pImageNumberArg;
        shellp::ShellCmdRealArg *m_pDsArg;
        shellp::ShellCmdRealArg *m_pDdsArg;
        shellp::ShellCmdStringArg *m_pFileArg;
        shellp::ShellCmdIntArg *m_pNumXArg;
        shellp::ShellCmdIntArg *m_pNumYArg;
        shellp::ShellCmdBoolArg *m_pFastArg;
        shellp::ShellCmdIntArg *m_pResampleArg;
        shellp::ShellCmdBoolArg *m_pUseMagnifications;
};

class CmdImagesDataListAdd : public shellp::ShellCommand
{
public:
        CmdImagesDataListAdd(const std::string &cmdname);
        ~CmdImagesDataListAdd();
        bool execute();
private:
        shellp::ShellCmdRealArg *Dsarg;
        shellp::ShellCmdRealArg *Ddsarg;
        shellp::ShellCmdBoolArg *extraarg;
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdRealArg *valarg;
        std::vector<shellp::ShellCmdArg *> imgargs;
};

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

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

class CmdImagesDataSelect : public shellp::ShellCommand
{
public:
        CmdImagesDataSelect(const std::string &cmdname);
        ~CmdImagesDataSelect();
        bool execute();
private:
        shellp::ShellCmdIntArg *numarg;
};

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

class CmdImagesDataRegularBase : public shellp::ShellCommand
{
public:
        CmdImagesDataRegularBase(const std::string &cmdname);
        ~CmdImagesDataRegularBase();
protected:
        bool getAvoidTriangles(std::list<grale::Triangle2D<double> > &triangles);

        shellp::ShellCmdRealArg *x1arg;
        shellp::ShellCmdRealArg *y1arg;
        shellp::ShellCmdRealArg *x2arg;
        shellp::ShellCmdRealArg *y2arg;
        shellp::ShellCmdIntArg *numxarg;
        shellp::ShellCmdIntArg *numyarg;
        shellp::ShellCmdBoolArg *m_pNeedTriangArg;
        shellp::ShellCmdBoolArg *m_pTriangulateArg;
};

class CmdImagesDataNewRegular : public CmdImagesDataRegularBase
{
public:
        CmdImagesDataNewRegular(const std::string &cmdname);
        ~CmdImagesDataNewRegular();
        bool execute();
private:
        shellp::ShellCmdBoolArg *m_pIntensFlagArg;
        shellp::ShellCmdBoolArg *m_pCutArg;
        shellp::ShellCmdBoolArg *m_pMinDistArg;
};

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

class CmdImagesDataSubtractPosition : public shellp::ShellCommand
{
public:
        CmdImagesDataSubtractPosition(const std::string &cmdname);
        ~CmdImagesDataSubtractPosition();
        bool execute();
private:
        shellp::ShellCmdRealArg *xarg;
        shellp::ShellCmdRealArg *yarg;
};

class CmdImagesDataSubtractIntensity : public shellp::ShellCommand
{
public:
        CmdImagesDataSubtractIntensity(const std::string &cmdname);
        ~CmdImagesDataSubtractIntensity();
        bool execute();
private:
        shellp::ShellCmdRealArg *varg;
};

class CmdImagesDataNonDominatedSet : public shellp::ShellCommand
{
public:
        CmdImagesDataNonDominatedSet(const std::string &cmdname);
        ~CmdImagesDataNonDominatedSet();
        bool execute();
private:
        class FitnessValues
        {
        public:
                FitnessValues(int n,const std::string f);
                ~FitnessValues();
                float *GetValues()                                                                      { return values; }
                std::string GetFilename() const                                                         { return fname; }
        private:
                float *values;
                std::string fname;
        };

        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdRealArg *m_pZArg;
        std::vector<shellp::ShellCmdArg *> fileargs;
        shellp::ShellCmdStringArg *fnamearg2;
};

class CmdImagesDataNewPoints : public shellp::ShellCommand
{
public:
        CmdImagesDataNewPoints(const std::string &cmdName);
        ~CmdImagesDataNewPoints();
        bool execute();
private:
        shellp::ShellCmdStringArg *m_pFileArg;
        std::vector<shellp::ShellCmdArg *> m_coordArgs;
        shellp::ShellCmdRealArg *m_pXArg;
        shellp::ShellCmdRealArg *m_pYArg;
};

class CmdImagesDataNew : public shellp::ShellCommand
{
public:
        CmdImagesDataNew(const std::string &cmdName);
        ~CmdImagesDataNew();
        bool execute();
private:
        shellp::ShellCmdIntArg *m_pNumImagesArg;
        shellp::ShellCmdBoolArg *m_pIntensFlagArg;
        shellp::ShellCmdBoolArg *m_pShearFlagArg;
};

class CmdImagesDataAddPoints : public shellp::ShellCommand
{
public:
        CmdImagesDataAddPoints(const std::string &cmdName);
        ~CmdImagesDataAddPoints();
        bool execute();
private:
        shellp::ShellCmdIntArg *m_pImageNumberArg;
        shellp::ShellCmdStringArg *m_pFileArg;
        std::vector<shellp::ShellCmdArg *> m_pointInfoArgs;
        shellp::ShellCmdRealArg *m_pXArg;
        shellp::ShellCmdRealArg *m_pYArg;
        shellp::ShellCmdRealArg *m_pIntensArg;
        shellp::ShellCmdRealArg *m_pShearAngle;
        shellp::ShellCmdRealArg *m_pShearSize;
};

class CmdImagesDataAddShearInfo : public shellp::ShellCommand
{
public:
        CmdImagesDataAddShearInfo(const std::string &cmdName);
        ~CmdImagesDataAddShearInfo();
        bool execute();
private:
        shellp::ShellCmdBoolArg *m_pReducedArg;
};

#endif // CMDIMAGESDATA_H