vertex.cpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit 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 bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#include <limits>
 
#include "bitpit_CG.hpp"
#include "bitpit_common.hpp"
 
#include "vertex.hpp"
 
namespace bitpit {
 
OBinaryStream& operator<<(OBinaryStream &out_stream, const Vertex &vertex)
{
    out_stream << vertex.m_id;
    out_stream << vertex.m_coords;
    out_stream << vertex.m_interior;
 
    return out_stream;
}
 
IBinaryStream& operator>>(IBinaryStream &in_stream, Vertex &vertex)
{
    in_stream >> vertex.m_id;
    in_stream >> vertex.m_coords;
    in_stream >> vertex.m_interior;
 
    return in_stream;
}
 
const long Vertex::NULL_ID = std::numeric_limits<long>::min();
 
Vertex::Vertex()
{
    _initialize(NULL_ID, {{0., 0., 0.}}, true);
}
 
Vertex::Vertex(long id, bool interior)
{
    _initialize(id, {{0., 0., 0.}}, interior);
}
 
Vertex::Vertex(long id, const std::array<double, 3> &coords, bool interior)
{
    _initialize(id, coords, interior);
}
 
void Vertex::swap(Vertex &other) noexcept
{
    std::swap(other.m_id, m_id);
    std::swap(other.m_coords, m_coords);
    std::swap(other.m_interior, m_interior);
}
 
void Vertex::initialize(long id, const std::array<double, 3> &coords, bool interior)
{
    _initialize(id, coords, interior);
}
 
void Vertex::_initialize(long id, const std::array<double, 3> &coords, bool interior)
{
    setId(id);
    setCoords(coords);
    setInterior(interior);
}
 
void Vertex::setInterior(bool interior)
{
    m_interior = interior;
}
 
bool Vertex::isInterior() const
{
    return m_interior;
}
 
bool Vertex::operator==(const Vertex &other) const
{
    for (int i = 0; i < 3; ++i) {
        if (!utils::DoubleFloatingEqual()(m_coords[i], other.m_coords[i])) {
            return false;
        }
    }
 
    return true;
}
 
double & Vertex::operator[](int coord_id)
{
    return m_coords[coord_id];
}
 
const double & Vertex::operator[](int coord_id) const
{
    return m_coords[coord_id];
}
 
void Vertex::setId(long id)
{
    m_id = id;
}
 
long Vertex::getId() const
{
    return m_id;
}
 
void Vertex::setCoords(const std::array<double, 3> &coords)
{
    m_coords = coords;
}
 
std::array<double, 3> & Vertex::getCoords()
{
    return m_coords;
}
 
const std::array<double, 3> & Vertex::getCoords() const
{
    return m_coords;
}
 
void Vertex::translate(const std::array<double, 3> &translation)
{
    m_coords[0] += translation[0];
    m_coords[1] += translation[1];
    m_coords[2] += translation[2];
}
 
void Vertex::translate(double sx, double sy, double sz)
{
    translate({{sx, sy, sz}});
}
 
void Vertex::rotate(const std::array<double, 3> &n0, const std::array<double, 3> &n1, double angle)
{
    m_coords = CGElem::rotatePoint(m_coords, n0, n1, angle);
}
 
void Vertex::rotate(double n0x, double n0y, double n0z, double n1x, double n1y, double n1z, double angle)
{
    rotate({{n0x, n0y, n0z}}, {{n1x, n1y, n1z}}, angle);
}
 
void Vertex::scale(const std::array<double, 3> &scaling, const std::array<double, 3> &center)
{
    m_coords[0] = center[0] + scaling[0] * (m_coords[0] - center[0]);
    m_coords[1] = center[1] + scaling[1] * (m_coords[1] - center[1]);
    m_coords[2] = center[2] + scaling[2] * (m_coords[2] - center[2]);
}
 
void Vertex::scale(double sx, double sy, double sz,
                   double cx, double cy, double cz)
{
    scale({{sx, sy, sz}}, {{cx, cy, cz}});
}
 
void Vertex::display(std::ostream &out, unsigned short int indent) const
{
    std::string t_s = std::string(indent, ' ');
 
    // General info ----------------------------------------------------- //
    out << t_s << "ID:             " << getId() << std::endl;
 
    // Coordinates ------------------------------------------------------ //
    out << t_s << "coordinates :   (";
    out << m_coords[0] << ", ";
    out << m_coords[1] << ", ";
    out << m_coords[2] << ")" << std::endl;
}
 
unsigned int Vertex::getBinarySize() const
{
    return (sizeof(m_id) + m_coords.size() * sizeof(double) + sizeof(m_interior));
}
 
// Explicit instantiation of the Vertex containers
template class PiercedVector<Vertex>;
 
}