ChainingIterators.h

Go to the documentation of this file.

/*
 * 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
 * of the License, 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#pragma once
 
#include <iostream>
 
#include "Predicates1D.h"
 
#include "../system/Iterator.h"
 
#include "../view_map/ViewMap.h"
#include "../view_map/ViewMapAdvancedIterators.h"
#include "../view_map/ViewMapIterators.h"
 
// using namespace ViewEdgeInternal;
 
namespace Freestyle {
 
//
// Adjacency iterator used in the chaining process
//
class AdjacencyIterator : public Iterator {
 protected:
  ViewVertexInternal::orientedViewEdgeIterator _internalIterator;
  bool _restrictToSelection;
  bool _restrictToUnvisited;
 
 public:
  AdjacencyIterator()
  {
    _restrictToSelection = true;
    _restrictToUnvisited = true;
  }
 
  AdjacencyIterator(ViewVertex *iVertex,
                    bool iRestrictToSelection = true,
                    bool iRestrictToUnvisited = true)
  {
    _restrictToSelection = iRestrictToSelection;
    _restrictToUnvisited = iRestrictToUnvisited;
    _internalIterator = iVertex->edgesBegin();
    while ((!_internalIterator.isEnd()) && (!isValid((*_internalIterator).first))) {
      ++_internalIterator;
    }
  }
 
  AdjacencyIterator(const AdjacencyIterator &iBrother)
  {
    _internalIterator = iBrother._internalIterator;
    _restrictToSelection = iBrother._restrictToSelection;
    _restrictToUnvisited = iBrother._restrictToUnvisited;
  }
 
  AdjacencyIterator &operator=(const AdjacencyIterator &iBrother)
  {
    _internalIterator = iBrother._internalIterator;
    _restrictToSelection = iBrother._restrictToSelection;
    _restrictToUnvisited = iBrother._restrictToUnvisited;
    return *this;
  }
 
  virtual ~AdjacencyIterator()
  {
  }
 
  virtual string getExactTypeName() const
  {
    return "AdjacencyIterator";
  }
 
  virtual inline bool isEnd() const
  {
    return _internalIterator.isEnd();
  }
 
  virtual inline bool isBegin() const
  {
    return _internalIterator.isBegin();
  }
 
  bool isIncoming() const;
 
  virtual ViewEdge *operator*();
 
  virtual ViewEdge *operator->()
  {
    return operator*();
  }
 
  virtual AdjacencyIterator &operator++()
  {
    increment();
    return *this;
  }
 
  virtual AdjacencyIterator operator++(int)
  {
    AdjacencyIterator tmp(*this);
    increment();
    return tmp;
  }
 
  virtual int increment();
 
  virtual int decrement()
  {
    cerr << "Warning: method decrement() not implemented" << endl;
    return 0;
  }
 
 protected:
  bool isValid(ViewEdge *edge);
};
 
//
// Base class for Chaining Iterators
//
 
class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
 protected:
  bool _restrictToSelection;
  bool _restrictToUnvisited;
  bool _increment;  // true if we're currently incrementing, false when decrementing
 
 public:
  ViewEdge *result;
  void *py_c_it;
 
  ChainingIterator(bool iRestrictToSelection = true,
                   bool iRestrictToUnvisited = true,
                   ViewEdge *begin = NULL,
                   bool orientation = true)
      : ViewEdgeIterator(begin, orientation)
  {
    _restrictToSelection = iRestrictToSelection;
    _restrictToUnvisited = iRestrictToUnvisited;
    _increment = true;
    py_c_it = NULL;
  }
 
  ChainingIterator(const ChainingIterator &brother) : ViewEdgeIterator(brother)
  {
    _restrictToSelection = brother._restrictToSelection;
    _restrictToUnvisited = brother._restrictToUnvisited;
    _increment = brother._increment;
    py_c_it = brother.py_c_it;
  }
 
  virtual string getExactTypeName() const
  {
    return "ChainingIterator";
  }
 
  virtual int init();
 
  virtual int traverse(const AdjacencyIterator &it);
 
  /* accessors */
  // inline bool getOrientation() const {}
 
  inline ViewVertex *getVertex()
  {
    if (_increment) {
      if (_orientation) {
        return _edge->B();
      }
      else {
        return _edge->A();
      }
    }
    else {
      if (_orientation) {
        return _edge->A();
      }
      else {
        return _edge->B();
      }
    }
  }
 
  inline bool isIncrementing() const
  {
    return _increment;
  }
 
  /* increments.*/
  virtual int increment();
  virtual int decrement();
};
 
//
// Chaining iterators definitions
//
 
class ChainSilhouetteIterator : public ChainingIterator {
 public:
  ChainSilhouetteIterator(bool iRestrictToSelection = true,
                          ViewEdge *begin = NULL,
                          bool orientation = true)
      : ChainingIterator(iRestrictToSelection, true, begin, orientation)
  {
  }
 
  ChainSilhouetteIterator(const ChainSilhouetteIterator &brother) : ChainingIterator(brother)
  {
  }
 
  virtual string getExactTypeName() const
  {
    return "ChainSilhouetteIterator";
  }
 
  virtual int traverse(const AdjacencyIterator &it);
 
  virtual int init()
  {
    return 0;
  }
};
 
//
// ChainPredicateIterator
//
 
class ChainPredicateIterator : public ChainingIterator {
 protected:
  BinaryPredicate1D
      *_binary_predicate;              // the caller is responsible for the deletion of this object
  UnaryPredicate1D *_unary_predicate;  // the caller is responsible for the deletion of this object
 
 public:
  ChainPredicateIterator(bool iRestrictToSelection = true,
                         bool iRestrictToUnvisited = true,
                         ViewEdge *begin = NULL,
                         bool orientation = true)
      : ChainingIterator(iRestrictToSelection, iRestrictToUnvisited, begin, orientation)
  {
    _binary_predicate = 0;
    _unary_predicate = 0;
  }
 
  ChainPredicateIterator(UnaryPredicate1D &upred,
                         BinaryPredicate1D &bpred,
                         bool iRestrictToSelection = true,
                         bool iRestrictToUnvisited = true,
                         ViewEdge *begin = NULL,
                         bool orientation = true)
      : ChainingIterator(iRestrictToSelection, iRestrictToUnvisited, begin, orientation)
  {
    _unary_predicate = &upred;
    _binary_predicate = &bpred;
  }
 
  ChainPredicateIterator(const ChainPredicateIterator &brother) : ChainingIterator(brother)
  {
    _unary_predicate = brother._unary_predicate;
    _binary_predicate = brother._binary_predicate;
  }
 
  virtual ~ChainPredicateIterator()
  {
    _unary_predicate = 0;
    _binary_predicate = 0;
  }
 
  virtual string getExactTypeName() const
  {
    return "ChainPredicateIterator";
  }
 
  virtual int traverse(const AdjacencyIterator &it);
 
  virtual int init()
  {
    return 0;
  }
};
 
} /* namespace Freestyle */