550 lines
14 KiB
C++
550 lines
14 KiB
C++
//
|
|
// Filename : ViewMapIterators.h
|
|
// Author(s) : Stephane Grabli
|
|
// Purpose : Iterators used to iterate over the various elements
|
|
// of the ViewMap
|
|
// Date of creation : 01/07/2003
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//
|
|
// Copyright (C) : Please refer to the COPYRIGHT file distributed
|
|
// with this source distribution.
|
|
//
|
|
// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef VIEWMAPITERATORS_H
|
|
# define VIEWMAPITERATORS_H
|
|
|
|
#include "ViewMap.h"
|
|
#include "../system/Iterator.h" //soc
|
|
|
|
|
|
/**********************************/
|
|
/* */
|
|
/* */
|
|
/* ViewMap */
|
|
/* */
|
|
/* */
|
|
/**********************************/
|
|
|
|
/**********************************/
|
|
/* */
|
|
/* */
|
|
/* ViewVertex */
|
|
/* */
|
|
/* */
|
|
/**********************************/
|
|
|
|
namespace ViewVertexInternal{
|
|
|
|
/*! Class representing an iterator over oriented ViewEdges
|
|
* around a ViewVertex. This iterator allows a CCW iteration
|
|
* (in the image plane).
|
|
* An instance of an orientedViewEdgeIterator can only
|
|
* be obtained from a ViewVertex by calling edgesBegin() or edgesEnd().
|
|
*/
|
|
class orientedViewEdgeIterator : public Iterator
|
|
{
|
|
public:
|
|
friend class ViewVertex;
|
|
friend class TVertex;
|
|
friend class NonTVertex;
|
|
friend class ViewEdge;
|
|
|
|
// FIXME
|
|
typedef ::TVertex::edge_pointers_container edge_pointers_container;
|
|
typedef ::NonTVertex::edges_container edges_container;
|
|
protected:
|
|
|
|
Nature::VertexNature _Nature; // the nature of the underlying vertex
|
|
// T vertex attributes
|
|
edge_pointers_container::iterator _tbegin;
|
|
edge_pointers_container::iterator _tend;
|
|
edge_pointers_container::iterator _tvertex_iter;
|
|
|
|
// Non TVertex attributes
|
|
edges_container::iterator _begin;
|
|
edges_container::iterator _end;
|
|
edges_container::iterator _nontvertex_iter;
|
|
|
|
public:
|
|
/*! Default constructor */
|
|
inline orientedViewEdgeIterator() {}
|
|
inline orientedViewEdgeIterator(Nature::VertexNature iNature)
|
|
{_Nature = iNature;}
|
|
/*! Copy constructor */
|
|
orientedViewEdgeIterator(const orientedViewEdgeIterator& iBrother)
|
|
{
|
|
_Nature = iBrother._Nature;
|
|
if(_Nature & Nature::T_VERTEX)
|
|
{
|
|
_tbegin = iBrother._tbegin;
|
|
_tend = iBrother._tend;
|
|
_tvertex_iter = iBrother._tvertex_iter;
|
|
}
|
|
else
|
|
{
|
|
_begin = iBrother._begin;
|
|
_end = iBrother._end;
|
|
_nontvertex_iter = iBrother._nontvertex_iter;
|
|
}
|
|
}
|
|
virtual ~orientedViewEdgeIterator() {}
|
|
|
|
public:
|
|
inline orientedViewEdgeIterator(edge_pointers_container::iterator begin,
|
|
edge_pointers_container::iterator end,
|
|
edge_pointers_container::iterator iter)
|
|
{
|
|
_Nature = Nature::T_VERTEX;
|
|
_tbegin = begin;
|
|
_tend = end;
|
|
_tvertex_iter = iter;
|
|
}
|
|
inline orientedViewEdgeIterator(edges_container::iterator begin,
|
|
edges_container::iterator end,
|
|
edges_container::iterator iter)
|
|
{
|
|
_Nature = Nature::NON_T_VERTEX;
|
|
_begin = begin;
|
|
_end = end;
|
|
_nontvertex_iter = iter;
|
|
}
|
|
|
|
public:
|
|
|
|
|
|
/*! Tells whether the ViewEdge pointed
|
|
* by this iterator is the first one of the
|
|
* iteration list or not.
|
|
*/
|
|
virtual bool isBegin() const
|
|
{
|
|
if(_Nature & Nature::T_VERTEX)
|
|
return (_tvertex_iter == _tbegin);
|
|
else
|
|
return (_nontvertex_iter == _begin);
|
|
}
|
|
/*! Tells whether the ViewEdge pointed
|
|
* by this iterator is after the last one of the
|
|
* iteration list or not.
|
|
*/
|
|
virtual bool isEnd() const
|
|
{
|
|
if(_Nature & Nature::T_VERTEX)
|
|
return (_tvertex_iter == _tend);
|
|
else
|
|
return (_nontvertex_iter == _end);
|
|
}
|
|
|
|
// operators
|
|
/*! Increments.In the scripting language, call
|
|
* "increment()".
|
|
*/
|
|
virtual orientedViewEdgeIterator& operator++() // operator corresponding to ++i
|
|
{
|
|
increment();
|
|
return *this;
|
|
}
|
|
/*! Increments.In the scripting language, call
|
|
* "increment()".
|
|
*/
|
|
virtual orientedViewEdgeIterator operator++(int) // opérateur correspondant à i++
|
|
{ // c.a.d qui renvoie la valeur *puis* incrémente.
|
|
orientedViewEdgeIterator tmp = *this; // C'est pour cela qu'on stocke la valeur
|
|
increment(); // dans un temporaire.
|
|
return tmp;
|
|
}
|
|
|
|
// comparibility
|
|
/*! operator != */
|
|
virtual bool operator!=(const orientedViewEdgeIterator& b) const
|
|
{
|
|
if(_Nature & Nature::T_VERTEX)
|
|
return (_tvertex_iter != b._tvertex_iter);
|
|
else
|
|
return (_nontvertex_iter != b._nontvertex_iter);
|
|
}
|
|
|
|
/*! operator == */
|
|
virtual bool operator==(const orientedViewEdgeIterator& b) const
|
|
{return !(*this != b);}
|
|
|
|
// dereferencing
|
|
/*! Returns a reference to the pointed orientedViewEdge.
|
|
* In the scripting language, you must call
|
|
* "getObject()"instead.
|
|
*/
|
|
virtual ::ViewVertex::directedViewEdge& operator*() const
|
|
{
|
|
if(_Nature & Nature::T_VERTEX)
|
|
//return _tvertex_iter;
|
|
return **_tvertex_iter;
|
|
else
|
|
return (*_nontvertex_iter);
|
|
}
|
|
/*! Returns a pointer to the pointed orientedViewEdge.
|
|
* Can't be called in the scripting language.
|
|
*/
|
|
virtual ::ViewVertex::directedViewEdge* operator->() const { return &(operator*());}
|
|
|
|
public:
|
|
/*! increments.*/
|
|
virtual inline int increment()
|
|
{
|
|
if(_Nature & Nature::T_VERTEX)
|
|
{
|
|
::ViewVertex::directedViewEdge tmp = (**_tvertex_iter);
|
|
++_tvertex_iter;
|
|
if(_tvertex_iter != _tend){
|
|
// FIXME : pquoi deja ?
|
|
::ViewVertex::directedViewEdge tmp2 = (**_tvertex_iter);
|
|
if(tmp2.first == tmp.first)
|
|
++_tvertex_iter;
|
|
}
|
|
}
|
|
else
|
|
++_nontvertex_iter;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
}
|
|
/**********************************/
|
|
/* */
|
|
/* */
|
|
/* ViewEdge */
|
|
/* */
|
|
/* */
|
|
/**********************************/
|
|
|
|
namespace ViewEdgeInternal {
|
|
//
|
|
// SVertexIterator
|
|
//
|
|
/////////////////////////////////////////////////
|
|
|
|
class SVertexIterator : public Interface0DIteratorNested
|
|
{
|
|
public:
|
|
|
|
SVertexIterator() {
|
|
_vertex = NULL;
|
|
_begin = NULL;
|
|
_previous_edge = NULL;
|
|
_next_edge = NULL;
|
|
_t = 0;
|
|
}
|
|
|
|
SVertexIterator(const SVertexIterator& vi) {
|
|
_vertex = vi._vertex;
|
|
_begin = vi._begin;
|
|
_previous_edge = vi._previous_edge;
|
|
_next_edge = vi._next_edge;
|
|
_t = vi._t;
|
|
}
|
|
|
|
SVertexIterator(SVertex* v, SVertex* begin, FEdge* prev, FEdge* next, float t) {
|
|
_vertex = v;
|
|
_begin = begin;
|
|
_previous_edge = prev;
|
|
_next_edge = next;
|
|
_t = t;
|
|
}
|
|
|
|
SVertexIterator& operator=(const SVertexIterator& vi) {
|
|
_vertex = vi._vertex;
|
|
_begin = vi._begin;
|
|
_previous_edge = vi._previous_edge;
|
|
_next_edge = vi._next_edge;
|
|
_t = vi._t;
|
|
return *this;
|
|
}
|
|
|
|
virtual ~SVertexIterator() {}
|
|
|
|
virtual string getExactTypeName() const {
|
|
return "SVertexIterator";
|
|
}
|
|
|
|
virtual SVertex& operator*() {
|
|
return *_vertex;
|
|
}
|
|
|
|
virtual SVertex* operator->() {
|
|
return &(operator*());
|
|
}
|
|
|
|
virtual SVertexIterator& operator++() {
|
|
increment();
|
|
return *this;
|
|
}
|
|
|
|
virtual SVertexIterator operator++(int) {
|
|
SVertexIterator ret(*this);
|
|
increment();
|
|
return ret;
|
|
}
|
|
|
|
virtual SVertexIterator& operator--() {
|
|
decrement();
|
|
return *this;
|
|
}
|
|
|
|
virtual SVertexIterator operator--(int) {
|
|
SVertexIterator ret(*this);
|
|
decrement();
|
|
return ret;
|
|
}
|
|
|
|
virtual int increment(){
|
|
if (!_next_edge) {
|
|
_vertex = 0;
|
|
return 0;
|
|
}
|
|
_t += (float)_next_edge->getLength2D();
|
|
_vertex = _next_edge->vertexB();
|
|
_previous_edge = _next_edge;
|
|
_next_edge = _next_edge->nextEdge();
|
|
return 0;
|
|
|
|
}
|
|
virtual int decrement(){
|
|
if (!_previous_edge) {
|
|
_vertex = 0;
|
|
return 0;
|
|
}
|
|
if((!_next_edge) && (!_vertex)){
|
|
_vertex = _previous_edge->vertexB();
|
|
return 0;
|
|
}
|
|
_t -= (float)_previous_edge->getLength2D();
|
|
_vertex = _previous_edge->vertexA();
|
|
_next_edge = _previous_edge;
|
|
_previous_edge = _previous_edge->previousEdge();
|
|
return 0;
|
|
}
|
|
|
|
virtual bool isBegin() const {
|
|
return _vertex == _begin;
|
|
}
|
|
|
|
virtual bool isEnd() const {
|
|
return (!_vertex) || (_vertex == _begin && _previous_edge);
|
|
}
|
|
|
|
virtual float t() const {
|
|
return _t;
|
|
}
|
|
virtual float u() const {
|
|
return _t/(float)_next_edge->viewedge()->getLength2D();
|
|
}
|
|
|
|
virtual bool operator==(const Interface0DIteratorNested& it) const {
|
|
const SVertexIterator* it_exact = dynamic_cast<const SVertexIterator*>(&it);
|
|
if (!it_exact)
|
|
return false;
|
|
return (_vertex == it_exact->_vertex);
|
|
}
|
|
|
|
virtual SVertexIterator* copy() const {
|
|
return new SVertexIterator(*this);
|
|
}
|
|
|
|
private:
|
|
|
|
SVertex* _vertex;
|
|
SVertex* _begin;
|
|
FEdge* _previous_edge;
|
|
FEdge* _next_edge;
|
|
float _t; // curvilinear abscissa
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// ViewEdgeIterator (base class)
|
|
//
|
|
///////////////////////////////////////////////////////////
|
|
|
|
/*! Base class for iterators over ViewEdges of the ViewMap Graph.
|
|
* Basically the "increment()" operator of this class should
|
|
* be able to take the decision of "where" (on which ViewEdge) to go
|
|
* when pointing on a given ViewEdge.
|
|
* ::Caution::: the dereferencing operator returns a *pointer* to
|
|
* the pointed ViewEdge.
|
|
*/
|
|
class ViewEdgeIterator : public Iterator
|
|
{
|
|
public:
|
|
|
|
/*! Builds a ViewEdgeIterator from a starting ViewEdge and its orientation.
|
|
* \param begin
|
|
* The ViewEdge from where to start the iteration.
|
|
* \param orientation
|
|
* If true, we'll look for the next ViewEdge among the
|
|
* ViewEdges that surround the ending ViewVertex of begin.
|
|
* If false, we'll search over the ViewEdges surrounding
|
|
* the ending ViewVertex of begin.
|
|
*/
|
|
ViewEdgeIterator(ViewEdge* begin = 0, bool orientation = true) {
|
|
_orientation = orientation;
|
|
_edge = begin;
|
|
_begin = begin;
|
|
}
|
|
|
|
/*! Copy constructor */
|
|
ViewEdgeIterator(const ViewEdgeIterator& it) {
|
|
_orientation = it._orientation;
|
|
_edge = it._edge;
|
|
_begin = it._begin;
|
|
}
|
|
|
|
virtual ~ViewEdgeIterator() {}
|
|
|
|
/*! Returns the string "ViewEdgeIterator" */
|
|
virtual string getExactTypeName() const {
|
|
return "ViewEdgeIterator";
|
|
}
|
|
|
|
/*! Returns the current pointed ViewEdge. */
|
|
ViewEdge* getCurrentEdge() {
|
|
return _edge;
|
|
}
|
|
|
|
/*! Sets the current pointed ViewEdge. */
|
|
void setCurrentEdge(ViewEdge* edge) {
|
|
_edge = edge;
|
|
}
|
|
|
|
/*! Returns the first ViewEdge used for the iteration. */
|
|
ViewEdge* getBegin() {
|
|
return _begin;
|
|
}
|
|
|
|
/*! Sets the first ViewEdge used for the iteration. */
|
|
void setBegin(ViewEdge* begin) {
|
|
_begin = begin;
|
|
}
|
|
|
|
/*! Gets the orientation of the pointed ViewEdge in the iteration. */
|
|
bool getOrientation() const {
|
|
return _orientation;
|
|
}
|
|
|
|
/*! Sets the orientation of the pointed ViewEdge in the iteration. */
|
|
void setOrientation(bool orientation) {
|
|
_orientation = orientation;
|
|
}
|
|
|
|
/*! Changes the current orientation. */
|
|
void changeOrientation() {
|
|
_orientation = !_orientation;
|
|
}
|
|
|
|
/*! Returns a *pointer* to the pointed ViewEdge. */
|
|
virtual ViewEdge* operator*() {
|
|
return _edge;
|
|
}
|
|
|
|
virtual ViewEdge* operator->() {
|
|
return operator*();
|
|
}
|
|
|
|
/*! Increments. In the scripting language, call
|
|
* "increment()".
|
|
*/
|
|
virtual ViewEdgeIterator& operator++() {
|
|
increment();
|
|
return *this;
|
|
}
|
|
|
|
/*! Increments. In the scripting language, call
|
|
* "increment()".
|
|
*/
|
|
virtual ViewEdgeIterator operator++(int) {
|
|
ViewEdgeIterator tmp(*this);
|
|
increment();
|
|
return tmp;
|
|
}
|
|
|
|
/*! increments. */
|
|
virtual int increment() {
|
|
cerr << "Warning: method increment() not implemented" << endl;
|
|
return 0;
|
|
}
|
|
|
|
/*! Decrements. In the scripting language, call
|
|
* "decrement()".
|
|
*/
|
|
virtual ViewEdgeIterator& operator--() {
|
|
decrement();
|
|
return *this;
|
|
}
|
|
|
|
/*! Decrements. In the scripting language, call
|
|
* "decrement()".
|
|
*/
|
|
virtual ViewEdgeIterator operator--(int) {
|
|
ViewEdgeIterator tmp(*this);
|
|
decrement();
|
|
return tmp;
|
|
}
|
|
|
|
/*! decrements. */
|
|
virtual int decrement(){
|
|
cerr << "Warning: method decrement() not implemented" << endl;
|
|
return 0;
|
|
}
|
|
|
|
/*! Returns true if the pointed ViewEdge is the
|
|
* first one used for the iteration.
|
|
*/
|
|
virtual bool isBegin() const {
|
|
return _edge == _begin;
|
|
}
|
|
|
|
/*! Returns true if the pointed ViewEdge* equals 0.
|
|
*/
|
|
virtual bool isEnd() const {
|
|
return !_edge;
|
|
}
|
|
|
|
/*! operator == */
|
|
virtual bool operator==(ViewEdgeIterator& it) const {
|
|
return _edge == it._edge;
|
|
}
|
|
|
|
/*! operator != */
|
|
virtual bool operator!=(ViewEdgeIterator& it) const {
|
|
return !(*this == it);
|
|
}
|
|
|
|
protected:
|
|
|
|
bool _orientation;
|
|
ViewEdge* _edge;
|
|
ViewEdge* _begin;
|
|
};
|
|
|
|
} // end of namespace ViewEdgeInternal
|
|
|
|
#endif // VIEWMAPITERATORS_H
|
|
|