Package: GrAL Cartesian2D       

---

Gral/Grids/Cartesian2D/stored-geometry.h

Go to the documentation of this file.

#ifndef NMWR_GB_STORED_FOR_CARTESIAN2D_H
#define NMWR_GB_STORED_FOR_CARTESIAN2D_H


/* ------------------------------------------------------------

    Copyright (C) 1997 - 2009 Guntram Berti

    This file is part of the Grid Algorithms Library (GrAL),
    available at http://gral.berti-cmm.de

    GrAL is distributed under the MIT license,
    see the file LICENSE or http://gral.berti-cmm.de/license

--------------------------------------------------------------- */


#include "Geometry/point-traits.h"
#include "Geometry/algebraic-primitives.h"
#include "Gral/Base/common-grid-basics.h"
#include "Gral/Geometries/geometric-types-2d.h"

#include "Gral/Grids/Cartesian2D/cartesian-grid2d.h"
#include "Gral/Grids/Cartesian2D/grid-functions.h"
#include "Gral/Grids/Cartesian2D/geometry-extensions2d.h"

namespace GrAL {

namespace cartesian2d {

template<class Coord2D>
class stored_geometry_base : public grid_types<RegGrid2D>,
                             public algebraic_primitives<Coord2D>
{
public:
  typedef grid_geometry_category category;
  typedef Coord2D   coord_type;
  typedef RegGrid2D grid_type;

  stored_geometry_base() :  g(0) {} 

  stored_geometry_base(const RegGrid2D& gg) 
    : g(&gg), coords_(gg) {}
  
  void init(RegGrid2D const& gg) 
  {
    g = &gg;
    coords_.set_grid(gg);
  }

  void set_grid(const RegGrid2D& gg) { g = &gg; coords_.set_grid(gg);}
  void rebind  (const RegGrid2D& gg) { g = &gg; coords_.rebind  (gg);}
  bool bound() const { return (g != 0);}

  const grid_type& TheGrid() const { return *g;}

  // is this always possible?
  unsigned space_dimension() const { return Dim(coord(*(TheGrid().FirstVertex())));}

  const coord_type& coord(const Vertex& v) const { return coords_(v); }
        coord_type& coord(const Vertex& v)       { return coords_[v]; }

  void read(std::istream& in) {
    for(typename grid_function<Vertex,coord_type>::iterator ii = coords_.begin(); ii != coords_.end(); ++ii)
      in >> *ii;
  }

private:
  const grid_type* g; // reference
  grid_function<Vertex,coord_type> coords_;
};



template<class COORD>
class stored_geometry 
  :   public dimension_dependend_extensions2d<stored_geometry_base<COORD>, 
                                              stored_geometry<COORD>, 
                                              point_traits<COORD>::dimension>

{
  
public:
  typedef stored_geometry_base<COORD>  base;
  typedef stored_geometry<COORD>             self;

  typedef point_traits<COORD> pt;
  typedef algebraic_primitives<COORD> ap;

  typedef typename base::Vertex Vertex;
  typedef typename base::Edge   Edge;
  typedef typename base::Face   Face;
  typedef typename base::Facet  Facet;
  typedef typename base::Cell   Cell;

  typedef typename base::CellIterator        CellIterator;
  typedef typename base::CellOnCellIterator  CellOnCellIterator;
  typedef typename base::FacetOnCellIterator FacetOnCellIterator;

  typedef typename base::coord_type coord_type;
  // typedef typename base::EdgeIterator   EdgeIterator;



  stored_geometry() {}
  stored_geometry(const RegGrid2D& gg) 
    { base::init(gg); }

  friend std::istream& operator>>(std::istream& in, self& rs) { rs.read(in); return in;}

  typedef Segment<Edge,base>   segment_type;

  typedef Polygon2d<Face,base> polygon_type;

  segment_type segment(const Edge& e) const { return segment_type(e,basic_geom());}
  polygon_type polygon(const Face& f) const { return polygon_type(f,basic_geom());}

  double volume(const Edge& e) const  { return (segment_type(e,basic_geom()).length());}
  double length(const Edge& e) const  { return (segment_type(e,basic_geom()).length());}

  double volume(const Cell& c) const { return (polygon_type(c,basic_geom()).area());}
  
  coord_type center(const Edge& e) const {return(segment_type(e,basic_geom()).center());}
  
  coord_type center(const Cell& c) const {return(polygon_type(c,basic_geom()).center());}

private:
  const base& basic_geom() const { return *this;}  
};

} // namespace cartesian2d
} // namespace GrAL 

#endif

---

©  Guntram Berti 1997-2009. See the GrAL Homepage for up-to-date information.

---