coMiniGrid.h

Go to the documentation of this file.

/* This file is part of COVISE.
 
   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.
 
 * License: LGPL 2+ */
 
#ifndef _COVISE_MINI_GRID_H_
#define _COVISE_MINI_GRID_H_
 
// These are auxiliary classes involved in the RainAlgorithm
// as used in class coFeatureLines
 
#include "MagmaUtils.h"
#include "unordered_set.h"
 
namespace covise
{
 
// coTriEdge stands for an ordered pair of nodes defining an
// edge in a grid
class coTriEdge
{
public:
    coTriEdge();
    coTriEdge(int i, int j);
    bool operator==(const coTriEdge &rhs) const;
    bool operator<(const coTriEdge &rhs) const;
    int getMin() const;
    int getMax() const;
 
private:
    int min_;
    int max_;
};
 
// HashCoTriEdge is defined in order to improve
// the performance of the algorithm, as it makes
// it possible to use hashed containers
struct HashCoTriEdge
{
    size_t operator()(const coTriEdge &edge) const;
    bool operator()(const coTriEdge &edge0, const coTriEdge &edge1) const;
#if defined(__INTEL_COMPILER) || defined(WIN32)
    enum
    {
        bucket_size = 4,
        min_buckets = 8
    };
#endif
};
 
// coTestNeighbour describes a neighbourhood
// relationship between a given cell (not the one
// indicated in the contructor) and another one (the one
// referrred to by parameter cell in constructor or variable cell_).
class coTestNeighbour
{
public:
    // cell has to refer to the mini-numbering (see below)
    coTestNeighbour(int cell, coTriEdge edge);
    int CellLabel() const;
    coTriEdge GetEdge() const;
 
private:
    int cell_;
    coTriEdge edge_;
};
 
// coFeatureBorder describes a set of edges
class coFeatureBorder
{
public:
    coFeatureBorder(const unordered_set<coTriEdge, HashCoTriEdge> &set_kanten);
    virtual ~coFeatureBorder();
    // tests whether the edge associated with neighbourhood tn
    // belongs to this set of edges
    bool IsIn(const coTestNeighbour &tn) const;
 
private:
    bool IsIn(const coTriEdge &edge) const;
    unordered_set<coTriEdge, HashCoTriEdge> hash_segments_;
};
 
// coTestNeighbourhoodContainer describes a set of
// neighbour relationships between a given cell and
// its neighbours
class coTestNeighbourhoodContainer
{
public:
    void Add(const coTestNeighbour &tn)
    {
        container_.push_back(tn);
    }
    typedef vector<coTestNeighbour>::iterator iterator;
    iterator begin()
    {
        return container_.begin();
    }
    iterator end()
    {
        return container_.end();
    }
 
private:
    vector<coTestNeighbour> container_;
};
 
// coMiniGrid describes a subset of a grid
// In our application, it describes the subgrid around
// a given node
class coMiniGrid
{
public:
    typedef coFeatureBorder Border;
    typedef coTestNeighbourhoodContainer NeighbourhoodContainer;
 
    coMiniGrid(const vector<int> &minigrid_cells,
               const vector<int> &elem_start_neigh,
               const vector<int> &elem_number_neigh,
               const vector<int> &elem_neighbours, // neighbour cells of a cell
               //as long
               const vector<MagmaUtils::Edge> &edge_neighbours);
    //as elem_neighbours
    virtual ~coMiniGrid();
    int CellSize() const;
    void GetEdgeNeighbours(int cell, coTestNeighbourhoodContainer &nc) const;
 
private:
    const vector<int> &minigrid_cells_; // contains the cells in the subset
    // the following arrays are the neighbour information
    // for the whole grid
    const vector<int> &elem_start_neigh_;
    const vector<int> &elem_number_neigh_;
    const vector<int> &elem_neighbours_; // neighbour cells of a cell
    //as long
    const vector<MagmaUtils::Edge> &edge_neighbours_;
    //as elem_neighbours_
};
}
#endif