Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *
* This file is part of GEL, http://www.imm.dtu.dk/GEL
* Copyright (C) the authors and DTU Informatics
* For license and list of authors, see ../../doc/intro.pdf
* ----------------------------------------------------------------------- */

#include "../CGLA/Vec3f.h"
#include <stdio.h>
#include <iostream>
#include <set>

#include "TriMesh.h"

using namespace std;
using namespace CGLA;

namespace Geometry 
{
  int TriMesh::find_material(const string& name) const
  {
    for(size_t i = 0; i < materials.size(); ++i)
      if(materials[i].name == name)
        return i;
    return 0;
  }
        
  void TriMesh::compute_normals()
  {
    // By default the normal faces are the same as the geometry faces
    // and there are just as many normals as vertices, so we simply
    // copy.
    normals = geometry;

    const int NV = normals.no_vertices();
    // The normals are initialized to zero.
    int i;
    for(i=0;i<NV; ++i)
      normals.vertex_rw(i) = Vec3f(0);

    // For each face
    int NF = geometry.no_faces();
    for(i=0;i<NF; ++i)
    {
      // Compute the normal
      const Vec3i& f  = geometry.face(i);
      const Vec3f& p0 = geometry.vertex(f[0]);
      const Vec3f& a  = geometry.vertex(f[1]) - p0;
      const Vec3f& b  = geometry.vertex(f[2]) - p0;
      Vec3f face_normal = cross(a,b);
      float l = sqr_length(face_normal);
      if(l > 0.0f)
        face_normal /= sqrt(l);

      // Add the angle weighted normal to each vertex
      for(int j=0;j<3; ++j)
      {
        const Vec3f& p0 = geometry.vertex(f[j]);
        Vec3f a = geometry.vertex(f[(j+1)%3]) - p0;
        float l_a = sqr_length(a);
        if(l_a > 0.0f)
          a /= sqrt(l_a);
        Vec3f b = geometry.vertex(f[(j+2)%3]) - p0;
        float l_b = sqr_length(b);
        if(l_b > 0.0f)
          b /= sqrt(l_b);
        float d = max(-1.0f, min(1.0f, dot(a,b)));
        normals.vertex_rw(f[j]) += face_normal * acos(d);
      }
    }

    // Normalize all normals
    for(i=0;i<NV; ++i)
    {
      float l_vert_rw = sqr_length(normals.vertex_rw(i));
      if(l_vert_rw > 0.0f)
        normals.vertex_rw(i) /= sqrt(l_vert_rw);
    }
  }

  void TriMesh::compute_areas()
  {
    int no_of_faces = geometry.no_faces();
    surface_area = 0.0f;
    face_areas.resize(no_of_faces);
    face_area_cdf.resize(no_of_faces);
    for(int i = 0; i < no_of_faces; ++i)
    {
      const Vec3i& f  = geometry.face(i);
      const Vec3f& p0 = geometry.vertex(f[0]);
      const Vec3f& a  = geometry.vertex(f[1]) - p0;
      const Vec3f& b  = geometry.vertex(f[2]) - p0;
      face_areas[i] = 0.5f*cross(a, b).length();
      face_area_cdf[i] = surface_area + face_areas[i];
      surface_area += face_areas[i];
    }
    if(surface_area > 0.0f)
      for(int i = 0; i < no_of_faces; ++i)
        face_area_cdf[i] /= surface_area;
  }

  bool TriMesh::get_bbox(Vec3f& p0, Vec3f& p7) const
  {
    if(geometry.no_vertices() == 0)
      return false;

    int i;
    p0 = geometry.vertex(0);
    p7 = geometry.vertex(0);
    for(i = 1; i < geometry.no_vertices(); ++i) 
    {
      p0 = v_min(geometry.vertex(i), p0);
      p7 = v_max(geometry.vertex(i), p7);
    }
    return true;
  }

  bool TriMesh::get_bsphere(Vec3f& c, float& r) const
  {
    Vec3f p0,p7;
    if(!get_bbox(p0, p7))
      return false;

    Vec3f rad = (p7 - p0)/2.0;
    c = p0 + rad;
    r = rad.length();
    return true;
  }

  void TriMesh::transform(const Mat4x4f& m)
  {
    for(int i = 0; i < geometry.no_vertices(); ++i)
      geometry.vertex_rw(i) = m.mul_3D_point(geometry.vertex(i));
    for(int i = 0; i < normals.no_vertices(); ++i)
      normals.vertex_rw(i) = normalize(m.mul_3D_vector(normals.vertex(i)));
  }

  void TriMesh::tex_transform(const Mat4x4f& m)
  {
    for(int i = 0; i < texcoords.no_vertices(); ++i)
      texcoords.vertex_rw(i) = m.mul_3D_point(texcoords.vertex(i));
  }

  void TriMesh::tex_transform(const Mat4x4f& m, const string& material)
  {
    set<int> v_touched;
    int m_idx = find_material(material);
    for(int i = 0; i < texcoords.no_faces(); ++i)
      if(mat_idx[i] == m_idx)
      {
        Vec3i face = texcoords.face(i);
        for(int j = 0; j < 3; ++j)
        {
          int v_idx = face[j];
          if(v_touched.count(v_idx) == 0)
          {
            v_touched.insert(v_idx);
            texcoords.vertex_rw(v_idx) = m.mul_3D_point(texcoords.vertex(v_idx));
          }
        }
      }
  }
}