a_tetrahedron.cxx

Go to the documentation of this file.

/*
         Copyright 2016 Pierre SMARS (smars@yuntech.edu.tw)
         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 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/>.
 */
#include "a_tetrahedron.h"
#include "a_plane.h"
#include "a_segment.h"
 
#include "a_debug.h"
#include <sstream>
 
//---------------------------------------------------------------------------
const std::string a_tetrahedron::help()
{
        std::ostringstream o;
        o << "*************" << std::endl;
        o << "a_tetrahedron:" << std::endl;
        o << "*************" << std::endl;
        o << "This is a 'tetrahedron' class" << std::endl;
        o << std::endl;
        o << "Create a tetrahedron:" << std::endl;
        o << " a_tetrahedron a" << std::endl;
        o << " a_tetrahedron a p1 p2 p3 p4" << std::endl;
        o << std::endl;
        o << "Commands:" << std::endl;
        o << "p1, p2, p3, p4: get or set apices" << std::endl;
        o << "a[_ref]: returns apex" << std::endl;
        o << "s _ref: returns side of tetrahedron as a_segment" << std::endl;
        o << "f _ref: returns face of tetrahedron as a_triangle" << std::endl;
        o << "c: get centre" << std::endl;
        o << "V: get volume" << std::endl;
        o << "translate _x _y _z: translate." << std::endl;
        o << "rotate _xaxis _yaxis _zaxis: rotate." << std::endl;
        o << a_geom_base::help();
        return o.str();
}
//---------------------------------------------------------------------------
bool a_tetrahedron::operator==(const a_tetrahedron& p)
{
        bool test = true;
        for (unsigned short i = 0; i<4; i++)
                test = test&&(p_[i]==p[i]);
        return test;
}
//---------------------------------------------------------------------------
a_tetrahedron & a_tetrahedron::operator=(const a_tetrahedron& p)
{
        for (unsigned short i = 0; i<4; i++)
                p_[i] = p[i];
        return *this;
}
//---------------------------------------------------------------------------
a_segment a_tetrahedron::s(const int ref) const
{
        unsigned short r=ref%4;
        unsigned short u=0;
        unsigned short v=3;
        if (r==3||r==4) u=1;
        else if (r==5) u=2;
        if (r==0) v=1;
        else if (r==1||r==3) v=2;
        return a_segment(p_[u],p_[v]);
}
//---------------------------------------------------------------------------
a_triangle a_tetrahedron::f(const int ref) const
{
        unsigned short r=ref%4;
        a_triangle t(p_[0],p_[1],p_[2]);
        a_point c = this->c();
        a_point n, k;
        switch (r)
        {
                case 0:
                        n = t.normal();
                        k = p_[3]-c;
                        if (n*k>0.) t.invert();
                        break;
                case 1:
                        t.set(p_[0],p_[1],p_[3]);
                        n = t.normal();
                        k = p_[2]-c;
                        if (n*k>0.) t.invert();
                        break;
                case 2:
                        t.set(p_[0],p_[2],p_[3]);
                        n = t.normal();
                        k = p_[1]-c;
                        if (n*k>0.) t.invert();
                        break;
                case 3:
                        t.set(p_[1],p_[2],p_[3]);
                        n = t.normal();
                        k = p_[0]-c;
                        if (n*k>0.) t.invert();
                        break;
        }
        return t;
}
//-rotate--------------------------------------------------------------------
a_tetrahedron& a_tetrahedron::translate(double x, double y, double z)
{
        for (unsigned short i = 0; i<4; i++)
                p_[i].translate(x,y,z);
        return *this;
}
//-rotate--------------------------------------------------------------------
a_tetrahedron& a_tetrahedron::rotate(const a_point& x_axis, const a_point& y_axis, const a_point& z_axis)
{
        for (unsigned short i = 0; i<4; i++)
                p_[i].rotate(x_axis, y_axis, z_axis);
        return *this;
}
//---------------------------------------------------------------------------
double a_tetrahedron::V() const
{
        return cross(p_[1]-p_[0],p_[2]-p_[0])*(p_[3]-p_[0])/6.;
}
//---------------------------------------------------------------------------
double a_tetrahedron::S() const
{
        double s = 0.;
        for (unsigned short i = 0; i<4; i++)
                s+= this->f(i).S();
        return s;
}
//---------------------------------------------------------------------------
bool a_tetrahedron::contains(const a_point& p) const
{
        for (unsigned short i = 0; i<4; i++)
        {
                a_triangle t =this->f(i);
                a_point n = t.normal();
                a_point c = t.c();
                if ((p-c)*n>verysmall_)
                        return false;
        }
        return true;
}
//---------------------------------------------------------------------------
double a_tetrahedron::quality() const
{
        double m = 1.e30;
        double M = -1.e30;
        for (unsigned short i = 0; i<4; i++)
        {
                a_segment s = this->s(i);
                double l = s.length();
                if (l<m) m=l;
                if (l>M) M=l;
        }
        if (M==0)
                return 0.;
        else
                return m/M;
}
//***************************************************************************
//---------------------------------------------------------------------------
void a_tetrahedron::read(std::istream &in)
{
        for (unsigned short i = 0; i<4; i++)
                in >> p_[i];
}
//---------------------------------------------------------------------------
void a_tetrahedron::write(std::ostream &o) const
{
        for (unsigned short i = 0; i<4; i++)
                o << p_[i] << " ";
}