polygon.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/polygon.h"
#include "mesh3d/point.h"
#include "mesh3d/corner.h"
#include "mesh3d/attribute_map.h"
#include <cassert>
#include <cmath>
#include <exception>

namespace mesh3d {

polygon::~polygon()
{
    for(
        corner_collection::iterator i = m_corners.begin();
        i != m_corners.end();
        ++i
    )
    {
        mesh3d::corner *cor = *i;
        delete cor;
        *i = 0;
    }
    m_corners.clear();
}

void polygon::compute_normal(
    std::tr1::shared_ptr<attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals,
    std::tr1::shared_ptr<attribute_map<mesh3d::point*,   mesh3d::vec3> > point_locations
)
{
    if(m_corners.size() > 2)
    {
        corner_collection::iterator i = m_corners.begin();
        mesh3d::corner *c0 = *i; ++i;           /*  first  point in polygon  */ 
        mesh3d::corner *c1 = *i;                /*  second point in polygon  */ 
        mesh3d::corner *c2 = m_corners.back();  /*  last   point in polygon  */ 
        mesh3d::point  *p0 = c0->point();
        mesh3d::point  *p1 = c1->point();
        mesh3d::point  *p2 = c2->point();

        /*  Make sure all points are unique from others  */ 
        if(
            (p0 != p1) &&
            (p0 != p2) &&
            (p1 != p2)
        )
        {
            vec3 pos0   = point_locations->value(p0);
            vec3 pos1   = point_locations->value(p1);
            vec3 pos2   = point_locations->value(p2);
            vec3 normal = cross((pos2 - pos0), (pos1 - pos0));
            normal = normalize(normal);
            polygon_normals->set_value(this, normal);
        }
        else
        {
            throw std::exception("polygons with duplicate points\n");
        }

    }
}

void polygon::compute_centroid(
    std::tr1::shared_ptr<attribute_map<mesh3d::polygon*, mesh3d::vec3> >  polygon_centroids,
    std::tr1::shared_ptr<attribute_map<mesh3d::point*,   mesh3d::vec3> >  point_locations
)
{
    mesh3d::vec3 centroid = mesh3d::vec3(0.0f, 0.0f, 0.0f);
    int count = 0;
    for(
        corner_collection::iterator i = m_corners.begin();
        i != m_corners.end();
        ++i
    )
    {
        mesh3d::corner  *cor  = *i;
        mesh3d::point   *pnt  = cor->point();
        mesh3d::vec3    pos0 = point_locations->value(pnt);
        centroid += pos0;
        ++count;
    }
    if(count > 0)
    {
        centroid /= (float)(count);
        polygon_centroids->set_value(this, centroid);
    }
    else
    {
        polygon_centroids->set_value(this, centroid);
    }
}

void polygon::compute_corner_normals(
    std::tr1::shared_ptr<attribute_map<mesh3d::corner*,  mesh3d::vec3> > corner_normals, 
    std::tr1::shared_ptr<attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals, 
    std::tr1::shared_ptr<attribute_map<mesh3d::point*,   mesh3d::vec3> > point_locations,
    float                                                                cos_max_smoothing_angle
)
{
    if(m_corners.size() > 2)
    {
        for(
            corner_collection::iterator i = m_corners.begin();
            i != m_corners.end();
            ++i
        )
        {
            mesh3d::corner *cor = *i;
            cor->compute_normal(
                corner_normals,
                polygon_normals,
                point_locations,
                cos_max_smoothing_angle
            );
        }
    }
}

void polygon::copy_polygon_normal_to_corners(
    std::tr1::shared_ptr<attribute_map<mesh3d::corner*,  mesh3d::vec3> > corner_normals, 
    std::tr1::shared_ptr<attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals
)
{
    if(m_corners.size() > 2)
    {
        mesh3d::vec3 pol_normal = polygon_normals->value(this);
        for(
            corner_collection::iterator i = m_corners.begin();
            i != m_corners.end();
            ++i
        )
        {
            mesh3d::corner *cor = *i;
            corner_normals->set_value(cor, pol_normal);
        }
    }
}

mesh3d::corner *polygon::corner(mesh3d::point *pnt)
{
    for(
        corner_collection::iterator i = m_corners.begin();
        i != m_corners.end();
        ++i
    )
    {
        mesh3d::corner *cor = *i;
        if(pnt == cor->point())
        {
            return cor;
        }
    }
    return 0;
}

mesh3d::corner *polygon::make_corner(mesh3d::point *pnt)
{
    mesh3d::corner *cor = new mesh3d::corner(pnt, this);
    pnt->add_corner(cor);
    m_corners.push_back(cor);
    return cor;
}

}  /*  namespace mesh3d  */