geometry.cpp

Go to the documentation of this file.

/*
    mesh3d
    Copyright (C) 2010  Timo Suoranta

    This library 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 2.1 of the License, or (at your option) any later version.

    This library 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 library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "mesh3d/geometry.h"
#include "mesh3d/point.h"
#include "mesh3d/polygon.h"
#include <cmath>

namespace mesh3d {

geometry::geometry()
{
}

geometry::~geometry()
{
    for(
        polygon_collection::iterator i = polygons().begin();
        i != polygons().end();
        ++i
    )
    {
        polygon* pol = *i;
        delete pol;
    }
    for(
        point_collection::iterator i = points().begin();
        i != points().end();
        ++i
    )
    {
        point *pnt = *i;
        delete pnt;
    }
}

void geometry::reserve_points(size_t point_count)
{
    if(point_count > m_points.size())
    {
        m_points.reserve(point_count);
    }
}

void geometry::reserve_polygons(size_t polygon_count)
{
    if(polygon_count > m_polygons.size())
    {
        m_polygons.reserve(polygon_count);
    }
}

point *geometry::make_point()
{
    mesh3d::point *pnt = new mesh3d::point();
    m_points.push_back(pnt);
    return pnt;
}

polygon *geometry::make_polygon()
{
    mesh3d::polygon *pol = new mesh3d::polygon();
    m_polygons.push_back(pol);
    return pol;
}

geometry::point_collection          &geometry::points  ()       { return m_points;   }
geometry::point_collection   const  &geometry::points  () const { return m_points;   }
geometry::polygon_collection        &geometry::polygons()       { return m_polygons; }
geometry::polygon_collection const  &geometry::polygons() const { return m_polygons; }

void geometry::compute_polygon_normals()
{
    std::tr1::shared_ptr<attribute_map<polygon*, vec3> > polygon_normals = polygon_attributes().find_or_create<vec3>("polygon_normals");
    std::tr1::shared_ptr<attribute_map<point*,   vec3> > point_locations = point_attributes().find<vec3>("point_locations");
    for(
        polygon_collection::iterator i = polygons().begin();
        i != polygons().end();
        ++i
    )
    {
        polygon *pol = *i;
        pol->compute_normal(
            polygon_normals,
            point_locations
        );
    }
}
void geometry::compute_polygon_centroids()
{
    std::tr1::shared_ptr<attribute_map<polygon*, vec3> > polygon_centroids = polygon_attributes().find_or_create<vec3>("polygon_centroids");
    std::tr1::shared_ptr<attribute_map<point*,   vec3> > point_locations = point_attributes().find<vec3>("point_locations");

    for(
        polygon_collection::iterator i = polygons().begin();
        i != polygons().end();
        ++i
    )
    {
        polygon *pol = *i;
        pol->compute_centroid(
            polygon_centroids,
            point_locations
        );
    }
}

void geometry::compute_corner_normals(float max_smoothing_angle)
{
    std::tr1::shared_ptr<attribute_map<corner*,  vec3> > corner_normals  = corner_attributes ().find_or_create<vec3>("corner_normals");
    std::tr1::shared_ptr<attribute_map<polygon*, vec3> > polygon_normals = polygon_attributes().find<vec3>("polygon_normals");
    std::tr1::shared_ptr<attribute_map<point*,   vec3> > point_locations = point_attributes  ().find<vec3>("point_locations");
    float cos_max_smoothing_angle = std::cos(max_smoothing_angle);

    for(
        polygon_collection::iterator i = polygons().begin();
        i != polygons().end();
        ++i
    )
    {
        polygon *pol = *i;

        if(max_smoothing_angle == 0)
        {
            pol->copy_polygon_normal_to_corners(
                corner_normals,
                polygon_normals
            );
        }
        else
        {
            pol->compute_corner_normals(
                corner_normals,
                polygon_normals,
                point_locations,
                cos_max_smoothing_angle
            );
        }
    }
}

point *geometry::make_point(float x, float y, float z)
{
    point *pnt = make_point();
    std::tr1::shared_ptr<attribute_map<point*, vec3> > point_positions = 
        point_attributes().find_or_create<vec3>("point_locations");

    point_positions->set_value(pnt, vec3(x, y, z));

    return pnt;
}

point *geometry::make_point(double x, double y, double z)
{
    return make_point(float(x), float(y), float(z));
}

polygon *geometry::make_polygon(point *p0)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2, point *p3)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    p->make_corner(p3);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2, point *p3, point *p4)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    p->make_corner(p3);
    p->make_corner(p4);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2, point *p3, point *p4, point *p5)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    p->make_corner(p3);
    p->make_corner(p4);
    p->make_corner(p5);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2, point *p3, point *p4, point *p5, point *p6)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    p->make_corner(p3);
    p->make_corner(p4);
    p->make_corner(p5);
    p->make_corner(p6);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2, point *p3, point *p4, point *p5, point *p6, point *p7)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    p->make_corner(p3);
    p->make_corner(p4);
    p->make_corner(p5);
    p->make_corner(p6);
    p->make_corner(p7);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2, point *p3, point *p4, point *p5, point *p6, point *p7, point *p8)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    p->make_corner(p3);
    p->make_corner(p4);
    p->make_corner(p5);
    p->make_corner(p6);
    p->make_corner(p7);
    p->make_corner(p8);
    return p;
}

polygon *geometry::make_polygon(point *p0, point *p1, point *p2, point *p3, point *p4, point *p5, point *p6, point *p7, point *p8, point *p9)
{
    polygon *p = make_polygon();
    p->make_corner(p0);
    p->make_corner(p1);
    p->make_corner(p2);
    p->make_corner(p3);
    p->make_corner(p4);
    p->make_corner(p5);
    p->make_corner(p6);
    p->make_corner(p7);
    p->make_corner(p8);
    p->make_corner(p9);
    return p;
}

polygon *geometry::make_polygon(size_t p0)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    p->make_corner(m_points[p3]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    p->make_corner(m_points[p3]);
    p->make_corner(m_points[p4]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    p->make_corner(m_points[p3]);
    p->make_corner(m_points[p4]);
    p->make_corner(m_points[p5]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    p->make_corner(m_points[p3]);
    p->make_corner(m_points[p4]);
    p->make_corner(m_points[p5]);
    p->make_corner(m_points[p6]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    p->make_corner(m_points[p3]);
    p->make_corner(m_points[p4]);
    p->make_corner(m_points[p5]);
    p->make_corner(m_points[p6]);
    p->make_corner(m_points[p7]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7, size_t p8)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    p->make_corner(m_points[p3]);
    p->make_corner(m_points[p4]);
    p->make_corner(m_points[p5]);
    p->make_corner(m_points[p6]);
    p->make_corner(m_points[p7]);
    p->make_corner(m_points[p8]);
    return p;
}

polygon *geometry::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7, size_t p8, size_t p9)
{
    polygon *p = make_polygon();
    p->make_corner(m_points[p0]);
    p->make_corner(m_points[p1]);
    p->make_corner(m_points[p2]);
    p->make_corner(m_points[p3]);
    p->make_corner(m_points[p4]);
    p->make_corner(m_points[p5]);
    p->make_corner(m_points[p6]);
    p->make_corner(m_points[p7]);
    p->make_corner(m_points[p8]);
    p->make_corner(m_points[p9]);
    return p;
}

}  /*  namespace mesh3d  */