triface.h

/* Copyright (C) 2015 David Eller <david@larosterna.com>
 * 
 * Commercial License Usage
 * Licensees holding valid commercial licenses may use this file in accordance
 * with the terms contained in their respective non-exclusive license agreement.
 * For further information contact david@larosterna.com .
 *
 * GNU General Public License Usage
 * Alternatively, this file may be used under the terms of the GNU General
 * Public License version 3.0 as published by the Free Software Foundation and
 * appearing in the file gpl.txt included in the packaging of this file.
 */
 
#ifndef GENUA_TRIFACE_H
#define GENUA_TRIFACE_H

#include "smatrix.h"
#include "dvector.h"
#include "point.h"
#include "triedge.h"

class TriMesh;
class Plane;

class TriFace
{
  public:
    
    TriFace() : ftag(0), msh(0) {}
    
    TriFace(const TriMesh *m, uint a, uint b, uint c)
      : ftag(0), msh(m) {order(a,b,c);}
  
    void assign(const TriMesh *m, uint a, uint b, uint c) {
      order(a, b, c);
      msh = m;
    }
    
    bool isValid() const {
      if (v[0] == v[1] or v[0] == v[2] or v[1] == v[2])
        return false;
      else
        return true;
    }

    bool inRange() const;
    
    void invalidate() { v[0]=v[1]=v[2] = NotFound; }
    
    const TriMesh *mesh() const {return msh;}
    
    const uint *vertices() const {return v;}
    
    uint *vertices() {return v;}
    
    void getVertices(uint *vi) const {
      vi[0] = v[0];
      vi[1] = v[1];
      vi[2] = v[2];
    }
    
    uint opposed(const TriEdge & e) const {
      uint s = e.source();
      uint t = e.target();
      for (uint k=0; k<3; ++k) {
        uint vk = v[k];
        if (vk != s and vk != t)
          return vk;
      }
      return NotFound;
    }
    
    void bind(const TriMesh *m, uint off = 0) {
      msh = m;
      v[0] += off;
      v[1] += off;
      v[2] += off;
    }
    
    void reverse() {std::swap(v[1], v[2]);}
    
    void itranslate(const Indices & repl) {
      order(repl[v[0]], repl[v[1]], repl[v[2]]);
    }
    
    uint replace(uint iold, uint inew) {
      for (uint k=0; k<3; ++k) {
        if (v[k] == iold) {
          v[k] = inew;
          order(v[0], v[1], v[2]);
          return k;
        }
      }
      return NotFound;
    }
    
    Vct3 eval(Real up, Real vp) const;
    
    Vct3 center() const;
    
    Vct3 normal() const;
    
    Real area() const;
    
    Real normal(Vct3 & nrm) const;
    
    Real corner(uint i) const;
    
    Real solidAngle(uint idx) const;
    
    void edgeLengths(Vct3 & elen) const;
    
    Vct3 project(const Vct3 & pt) const;

    Vct3 pierce(const Vct3 & a, const Vct3 & b) const;
    
    Real minDistance(const Vct3 & pt, Vct2 & foot) const;
    
    bool intersect(const Plane & pln, Vct3 & src, Vct3 & trg) const;

    void gradient(Mtx33 & gm) const;
    
    Vct3 gradient(const Vector & x) const;
    
    CpxVct3 gradient(const CpxVector & x) const;
    
    void xIntegrate(const Vector & p, const Vct3 & ref, Vct3 & pn, Vct3 & rxpn) const;
    
    Real dotIntegrate(const Vector & p, const PointList<3> & z) const;
    
    bool operator< (const TriFace & a) const {
      if (v[0] < a.v[0])
        return true;
      else if (v[0] > a.v[0])
        return false;
      else if (v[1] < a.v[1])
        return true;
      else if (v[1] > a.v[1])
        return false;
      else
        return (v[2] < a.v[2]);
    }
    
    bool operator== (const TriFace & a) const {
      if (v[0] != a.v[0])
        return false;
      else if (v[1] != a.v[1])
        return false;
      else if (v[2] != a.v[2])
        return false;
      else
        return true;
    }
    
    bool equivalent(const TriFace & a) const {
      if (v[0] != a.v[0])
        return false;
      else if (v[1] == a.v[1] and v[2] == a.v[2])
        return true;
      else if (v[2] == a.v[1] and v[1] == a.v[2])
        return true;
      else
        return false;
    }
    
    bool operator!= (const TriFace & a) const {
      return !(*this == a);
    }

    int tag() const {return ftag;}

    void tag(int t) {ftag = t;}
    
    uint64_t hash() const {
      uint64_t a = uint64_t(v[0]);
      uint64_t b = uint64_t(v[1]);
      uint64_t c = uint64_t(v[2]);
      uint64_t d = uint64_t(ptrdiff_t(msh));
      return jenkins_hash(a, b, c, d);
    }
    
  protected:
    
    void order(uint a, uint b, uint c) {
      if (a < b and a < c) {
        v[0] = a;
        v[1] = b;
        v[2] = c;
      } else if (b < a and b < c) {
        v[0] = b;
        v[1] = c;
        v[2] = a;
      } else {
        v[0] = c;
        v[1] = a;
        v[2] = b;
      }
    }
    
  protected:
    
    uint v[3];
    
    int ftag;
    
    const TriMesh *msh;
};

struct global_face_less 
{
  bool operator()(const TriFace & a, const TriFace & b) const
  {
    const TriMesh *am(a.mesh());
    const TriMesh *bm(b.mesh());
    if (am == bm) 
      return a < b;
    else
      return am < bm;
  }
};

struct global_face_equal
{
  bool operator()(const TriFace & a, const TriFace & b) const
  {
    const TriMesh *am(a.mesh());
    const TriMesh *bm(b.mesh());
    if (am != bm) 
      return false;
    else
      return a == b;
  }
};

struct face_hash 
{
  size_t operator() (const TriFace & a) const {return a.hash();}
};

#endif