surface.h

Go to the documentation of this file.

#ifndef SURFACE_H
#define SURFACE_H
 
#include <complex>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <math.h>
#include "vector.h"
#include "objectshape.h"
#include <string.h>
#include "triangle.h"
 
#ifdef WITH_OCTREE
#include "octree.h"
#endif
 
 
namespace GOAT
{
    namespace raytracing
    {
#ifndef SQRT3
#define SQRT3 1.73205080756887729352744634150587236694280525381038062805580  
#endif
 
#define OBJECTSHAPE_SURFACE_FILETYPE_NONE -1
#define OBJECTSHAPE_SURFACE_FILETYPE_SRF 0
#define OBJECTSHAPE_SURFACE_FILETYPE_STL 1
 
       
 
        /* Klasse, die eine ObjectShape repr�sentiert, die aus Dreiecken zusammengebaut ist. Die Dreiecke werden durch die Klasse \ref refdreieck "triangle"
        beschrieben */
        class surface : public ObjectShape
        {
        public:
 
            // Konstruktoren und Destruktor
            //   surface(int num); ///< Constructor for a surface object with num empty triangles
            surface();
            surface(maths::Vector<double> Oh); 
            // surface(const ObjectShape &); 
            surface(const surface& Su);
            surface(const maths::Vector<double>& P,
                std::complex<double>  n,
                const maths::Matrix<std::complex<double> > alpha = maths::CUNITY,
                const maths::Vector<double> Ex = GOAT::maths::ex,
                const maths::Vector<double> Ey = GOAT::maths::ey,
                const maths::Vector<double> Ez = GOAT::maths::ez
            );

            surface(const maths::Vector<double>& P,
                std::complex<double>  n,
                int num, triangle* list,
                const maths::Matrix<std::complex<double> > alpha = maths::CUNITY,
                const maths::Vector<double> Ex = maths::ex,
                const maths::Vector<double> Ey = maths::ey,
                const maths::Vector<double> Ez = maths::ez);
 
            // ~surface();
            maths::Vector<double> calcCoM(); 
            void getMinMax(double& min, double& max);
            triangle* S ; 
            int numTriangles = 0; 
 
            // Erzeugen der Dreiecksliste
            // 1. interaktiv
            int createsurface(); 
            // Skaliere die Dreiecke
            void scale(double sf);
 
            // 2. Einlesen aus Datei FName
            int createsurface(std::string FName); 
            int importBinSTL(std::string FName); 
            void exportSRF(std::string FName);   
            // Andere Hilfsfunktionen
            // 1. R�ckgabe einer Klasse mit leerem S
            surface nosurface(); 
            // 2. Hinzuf�gen einer Liste S 
            void addTriangle(triangle* S, int num);
 
            void clearS(); 
            //  string getFName() {return FName; }
            std::string getFilename() { return FName; } 
            void setFilename(std::string FName) 
            {
                this->FName = FName;                
            }
 
            // Operatoren 
            surface& operator=(const surface&);
 
            // Die virtuellen Funktionen der ObjectShape-Klasse
            bool next(const maths::Vector<double>& r, const maths::Vector<double>& k, maths::Vector<double>& p);
            maths::Vector<double> norm(const maths::Vector<double>& P); 
            bool isInside(const maths::Vector<double>& p);
            void setr0(double r0); 
            void initQuad(); 
            maths::Matrix<double> computeInertia(); 
            void setPos(maths::Vector<double> r); 
            void setPos(double x, double y, double z) { setPos(maths::Vector<double>(x, y, z)); } 
            //double isInHost(void);
            void binWrite(std::ofstream& os); 
            void binRead(std::ifstream& is); 
            // double volume(); 
            double volume();
            void setCenter(maths::Vector<double> P);
            void setCenter2CoM(); 
            int getCurrentIndex() { return currentIndex; } 
            triangle& getTriangle(int i) { return S[i]; } 
            int filetype=OBJECTSHAPE_SURFACE_FILETYPE_NONE; 
 
            // protected:
            maths::Vector<double> currentnorm;  
            int currentIndex; 
            std::string FName; 
            void initBounds(maths::Vector<double>& pul, maths::Vector<double>& por); 
 
#ifdef WITH_OCTREE
            Octree<triangle> Tree;
            int octreeRecursions=5;
            void setOctreeRecursiondepth (int octreeRecursions);
            int getOctreeRecursiondepth() {return Tree.MAX_RECURSIONS; }
#endif
        };
 
        std::ostream& operator << (std::ostream& os, const surface& su);

        surface operator + (const surface& s, const maths::Vector<double>& v); 
        surface operator - (const surface& s, const maths::Vector<double>& v); 
        surface operator + (const maths::Vector<double>& v, const surface& s); 
        surface operator - (const maths::Vector<double>& v, const surface& s); 
        surface operator * (const maths::Matrix<double>& M, const surface& s); 

        surface generateHexagonCylinder(double a, double h, maths::Matrix<double> M = maths::UNITY);

        surface generateHollowHexagonalCylinder(double a, double h, double t, maths::Matrix<double> M = maths::UNITY);

        surface& generateBullet(double a, double h, double t, maths::Matrix<double> M = maths::UNITY); 

        surface generateEllipsoid(double a, double b, int N, double r0 = 1.0, maths::Matrix<double> M = maths::UNITY); // generiert einen Rotationsellipsoiden mit Halbachsen a (z-Achse) und b

        surface generatePill(double a, double b, double h, int N, double r0 = 1.0, maths::Matrix<double> M = maths::UNITY);
 
        surface generatePolyBullet(int n, double a, double h, double t, maths::Matrix<double> M = maths::UNITY);

        void getMinMax(int numTriangles, triangle *S, double& min, double& max);
 
    }
}
#endif