aggregate.hpp

Go to the documentation of this file.

/*
*
*      AggregPacking : Generator of random aggregate packings in concrete     
*                                                                             
*                           version 0.1 (2014-08-22)                          
* 
*                      Copyright (C)  2014  Jan Stransky                      
* 
*          Czech Technical University, Faculty of Civil Engineering,          
*      Department of Structural Mechanics, 166 29 Prague, Czech Republic      
* 
* AggregPacking is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
* 
* AggregPacking 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 Lesser General Public License
* for more details.
* 
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef AGGREGATE_HPP
#define AGGREGATE_HPP

#include "math.hpp"
#ifdef AGGREGPACKING_BOOST_PYTHON
    #include <boost/python.hpp>
    namespace bp = boost::python;
#endif

#ifdef AGGREGPACKING_SERIALIZATION
#include <string>
#include <iostream>
#include <fstream>
using std::string;
using std::istream;
using std::ostream;
using std::ifstream;
using std::ofstream;
#endif


namespace aggregpacking {


class Sphere;

/**********************************************************************
* AGGREGATE
**********************************************************************/

class Aggregate {
    protected:
        int number;

        Vector3 pos;

        Quaternion ori;

    public:

        Aggregate() : Aggregate(Vector3::Zero(),Quaternion::Identity()) {}


        Aggregate(const Vector3& pos) : Aggregate(pos,Quaternion::Identity()) {}


        Aggregate(const Quaternion& ori) : Aggregate(Vector3::Zero(),ori) {}


        Aggregate(const Vector3& pos, const Quaternion& ori) : number(-1), pos(pos), ori(ori) {}


        bool operator==(const Aggregate& other) const { return &other == this; }


        bool operator!=(const Aggregate& other) const { return &other != this; }


        virtual bool containsPoint(const Vector3& p) const = 0;


        virtual bool containsSphere(const Sphere& s) const = 0;


        virtual double computeDistanceFrom(const Aggregate& aggreg) const = 0;


        virtual double computeMaxCoord(int axis) const = 0;


        virtual double computeMinCoord(int axis) const = 0;


        bool isInsideCube(double s) const;

        virtual double computeVolume() const = 0;


        virtual void fromSize(double s) = 0;

        virtual double getSize() const = 0;

        virtual double getMaxSize() const = 0;

        //static bool compare(Aggregate* a1, Aggregate* a2) { return a2->getSize() < a1->getSize(); }
        int getNumber() { return number; }


        void setNumber(int n) { number = n; }

        const Vector3& getPos() const { return pos; }

        Vector3 getPos() { return pos; }


        void setPos(const Vector3& p) { pos = p; }


        void setPos(double x, double y, double z) {
            pos.x() = x;
            pos.y() = y;
            pos.z() = z;
        }

        const Quaternion& getOri() const { return ori; }

        Quaternion getOri() { return ori; }


        void setOri(const Quaternion& q) { ori = q; ori.normalize(); }

#ifdef AGGREGPACKING_SERIALIZATION
        virtual const string& getClassName() = 0;


        static Aggregate* Load(istream& is);

        friend ostream& operator<<(ostream& os, const Aggregate& o);

#endif

        friend double get_x(const Aggregate& a) { return a.pos.x(); }

        friend double get_y(const Aggregate& a) { return a.pos.y(); }

        friend double get_z(const Aggregate& a) { return a.pos.z(); }

        friend double get_size(const Aggregate& a) { return a.getMaxSize(); }

        friend double get_x(const Aggregate* a) { return a->pos.x(); }

        friend double get_y(const Aggregate* a) { return a->pos.y(); }

        friend double get_z(const Aggregate* a) { return a->pos.z(); }

        friend double get_size(const Aggregate* a) { return a->getMaxSize(); }
};




/**********************************************************************
* SPHERE
**********************************************************************/

class Sphere : public Aggregate {
    private:
        double radius;

    public:
        Sphere() : Sphere(Vector3::Zero(),0.) {}


        Sphere(const Vector3& p) : Sphere(p,0.) {}


        Sphere(double r) : Sphere(Vector3::Zero(),r) {}


        Sphere(const Vector3& p, double r) : Aggregate(p), radius(r) {}

        double getRadius() const { return radius; }


