OpenPaperOpt/SurfaceTN.h

Go to the documentation of this file.

/**********************************************************************
 * SurfaceTN.h: interface for the SurfaceTN class.
 * Members are explained below, other documentation can be found
 * in the implementation file.
 **********************************************************************/

#ifndef _SURFACETN_H_
#define _SURFACETN_H_

#if _MSC_VER > 1000
#pragma once
#endif

#include "Surface.h"
#include "utilities.h"
#include "Array2D.h"


class SurfaceTN : public Surface {

public:
        SurfaceTN(float _zoffset,float sizeX, float sizeY,Array2D<float>& z,
                                                                                 int _normfact, bool _interpolate, float _rmsmin, float _rmsmax,
                                                                                 StructureObject* _el);
        SurfaceTN(float _zoffset,float sizeX, float sizeY, Array2D<float>& z,
                                                                                 int _normfact, bool _interpolate, Array2D< V2<float> >& v, StructureObject* _el);
        

        SurfaceTN(float _zoffset, float _xmax, float _ymax, Array2D< V3<float> >& v1, bool _interpolate, Array2D< V2<float> >& v, StructureObject* _el);
        //Surface Constructors which are called in other classes as overloaded functions

        SurfaceTN(int _normfact,int _interpolate,Array2D< V2<float> >& v);
        SurfaceTN(float _zoffset,float sizeX,float sizeY,Array2D<float>& z ,int _normfact,int  _interpolate,float _rmsmin,float _rmsmax,StructureObject* _el);
        SurfaceTN(float _zoffset,float sizeX,float sizeY,Array2D<float>& z,int _normfact,int _interpolate,Array2D< V2<float> >& v,StructureObject* _el);


        virtual ~SurfaceTN() {};

        virtual int mIntercept(WavePacket& wp, double t1in, double t2in,
                                                                                                        int updown, double& t) const;
        virtual int Process(WavePacket& wp, int updown, int internal) const;
        virtual double mZposition(WavePacket &wp) const { return mZoffset; };


private:
        bool ReadTopography(std::string _topofile, int mtopo, int ntopo, int normfact);

protected:
        SurfaceTN(int _mNorm, int _nnorm, int _mrough, int _nrough) :
                                 normals(_mNorm,_nnorm), roughness(_mrough, _nrough) {};

        void FindSnormal(WavePacket& wp, int updown) const;
        virtual bool ReadNormals(std::string _normfile);
        virtual void CreateRandomNormals(int thetamax);
        virtual void CreateNormals(Array2D<float>& z, int mtopo, int ntopo,
                                                                                                                        float dxtopo, float dytopo, int normfact);
        virtual bool ReadRoughness(std::string roughfile);
        virtual void WriteInfo(bool topobased, std::string _topofile,
                                                                                                        std::string _normfile, std::string _roughfile);

        const V2<float> FindRoughness(WavePacket& wp) const {
                if (detailed_roughness) {
                        return  roughness((int) (wp.mPos.X()/dxrough),
                                                                                         (int) (wp.mPos.Y()/dyrough));
                }


                return rms;
        }

        int mNorm, nnorm;                               // The size of the normal array
        double dxnorm, dynorm;                  // The distance between the precalc. normals
        bool interpolate;                               // Indicates if normal interp. should be used
        Array2D< V3<double> > normals; // The normal array 
        bool normal_mapping;            // Indicates if the normal array should be used at all
                                                                                                                                                        //   (currently always used by this class, but not
                                                                                                                                                        //    always by subclasses)

        int mrough, nrough;                             // The size of the roughness array
        double dxrough, dyrough;        // The distance between roughness points
        Array2D< V2<float> > roughness;         // The roughness array
        bool detailed_roughness;        // Indicates if the roughness array should be used at all
};

#endif