aperture.h

Go to the documentation of this file.

/*
Arroyo - software for the simulation of electromagnetic wave propagation
through turbulence and optics.

Copyright (c) 2000-2004 California Institute of Technology.  Written by
Dr. Matthew Britton.  For comments or questions about this software,
please contact the author at mbritton@astro.caltech.edu.

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 provided "as is" and 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.  In no
event shall California Institute of Technology be liable to any party
for direct, indirect, special, incidental or consequential damages,
including lost profits, arising out of the use of this software and its
documentation, even if the California Institute of Technology has been
advised of the possibility of such damage.   The California Institute of
Technology has no obligation to provide maintenance, support, updates,
enhancements or modifications.  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/

#ifndef APERTURE_H
#define APERTURE_H

#include <pixel_array.h>
#include "optic.h"

namespace Arroyo {

  using std::string;
  using std::vector;
  using std::ostream;


  class aperture :
    virtual public plane_optic,
    virtual public one_to_one_optic {

    protected:

    bool areal_weighting;

    public:

    aperture(){areal_weighting = true;};

    aperture(const aperture & ap);

    virtual ~aperture(){};

    aperture & operator=(const aperture & ap);

    virtual aperture * clone() const = 0;

    bool get_areal_weighting() const {return(areal_weighting);};

    void set_areal_weighting(bool aewtg) {areal_weighting = aewtg;};

    virtual void read(const char * filename) = 0;

    virtual void read(const iofits & iof) = 0;
 
    virtual void write(const char * filename) const = 0;

    virtual void write(iofits & iof) const = 0;

    virtual void print(ostream & os, const char * prefix="") const;

    virtual double convex_polygon_overlap(const vector<three_point> & polygon_vertices) const = 0;

    static aperture * aperture_factory(const char * filename);

    static aperture * aperture_factory(const iofits & iof);

  };


  class circular_aperture :
    public aperture {

    private:

    static const bool factory_registration;

    string unique_name() const {return(string("circular aperture"));};

    double diameter;

    template<class T>
      void private_transform(diffractive_wavefront<T> & wf) const;

    public:

    circular_aperture();

    circular_aperture(const circular_aperture & circ_ap);

    circular_aperture(const char * filename);

    circular_aperture(const iofits & iof);

    circular_aperture(double in_diameter);

    ~circular_aperture(){};

    circular_aperture & operator=(const circular_aperture & circ_ap);

    circular_aperture * clone() const {
      return(new circular_aperture(*this));
    };

    virtual void read(const char * filename);

    virtual void read(const iofits & iof);
 
    virtual void write(const char * filename) const;

    virtual void write(iofits & iof) const;

    void print(ostream & os, const char * prefix="") const;

    double get_diameter() const {return(diameter);};

    rectangular_region get_covering_region(const three_frame & tf) const;

    void transform(diffractive_wavefront<float> & wf) const;

    void transform(diffractive_wavefront<double> & wf) const;

    //void transform(geometric_ray & gray) const;

    //void transform(geometric_wavefront & gwf) const;

    double convex_polygon_overlap(const vector<three_point> & polygon_vertices) const;

  };


  class annular_aperture :
    public aperture {

    private:

    static const bool factory_registration;

    string unique_name() const {return(string("annular aperture"));};

    protected:

    double inner_diameter;

    double outer_diameter;

    template<class T>
      void private_transform(diffractive_wavefront<T> & wf) const;

    public:

    annular_aperture();

    annular_aperture(const annular_aperture & annular_ap);

    annular_aperture(const char * filename);

    annular_aperture(const iofits & iof);

    annular_aperture(double in_diameter, double out_diameter);

    ~annular_aperture(){};

    annular_aperture & operator=(const annular_aperture & annular_ap);

    annular_aperture * clone() const {
      return(new annular_aperture(*this));
    };

    virtual void read(const char * filename);

    virtual void read(const iofits & iof);
 
    virtual void write(const char * filename) const;

    virtual void write(iofits & iof) const;

    void print(ostream & os, const char * prefix="") const;

    double get_inner_diameter() const {return(inner_diameter);};

    double get_outer_diameter() const {return(outer_diameter);};

    rectangular_region get_covering_region(const three_frame & tf) const;

    virtual void transform(diffractive_wavefront<float> & wf) const;

    virtual void transform(diffractive_wavefront<double> & wf) const;

    //virtual void transform(geometric_ray & gray) const;

    //virtual void transform(geometric_wavefront & gwf) const;

    double convex_polygon_overlap(const vector<three_point> & polygon_vertices) const;

  };


  class rectangular_aperture :
    public aperture {

    private:

    static const bool factory_registration;

    string unique_name() const {return(string("rectangular aperture"));};

    protected:

    vector<double> size;

    template<class T>
      void private_transform(diffractive_wavefront<T> & wf) const;

    public:

    rectangular_aperture();

    rectangular_aperture(const rectangular_aperture & rectangular_ap);

    rectangular_aperture(const char * filename);

    rectangular_aperture(const iofits & iof);

    rectangular_aperture(double x_size, double y_size);

    ~rectangular_aperture(){};

    rectangular_aperture & operator=(const rectangular_aperture & rectangular_ap);

    rectangular_aperture * clone() const {
      return(new rectangular_aperture(*this));
    };

    virtual void read(const char * filename);

    virtual void read(const iofits & iof);
 
    virtual void write(const char * filename) const;

    virtual void write(iofits & iof) const;

    void print(ostream & os, const char * prefix="") const;

    vector<double> get_size() const {return(size);};

    rectangular_region get_covering_region(const three_frame & tf) const;

    virtual void transform(diffractive_wavefront<float> & wf) const;

    virtual void transform(diffractive_wavefront<double> & wf) const;

    //virtual void transform(geometric_ray & gray) const;

    //virtual void transform(geometric_wavefront & gwf) const;

    double convex_polygon_overlap(const vector<three_point> & polygon_vertices) const;

  };


  class spidered_annular_aperture :
    public annular_aperture {

    private:

    static const bool factory_registration;

    string unique_name() const {return(string("spidered annular aperture"));};

    protected:

    long nspiders;

    double spider_width;

    template<class T>
      void private_transform(diffractive_wavefront<T> & wf) const;

    public:

    spidered_annular_aperture();

    spidered_annular_aperture(const spidered_annular_aperture & spdrd_annular_ap);

    spidered_annular_aperture(const char * filename);

    spidered_annular_aperture(const iofits & iof);

    spidered_annular_aperture(double in_diameter, double out_diameter, 
                              int nspiders, double spider_width);

    ~spidered_annular_aperture(){};

    spidered_annular_aperture & operator=(const spidered_annular_aperture & spdrd_annular_ap);

    spidered_annular_aperture * clone() const {
      return(new spidered_annular_aperture(*this));
    };

    void read(const char * filename);

    void read(const iofits & iof);
 
    void write(const char * filename) const;

    void write(iofits & iof) const;

    void print(ostream & os, const char * prefix="") const;

    //rectangular_region get_covering_region(const three_frame & tf) const;
    
    void transform(diffractive_wavefront<float> & wf) const;

    void transform(diffractive_wavefront<double> & wf) const;

    //virtual void transform(geometric_ray & gray) const;

    //virtual void transform(geometric_wavefront & gwf) const;

    double convex_polygon_overlap(const vector<three_point> & polygon_vertices) const;

  };


  class hexagonal_aperture :
    public aperture {

    private:

    static const bool factory_registration;

    string unique_name() const {return(string("hexagonal aperture"));};

    template<class T>
      void private_transform(diffractive_wavefront<T> & wf) const;

    protected:

    double edge_length;

    public:

    hexagonal_aperture();

    hexagonal_aperture(const hexagonal_aperture & hexagonal_ap);

    hexagonal_aperture(const char * filename);

    hexagonal_aperture(const iofits & iof);

    hexagonal_aperture(double in_edge_length);

    ~hexagonal_aperture(){};

    hexagonal_aperture & operator=(const hexagonal_aperture & hexagonal_ap);

    hexagonal_aperture * clone() const {
      return(new hexagonal_aperture(*this));
    };

    virtual void read(const char * filename);

    virtual void read(const iofits & iof);
 
    virtual void write(const char * filename) const;

    virtual void write(iofits & iof) const;

    void print(ostream & os, const char * prefix="") const;

    double get_edge_length() const {return(edge_length);};

    rectangular_region get_covering_region(const three_frame & tf) const;

    virtual void transform(diffractive_wavefront<float> & wf) const;

    virtual void transform(diffractive_wavefront<double> & wf) const;

    //virtual void transform(geometric_ray & gray) const;

    //virtual void transform(geometric_wavefront & gwf) const;

    double convex_polygon_overlap(const vector<three_point> & polygon_vertices) const;

  };



  class tiled_hexagonal_aperture :
    public aperture {

    private:
 
    static const bool factory_registration;

    string unique_name() const {return(string("tiled hexagonal aperture"));};

    tiled_hexagonal_aperture(){};

    protected:

    Arroyo::pixel_array<long> tilemap;

    double edge_length;

    double gap_size;

    template<class T>
      void private_transform(diffractive_wavefront<T> & dwf) const;

    public:

    tiled_hexagonal_aperture(const tiled_hexagonal_aperture & tiled_hexagonal_ap);

    tiled_hexagonal_aperture(const char * filename);

    tiled_hexagonal_aperture(const iofits & iof);

    //tiled_hexagonal_aperture(int inner_ring, int outer_ring, 
    //double in_edge_length, double in_gap_size);

    tiled_hexagonal_aperture(double inner_diameter, double outer_diameter,
                             double in_edge_length, double in_gap_size);

    ~tiled_hexagonal_aperture(){};

    tiled_hexagonal_aperture & operator=(const tiled_hexagonal_aperture & tiled_hexagonal_ap);
 
    tiled_hexagonal_aperture * clone() const {
      return(new tiled_hexagonal_aperture(*this));
    };

    virtual void read(const char * filename);

    virtual void read(const iofits & iof);
 
    virtual void write(const char * filename) const;

    virtual void write(iofits & iof) const;

    void print(ostream & os, const char * prefix="") const;

    double get_edge_length() const {return(edge_length);};

    double get_gap_size() const {return(gap_size);};

    rectangular_region get_covering_region(const three_frame & tf) const;

    virtual void transform(diffractive_wavefront<float> & dwf) const;

    virtual void transform(diffractive_wavefront<double> & dwf) const;

    double convex_polygon_overlap(const vector<three_point> & polygon_vertices) const;
  };
}

#endif

---