point3D.h

Go to the documentation of this file.

/* point3D.h : 3D point primitive
 * Copyright (C) 2014  Daniel Haley
 * 
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */
#ifndef ATOMPROBE_POINT3D_H
#define ATOMPROBE_POINT3D_H

#include <iostream>
#include <cmath>
#include <vector>

#include <gsl/gsl_matrix.h>

#include "atomprobe/helper/endianTest.h"
#include "atomprobe/helper/stringFuncs.h"


//FIXME: This is not the right place for this
#include <gsl/gsl_linalg.h>
namespace AtomProbe{

/* A  3D point data class
 * contains operator overloads and some basic
 * mathematical functions
 */
class Point3D
{
        private:
        float value[3];
    public:
        Point3D() {};
        
        Point3D(const float *f) {setValueArr(f);};
        
        inline Point3D(float x,float y,float z) 
            { value[0] = x, value[1] = y, value[2] = z;}
        
        
        inline void setValue(unsigned int ui, float val){value[ui]=val;};
        
        inline void setValue(float fX,float fY, float fZ)
            {value[0]=fX; value[1]=fY; value[2]=fZ;}


        bool parse(const std::string &s);
        
        inline void setValueArr(const float *val)
            {
                value[0]=*val;
                value[1]=*(val+1);
                value[2]=*(val+2);
            };

        inline float getValue(unsigned int ui) const {return value[ui];};
        
        inline const float *getValueArr() const { return value;};


        void copyValueArr(float *value) const;
        

        void add(const Point3D &obj);
        

        void extend(float distance);

        bool hasNaN() const { return (std::isnan(value[0]) || 
                    std::isnan(value[1]) || std::isnan(value[2]));};
        
        bool operator==(const Point3D &pt) const;
        
        const Point3D &operator=(const Point3D &pt);
        
        const Point3D &operator+=(const Point3D &pt);
        
        const Point3D &operator-=(const Point3D &pt);
        
        Point3D operator*=(const float scale);  
        
        const Point3D operator+(const Point3D &pt) const;
        
        const Point3D operator+(float f) const;
        
        const Point3D operator*(float scale) const;
        
        const Point3D operator*(const Point3D &pt) const;
        
        const Point3D operator/(float scale) const;
        
        const Point3D operator/(const Point3D &pt) const;
        
        const Point3D operator-(const Point3D &pt) const;
        
        const Point3D operator-() const;
        
        friend std::ostream &operator<<(std::ostream &stream, const Point3D &);
        
        void normalise();   
        
        Point3D normal() const; 
        

        float sqrDist(const Point3D &pt) const;
        

        float dotProd(const Point3D &pt) const;
        
        Point3D crossProd(const Point3D &pt) const;

        float angle(const Point3D &pt) const;
        
        float sqrMag() const;

        float mag() const { return sqrtf(sqrMag());}
    
        float operator[](unsigned int ui) const;
        

        float &operator[](unsigned int ui); 
    

        bool insideBox(const Point3D &farPoint) const;
        

        bool insideBox(const Point3D &lowPt, const Point3D &hiPt) const;
        
        void negate();

        void reciprocal();
        
        void transform3x3(const gsl_matrix *matrix);

        bool orthogonalise(const Point3D &p);


        static void getCentroid(const std::vector<Point3D> &pts, Point3D &p);


        void setISOSpherical(float radius, float theta, float phi );
        

        void getISOSpherical(float &radius, float &theta, float &phi ) const;


#ifdef __LITTLE_ENDIAN__
        void switchEndian();
#endif
};
#ifdef DEBUG
bool testPoint3D();
#endif
}
#endif