---

/home/slang/XVision2/src/Pipes/PipeIterator.h

#ifndef _PIPEITERATOR_H_
#define _PIPEITERATOR_H_

#include <XVImageIterator.h>
#include <PipeImage.h>

// PipeIterator stuff

class EndOfImageException : public BrokenPipe { public:
  EndOfImageException() : BrokenPipe("EndOfImageException") {}
  EndOfImageException( char * err ) : BrokenPipe(err) {} };

template <class PIXEL_IN, class PIXEL_OUT>
class PixelPipeModule{

  typedef PIXEL_OUT (* FUNTYPE) (PIXEL_IN);

protected:

  FUNTYPE fun;

public:

  PixelPipeModule(FUNTYPE f) : fun(f) {}
  PIXEL_OUT operator () (PIXEL_IN p){ return fun(p); }
};

template <class IMTYPE>
class HiddenPixelPipeSrc{

  typedef IMTYPE IMAGE_IN;
  typedef typename IMTYPE::PIXELTYPE PIXEL;

public:

  const Pipe<IMAGE_IN > * srcPipe;

  HiddenPixelPipeSrc(const Pipe<IMAGE_IN > * p) : srcPipe(p) {}
  inline PIXEL map( PIXEL p1 ) const  { return p1; }
};

template <class PIN, class POUT, class PREV>
class HiddenPixelPipe{

  typedef POUT                                  PIXEL_OUT;
  typedef typename PREV::IMAGE_IN               IMAGE_IN;
  typedef typename IMAGE_IN::PIXELTYPE          PIXEL_IN;
  typedef PixelPipeModule<PIN, PIXEL_OUT > PIXMODULE; 
  
protected:
  
  const PREV      prev;
  const PIXMODULE fun;
  
public:

  const Pipe<IMAGE_IN > * srcPipe;

  HiddenPixelPipe(const PREV & p, const PIXMODULE & f) : 
    prev(p), fun(f), srcPipe(p.srcPipe) {} 

  inline PIXEL_OUT map(PIXEL_IN p ) const { 
    return (const_cast<PIXMODULE >(fun))(prev.map(p));
  }
};

template <class TO, class PIXEL_OUT>
class PixelPipeIterator{

  typedef TO RESULT_OUT;

public:
  
  RESULT_OUT * result;
  
  PixelPipeIterator() : result(0) {} 
  
  template <class IMAGE_IN, class TCLASS>
  void iterate(IMAGE_IN & im, TCLASS * c, typename TCLASS::PIXEL_OUT (TCLASS::*push) (typename TCLASS::PIXEL_IN) ) const {
    this->reset(im.Width(), im.Height());
    XVImageIterator<typename TCLASS::PIXEL_IN > iter(im);
    for(; !iter.end(); ++iter){
      this->pile(((*c).*push)(*iter));
    }
  };
  
  inline virtual void reset(int, int) = 0;
  
  inline virtual void pile(PIXEL_OUT) = 0;
};

template <class IMAGE>
class PixelImageOutIterator : public PixelPipeIterator<IMAGE, typename IMAGE::PIXELTYPE > {
  
  typedef typename IMAGE::PIXELTYPE PIXEL;

 protected:

  XVImageWIterator<PIXEL > * witer;

 public:

  inline virtual void reset(int w, int h){ 
    if(result) delete result;
    result = new IMAGE(w, h);
    //    if(witer) delete witer;
    witer = new XVImageWIterator<PIXEL >(*result);
  }

  inline virtual void pile(PIXEL p){
    (*(*witer)) = p;
    ++(*witer);
  }
};

template <class PIXEL>
class PixelRGBIterator : public PixelImageOutIterator<XVImageRGB<PIXEL > > {};

template <class PIXEL>
class PixelScalarIterator : public PixelImageOutIterator<XVImageScalar<PIXEL > > {};

template <class PI, class PP>
class HiddenPixelPipeHolder : public PipeModule<typename PI::RESULT_OUT > {
  
  typedef typename PP::IMAGE_IN   IMAGE_IN;
  typedef typename PI::RESULT_OUT OBJ_OUT;
  typedef typename PP::PIXEL_IN   PIXEL_IN;
  typedef typename PP::PIXEL_OUT  PIXEL_OUT;
  
protected:
  
  const Pipe<IMAGE_IN > * pred;

  const PP  * pixelPipe;
  const PI  * iterator;

  inline void check(void){
    PipeModule<OBJ_OUT >::check( pred );
  }

public:
  
  HiddenPixelPipeHolder(const PP * p, const PI * i) : 
    pixelPipe(p), iterator(i), pred(p->srcPipe) {}
  
  Pipe<OBJ_OUT > operator () (void) const {
    HiddenPixelPipeHolder<PI, PP> * hppHolder = new HiddenPixelPipeHolder<PI, PP>(*this);    
    return Pipe<OBJ_OUT >(hppHolder);
  }

  OBJ_OUT compute_local_fn(int fc) {

    check();
    (*iterator).iterate((const_cast<Pipe<IMAGE_IN > >(*pred))->get_value(fc), pixelPipe, & PP::map);
    return *(iterator->result);
  }
};

template <class IMAGE_IN, class PIXEL_IN, class PIXEL_OUT> 
inline HiddenPixelPipe<PIXEL_IN, PIXEL_OUT, 
                             HiddenPixelPipeSrc<IMAGE_IN > >
operator |= ( const PixelPipeModule<PIXEL_IN, PIXEL_OUT > & fun, 
           const Pipe<IMAGE_IN > & srcPipe ){ 

  return HiddenPixelPipe<PIXEL_IN, PIXEL_OUT, 
                         HiddenPixelPipeSrc<IMAGE_IN > >(HiddenPixelPipeSrc<IMAGE_IN >( & srcPipe ), fun);
};

template <class PIXEL_IN, class PIXEL_OUT, class PREV_PIXEL_IN, class PREV>
inline HiddenPixelPipe<PIXEL_IN, PIXEL_OUT, HiddenPixelPipe<PREV_PIXEL_IN, PIXEL_IN, PREV > >
operator |= ( const PixelPipeModule<PIXEL_IN, PIXEL_OUT > & fun, 
           const HiddenPixelPipe<PREV_PIXEL_IN, PIXEL_IN, PREV > & pp ){
  return HiddenPixelPipe<PIXEL_IN, PIXEL_OUT, HiddenPixelPipe<PREV_PIXEL_IN, PIXEL_IN, PREV > >(pp, fun);
};

template <class OBJ_OUT, class PIXEL_OUT, class PREV>
inline Pipe<OBJ_OUT >
operator |= ( const PixelPipeIterator<OBJ_OUT, PIXEL_OUT > & pi,
           const PREV & pp ){

  HiddenPixelPipeHolder<PixelPipeIterator<OBJ_OUT, PIXEL_OUT >, PREV > hppi(&pp, &pi);
  return hppi();
};

#endif

---