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

namespace mesh3d {

/*  Computer corner normal with max smoothing angle  */ 
/*  Initialize corner normal to polygon normal,      */ 
/*  loop through all polygons contributing to the    */ 
/*  corner point, add all other polygon normals      */ 
/*  that are not too different, take average         */ 
void corner::compute_normal(
    std::tr1::shared_ptr<attribute_map<mesh3d::corner*,  vec3> > corner_normals,
    std::tr1::shared_ptr<attribute_map<mesh3d::polygon*, vec3> > polygon_normals,
    std::tr1::shared_ptr<attribute_map<mesh3d::point*,   vec3> > point_locations,
    float                                                        cos_max_smoothing_angle
)
{
    mesh3d::polygon *pol = polygon();
    mesh3d::point   *pnt = point  ();

    vec3 corner_normal;
 
    if(polygon_normals->has(pol) == false)
    {
        corner_normal = vec3(0, 0, 0);
    }
    else
    {
        vec3 polygon_normal = polygon_normals->value(pol);
        corner_normal       = polygon_normal;

        size_t point_corners = 0;
        size_t participants  = 0;
        for(
            point::corner_collection::iterator i = pnt->corners().begin();
            i != pnt->corners().end();
            ++i
        )
        {
            ++point_corners;
            mesh3d::corner  *point_corner = *i;
            mesh3d::polygon *neighbor_pol = point_corner->polygon();
            if( 
                (pol != neighbor_pol                ) &&
                (polygon_normals->has(neighbor_pol) ) &&
                (neighbor_pol->corners().size() > 2)
            )
            {
                vec3 neighbor_normal = polygon_normals->value(neighbor_pol);
                float cos_angle = dot(
                    polygon_normal, 
                    neighbor_normal
                );
                if(cos_angle < cos_max_smoothing_angle)
                {
                    corner_normal += neighbor_normal;
                    ++participants;
                }
            }
        }

        corner_normal = normalize(corner_normal);
    }
    corner_normals->set_value(this, corner_normal);
}

}  /*  namespace mesh3d  */