HeTraits.h

Go to the documentation of this file.

//===========================================================================
//
// File: HeTraits.h
//
// Created: March 1 2001
//
// Author: Øyvind Hjelle <oyvind.hjelle@math.sintef.no>
//
// Revision: $Id: HeTraits.h,v 1.2 2006/07/26 12:08:44 oyvindhj Exp $
//
// Description:
//
//===========================================================================
// Copyright (C) 2000-2003 SINTEF Applied Mathematics.  All rights reserved.
//
// This file may be distributed under the terms of the Q Public License
// as defined by Trolltech AS of Norway and appearing in the file
// LICENSE.QPL included in the packaging of this file.
// 
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
//===========================================================================


#ifndef _HALF_EDGE_TRAITS_
#define _HALF_EDGE_TRAITS_


#include <ttl/halfedge/HeTriang.h>
#include <ttl/halfedge/HeDart.h>


namespace hed {


  //------------------------------------------------------------------------------------------------
  // Traits class for the half-edge data structure
  //------------------------------------------------------------------------------------------------
  
  struct TTLtraits {
    
    // The actual triangulation object
    static Triangulation* triang_;
    
    typedef double real_type;


    //----------------------------------------------------------------------------------------------
    // ------------------------------- Geometric Predicates Group ---------------------------------
    //----------------------------------------------------------------------------------------------


    //----------------------------------------------------------------------------------------------
    static real_type scalarProduct2d(const Dart& v1, const Dart& v2) {
      Dart v10 = v1; v10.alpha0();
      Dart v20 = v2; v20.alpha0();
      return ttl_util::scalarProduct2d(v10.x()-v1.x(), v10.y()-v1.y(),
                                       v20.x()-v2.x(), v20.y()-v2.y());
    }


    //----------------------------------------------------------------------------------------------
    static real_type scalarProduct2d(const Dart& v, const Node& p) {
      Dart d0 = v; d0.alpha0();
      return ttl_util::scalarProduct2d(d0.x() - v.x(), d0.y() - v.y(),
                                       p.x() - v.x(), p.y() - v.y());
    }


    //----------------------------------------------------------------------------------------------
    static real_type crossProduct2d(const Dart& v1, const Dart& v2) {
      Dart v10 = v1; v10.alpha0();
      Dart v20 = v2; v20.alpha0();
      return ttl_util::crossProduct2d(v10.x()-v1.x(), v10.y()-v1.y(), 
                                      v20.x()-v2.x(), v20.y()-v2.y());
    }


    //----------------------------------------------------------------------------------------------
    static real_type crossProduct2d(const Dart& v, const Node& p) {
      Dart d0 = v; d0.alpha0();
      return ttl_util::crossProduct2d(d0.x() - v.x(), d0.y() - v.y(),
                                      p.x() - v.x(), p.y() - v.y());
    }


    //----------------------------------------------------------------------------------------------
    static real_type orient2d(const Dart& n1, const Dart& n2, const Node& p) {
      real_type pa[2]; real_type pb[2]; real_type pc[2];
      pa[0] = n1.x(); pa[1] = n1.y();
      pb[0] = n2.x(); pb[1] = n2.y();
      pc[0] =  p.x(); pc[1] =  p.y();
      return ttl_util::orient2dfast(pa, pb, pc);
    }


    //----------------------------------------------------------------------------------------------
    static real_type orient2d(const Dart& n1, const Dart& n2, const Dart& p) {
      real_type pa[2]; real_type pb[2]; real_type pc[2];
      pa[0] = n1.x(); pa[1] = n1.y();
      pb[0] = n2.x(); pb[1] = n2.y();
      pc[0] =  p.x(); pc[1] =  p.y();
      return ttl_util::orient2dfast(pa, pb, pc);
    }



    // A rationale for directing these functions to traits is:
    // e.g., constraints

    //----------------------------------------------------------------------------------------------
    /* Checks if the edge associated with \e dart should be swapped
    *   according to the Delaunay criterion.<br>
    *
    *   \note
    *   This function is also present in the TTL as ttl::swapTestDelaunay.<br>
    *   Thus, the function can be implemented simply as:
    *   \code
    *   { return ttl::swapTestDelaunay<TTLtraits>(dart); }
    *   \endcode
    */
    //static bool swapTestDelaunay(const Dart& dart) {
    //  return ttl::swapTestDelaunay<TTLtraits>(dart);
    //}


    //----------------------------------------------------------------------------------------------
    /* Checks if the edge associated with \e dart can be swapped, i.e.,
    *   if the edge is a diagonal in a (strictly) convex quadrilateral.
    *   This function is also present as ttl::swappableEdge.
    */
    //static bool swappableEdge(const Dart& dart) {
    //  return ttl::swappableEdge<TTLtraits>(dart);
    //}


    //----------------------------------------------------------------------------------------------
    /* Checks if the edge associated with \e dart should be \e fixed, meaning
    *   that it should never be swapped. ??? Use when constraints.
    */
    //static bool fixedEdge(const Dart& dart) {
    //  return dart.getEdge()->isConstrained();
    //}


    //----------------------------------------------------------------------------------------------
    // ----------------------- Functions for Delaunay Triangulation Group -------------------------
    //----------------------------------------------------------------------------------------------


    //----------------------------------------------------------------------------------------------
    static void swapEdge(Dart& dart) {
      if (!dart.getEdge()->isConstrained()) triang_->swapEdge(*dart.getEdge());
    }


    //----------------------------------------------------------------------------------------------
    static void splitTriangle(Dart& dart, Node& point) {
      Edge* edge = triang_->splitTriangle(*dart.getEdge(), point);
      dart.init(edge);
    }
    


    //----------------------------------------------------------------------------------------------
    // --------------------------- Functions for removing nodes Group -----------------------------
    //----------------------------------------------------------------------------------------------


    //----------------------------------------------------------------------------------------------
    static void reverse_splitTriangle(Dart& dart) {
      triang_->reverse_splitTriangle(*dart.getEdge());
    }


    //----------------------------------------------------------------------------------------------
    static void removeBoundaryTriangle(Dart& d) {
      triang_->removeTriangle(*d.getEdge());
    }


  };

}; // End of hed namespace

#endif