triangle.h

//
// triangle.h
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Curtis Janssen <cljanss@limitpt.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit 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 Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _math_isosurf_triangle_h
#define _math_isosurf_triangle_h
 
#ifdef __GNUC__
#pragma interface
#endif
 
#include <math/isosurf/tricoef.h>
#include <math/isosurf/edge.h>
 
namespace sc {
 
class Triangle: public RefCount {
  protected:
    // these break gcc 2.5.8
    //unsigned int _order:5;
    //unsigned int _orientation0:1;
    //unsigned int _orientation1:1;
    //unsigned int _orientation2:1;
    //unsigned char _order;
    //unsigned char _orientation0;
    //unsigned char _orientation1;
    //unsigned char _orientation2;
    unsigned int _order;
    unsigned int _orientation0;
    unsigned int _orientation1;
    unsigned int _orientation2;
    Ref<Edge> _edges[3];
    Ref<Vertex> *_vertices;
  public:
    enum {max_order = 10};
 
    Triangle(const Ref<Edge>& v1, const Ref<Edge>& v2, const Ref<Edge>& v3,
             unsigned int orient0 = 0);
    Ref<Edge> edge(int i) { return _edges[i]; };
    int contains(const Ref<Edge>&) const;
    unsigned int orientation(int i) const
    {
      return i==0?_orientation0:i==1?_orientation1:_orientation2;
    }
    unsigned int orientation(const Ref<Edge>&) const;
    ~Triangle();
    void add_edges(std::set<Ref<Edge> >&);
    void add_vertices(std::set<Ref<Vertex> >&);
 
    // returns the surface area element
    // 0<=r<=1, 0<=s<=1, 0<=r+s<=1
    // Ref<Vertex> is the intepolated vertex (both point and normal)
    void interpolate(const Ref<TriInterpCoef>&,
                     double r,double s,const Ref<Vertex>&v, SCVector3& dA);
    void interpolate(double r,double s,const Ref<Vertex>&v, SCVector3& dA);
    void interpolate(double r,double s,const Ref<Vertex>&v, SCVector3& dA,
                     const Ref<Volume> &vol, double isovalue);
 
    // returns a corner vertex from the triangle
    // i = 0 is the (0,0) vertex (or L1 = 1, L2 = 0, L3 = 0)
    // i = 1 is the (r=1,s=0) vertex (or L1 = 0, L2 = 1, L3 = 0)
    // i = 2 is the (r=0,s=1) vertex (or L1 = 0, L2 = 0, L3 = 1)
    Ref<Vertex> vertex(int i);
 
    double flat_area();
 
    // flip the orientation
    void flip();
 
    unsigned int order() const { return _order; }
 
    void set_order(int order, const Ref<Volume>&vol,double isovalue);
};
 
 
 
class TriangleIntegrator: public DescribedClass {
  private:
    int _n;
    double* _r;
    double* _s;
    double* _w;
    // precomputed interpolation coefficients for triangles of various orders
    Ref<TriInterpCoef> **coef_; // max_order by _n
  protected:
    void set_r(int i,double r);
    void set_s(int i,double s);
    void set_w(int i,double w);
    void init_coef();
    void clear_coef();
  public:
    TriangleIntegrator(const Ref<KeyVal>&);
    TriangleIntegrator(int n);
    virtual ~TriangleIntegrator();
    inline double w(int i) { return _w[i]; }
    inline double r(int i) { return _r[i]; }
    inline double s(int i) { return _s[i]; }
    inline int n() { return _n; }
    virtual void set_n(int n);
    Ref<TriInterpCoef> coef(int order, int i) { return coef_[order-1][i]; }
};
 
 
class GaussTriangleIntegrator: public TriangleIntegrator {
  private:
    void init_rw(int order);
  public:
    GaussTriangleIntegrator(const Ref<KeyVal>&);
    GaussTriangleIntegrator(int order);
    ~GaussTriangleIntegrator();
    void set_n(int n);
};
 
}
 
#endif
 
// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End: