blender-archive/source/blender/freestyle/intern/stroke/ChainingIterators.cpp

//
//  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.
//
///////////////////////////////////////////////////////////////////////////////
#include "ChainingIterators.h"
#include "../system/TimeStamp.h"

ViewEdge* AdjacencyIterator::operator*() {
  return (*_internalIterator).first;
}
bool AdjacencyIterator::isIncoming() const{
  return (*_internalIterator).second;
}

int AdjacencyIterator::increment(){
  ++_internalIterator;
  while((!_internalIterator.isEnd()) && (!isValid((*_internalIterator).first)))
    ++_internalIterator;
  return 0;
}

bool AdjacencyIterator::isValid(ViewEdge* edge){
  if(_restrictToSelection)
    if(edge->getTimeStamp() != TimeStamp::instance()->getTimeStamp())
      return false;
  if(_restrictToUnvisited)
    if(edge->getChainingTimeStamp() > TimeStamp::instance()->getTimeStamp())
      return false;
    return true;
}

int ChainingIterator::increment() {
  _increment = true;
  ViewVertex * vertex = getVertex();
  if(!vertex){
    _edge = 0;
    return 0;
  }
  AdjacencyIterator it = AdjacencyIterator(vertex, _restrictToSelection, _restrictToUnvisited);
  if(it.isEnd()) {
    _edge = 0;
	return 0;
  }
  if (traverse(it) < 0)
	return -1;
  _edge = result;
  if(_edge == 0)
    return 0;
  if(_edge->A() == vertex)
    _orientation = true;
  else
    _orientation = false;
  return 0;
}

int ChainingIterator::decrement() {
  _increment = false;
  ViewVertex * vertex = getVertex();
  if(!vertex){
    _edge = 0;
    return 0;
  }
  AdjacencyIterator it = AdjacencyIterator(vertex, _restrictToSelection, _restrictToUnvisited);
  if(it.isEnd()) {
    _edge = 0;
	return 0;
  }
  if (traverse(it) < 0)
	return -1;
  _edge = result;
  if(_edge == 0)
    return 0;
  if(_edge->B() == vertex)
    _orientation = true;
  else
    _orientation = false;
  return 0;
}

//
// ChainSilhouetteIterators
//
///////////////////////////////////////////////////////////

int ChainSilhouetteIterator::traverse(const AdjacencyIterator& ait){
  AdjacencyIterator it(ait);
  ViewVertex* nextVertex = getVertex();
  // we can't get a NULL nextVertex here, it was intercepted
  // before
  if(nextVertex->getNature() & Nature::T_VERTEX){
    TVertex * tvertex = (TVertex*)nextVertex;
    ViewEdge *mate = (tvertex)->mate(getCurrentEdge());
    while(!it.isEnd()){
      ViewEdge *ve = *it;
	  if(ve == mate) {
	    result = ve;
        return 0;
	  }
      ++it;
    }
    result = 0;
	return 0;
  }
  if(nextVertex->getNature() & Nature::NON_T_VERTEX){
    //soc NonTVertex * nontvertex = (NonTVertex*)nextVertex;
    ViewEdge * newEdge(0);
    // we'll try to chain the edges by keeping the same nature...
    // the preseance order is : SILHOUETTE, BORDER, CREASE, SUGGESTIVE, VALLEY, RIDGE
    Nature::EdgeNature natures[6] = {Nature::SILHOUETTE, Nature::BORDER, Nature::CREASE, Nature::SUGGESTIVE_CONTOUR, Nature::VALLEY, Nature::RIDGE};
    for(unsigned i=0; i<6; ++i){
      if(getCurrentEdge()->getNature() & natures[i]){
        int n = 0;
        while(!it.isEnd()){
          ViewEdge *ve = *it;
          if(ve->getNature() & natures[i]){
            ++n;
            newEdge = ve;
          } 
          ++it;
        } 
        if(n == 1){
          result = newEdge;
        }else{
          result = 0;
        }   
		return 0;
	  } 
    }
  }
  result = 0;
  return 0;
}

int ChainPredicateIterator::traverse(const AdjacencyIterator& ait){
  AdjacencyIterator it(ait);
  // Iterates over next edges to see if one of them 
  // respects the predicate:
  while(!it.isEnd()) {
    ViewEdge *ve = *it;
	if (_unary_predicate->operator()(*ve) < 0)
	  return -1;
	if (_unary_predicate->result) {
	  if (_binary_predicate->operator()(*(getCurrentEdge()), *(ve)) < 0)
		return -1;
	  if (_binary_predicate->result) {
        result = ve;
	    return 0;
	  }
	}
    ++it;
  }
  result = 0;
  return 0;
}