        void setRadius(double r) { radius = r; }

        virtual bool containsPoint(const Vector3& p) const;

        virtual bool containsSphere(const Sphere& s) const;

        virtual double computeDistanceFrom(const Aggregate& aggreg) const;

        virtual double computeVolume() const { return 4./3.*PI*pow(radius,3); }

        virtual void fromSize(double s);

        virtual double computeMaxCoord(int axis) const { return pos[axis] + radius; };

        virtual double computeMinCoord(int axis) const { return pos[axis] - radius; };

        virtual double getSize() const { return 2*radius; }

        virtual double getMaxSize() const { return 2*radius; }

        const static string className;

#ifdef AGGREGPACKING_SERIALIZATION
        virtual const string& getClassName() { return Sphere::className; }

        friend ostream& operator<<(ostream& os, const Sphere& o);

        friend istream& operator>>(istream& is, Sphere& o);
#endif
};



/**********************************************************************
* ELLIPSOID
**********************************************************************/

class Ellipsoid : public Aggregate {
    private:
        double a;

        double b;

        double c;


        static double randomAxesRatio;

    public:
        Ellipsoid() : Ellipsoid(Vector3::Zero(),0.,0.,0.) {}


        Ellipsoid(const Vector3& p) : Ellipsoid(p,0.,0.,0.) {}


        Ellipsoid(double a, double b, double c) : Ellipsoid(Vector3::Zero(),a,b,c) {}


        Ellipsoid(const Vector3& p,  double a,  double b,  double c) : Aggregate(p), a(a), b(b), c(c) {}


        Ellipsoid(const Sphere& s);

        double getA() { return a; }

        double getB() { return b; }

        double getC() { return c; }


        void setA(double a) { this->a = a; }


        void setB(double b) { this->b = b; }


        void setC(double c) { this->c = c; }

        double getRandomAxesRatio() { return randomAxesRatio; }
        
        void setRandomAxesRatio(double v) { randomAxesRatio = v; }


        static double computeRelativeDistanceFrom(const Vector3&p, const Matrix3& bT, const Vector3& pos);


        double computeRelativeDistanceFrom(const Vector3& p) const;


        static bool containsPoint(const Vector3&p, const Matrix3& bT, const Vector3& pos);

        virtual bool containsPoint(const Vector3& p) const;

        virtual bool containsSphere(const Sphere& s) const;

        virtual double computeDistanceFrom(const Aggregate& aggreg) const;

        virtual double computeVolume() const { return 4./3.*PI*a*b*c; }


        virtual void fromSize(double s);


        void computeProjectionOnCoordAxis(double& s0, double& w, int axis) const;

        virtual double computeMaxCoord(int axis) const;

        virtual double computeMinCoord(int axis) const;

        virtual double getSize() const;

        virtual double getMaxSize() const { return 2*std::max(a,std::max(b,c)); }

        Matrix3 computeMatrixB() const;

        Matrix3 computeMatrixBT() const;

        Matrix3 computeMatrixBInversed() const;

        Matrix3 computeMatrixBTInversed() const;

        Matrix3 computeMatrixSigma() const;

        Matrix3 computeMatrixSigmaInversed() const;

        Matrix3 computeMatrixSigmaSquare() const;

        Matrix3 computeMatrixA() const;


        static Vector3 computeNearestPointFrom(const Vector3& p, const Matrix3& bT, const Vector3& pos);


        Vector3 computeNearestPointFrom(const Vector3& p) const;


        static Vector3 computeFarthestPointFrom(const Vector3& p, const Matrix3& bT, const Vector3& pos);


        Vector3 computeFarthestPointFrom(const Vector3& p) const;


        double computeEstimatedDistanceFrom(const Ellipsoid& e) const;

        const static string className;

#ifdef AGGREGPACKING_SERIALIZATION
        virtual const string& getClassName() { return Ellipsoid::className; }

        friend ostream& operator<<(ostream& os, const Ellipsoid& o);

        friend istream& operator>>(istream& is, Ellipsoid& o);
#endif
};



/**********************************************************************
* PYTHON
**********************************************************************/
#ifdef AGGREGPACKING_BOOST_PYTHON
void py_aggregate();
#endif

} // namespace
#endif