MeshOfTriangles.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  This program 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 General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: MeshOfTriangles.hpp,v 1.4 2008/03/04 00:17:57 delpinux Exp $

#ifndef MESH_OF_TRIANGLES_HPP
#define MESH_OF_TRIANGLES_HPP

#include <Vector.hpp>
#include <Triangle.hpp>

#include <Mesh.hpp>

#include <Octree.hpp>
#include <Connectivity.hpp>

#include <ErrorHandler.hpp>
#include <EdgesBuilder.hpp>

class MeshOfTriangles
  : public Mesh
{
public:
  enum {
    family = Mesh::plane
  };

  typedef Triangle CellType;
  typedef Edge FaceType;

  typedef struct {} BorderMeshType; 
  typedef Mesh::T_iterator<MeshOfTriangles, Triangle> iterator;
  typedef Mesh::T_iterator<const MeshOfTriangles, const Triangle> const_iterator;

private:
  ReferenceCounting<Vector<Triangle> > __cells; 
  ReferenceCounting<Octree<size_t, 2> > __octree; 
  TinyVector<2,real_t> __a;     
  TinyVector<2,real_t> __b;     
  Connectivity<MeshOfTriangles> __connectivity; 
public:
  bool hasBorderMesh() const
  {
    return false;
  }

  ConstReferenceCounting<Mesh> borderBaseMesh() const
  {
    throw ErrorHandler(__FILE__,__LINE__,
                       "not implemented yet",
                       ErrorHandler::unexpected);

    return 0;
  }

  std::string typeName() const
  {
    return "mesh of triangles";
  }

  void buildLocalizationTools();

  void buildFaces()
  {
    this->buildEdges();
  }

  void buildEdges()
  {
    EdgesBuilder<MeshOfTriangles> edgesBuilder(*this);
    __edgesSet = edgesBuilder.edgesSet();
  }

  const Connectivity<MeshOfTriangles>& connectivity() const
  {
    return __connectivity;
  }

  Connectivity<MeshOfTriangles>& connectivity()
  {
    return __connectivity;
  }

  inline bool inside(const real_t& x, const real_t& y, const real_t& z) const
  {
    return not(this->find(x, y, z).end());
  }

  inline bool inside(const TinyVector<3>& p) const
  {
    return this->inside(p[0], p[1], p[2]);
  }

  MeshOfTriangles::const_iterator
  find(const TinyVector<3, real_t>& P) const
  {
    return find(P[0], P[1], P[2]);
  }

  MeshOfTriangles::const_iterator
  find(const double& x,
       const double& y,
       const double& z) const;


  //   /** 
  //    * Computes fictitious cells of the mesh
  //    * 
  //    */
  //   void computesFictitiousCells() const
  //   {
  //     this->__computesFictitiousCells<Triangle>(*__cells);
  //   }

  Triangle& cell(const size_t& i)
  {
    return (*__cells)[i];
  }

  const Triangle& cell(const size_t& i) const
  {
    return (*__cells)[i];
  }

  inline void setNumberOfCells(const int n)
  {
    __cells = new Vector<Triangle>(n);
  }

  inline const size_t& numberOfCells() const
  {
    return (*__cells).size();
  }

  size_t cellNumber(const Triangle& t) const
  {
    return (*__cells).number(t);
  }

  inline bool hasFaces() const
  {
    return __edgesSet != 0;
  }

  inline const size_t& numberOfFaces() const
  {
    return __edgesSet->numberOfEdges();
  }

  const FaceType& face(const size_t& i) const
  {
    return (*__edgesSet)[i];
  }

  size_t faceNumber(const FaceType& f) const
  {
    return __edgesSet->number(f);
  }

  MeshOfTriangles(const size_t& theNumberOfCells)
    : Mesh(Mesh::trianglesMesh,
           Mesh::plane,
           0),
      __cells(new Vector<Triangle>(theNumberOfCells)),
      __connectivity(*this)
  {
    ;
  }

  MeshOfTriangles(ReferenceCounting<VerticesSet> vertices,
                  ReferenceCounting<VerticesCorrespondance> correspondances,
                  ReferenceCounting<Vector<Triangle> > triangles);

  MeshOfTriangles()
    : Mesh(Mesh::trianglesMesh,
           Mesh::plane,
           0),
      __connectivity(*this)
  {
    ;
  }

  ~MeshOfTriangles()
  {
    ;
  }
};

#endif // MESH_OF_TRIANGLES_HPP

---