8 #ifndef VIGRA_APPLYWINDOWFUCTION_HXX 
    9 #define VIGRA_APPLYWINDOWFUCTION_HXX 
   11 #include "basicimage.hxx" 
   12 #include "copyimage.hxx" 
   13 #include "basicgeometry.hxx" 
   14 #include "initimage.hxx" 
   15 #include "bordertreatment.hxx" 
  161 template <
class SrcIterator, 
class SrcAccessor, 
 
  162           class DestIterator, 
class DestAccessor, 
 
  163           class ProcessingFunctor>
 
  165                          DestIterator d_ul, DestAccessor d_acc, 
 
  166                          ProcessingFunctor func, 
 
  167                          BorderTreatmentMode border = BORDER_TREATMENT_REPEAT)
 
  169     vigra_precondition((border == BORDER_TREATMENT_AVOID   ||
 
  171                         border == BORDER_TREATMENT_REPEAT  ||
 
  172                         border == BORDER_TREATMENT_REFLECT ||
 
  173                         border == BORDER_TREATMENT_WRAP    ||
 
  174                         border == BORDER_TREATMENT_ZEROPAD   
 
  176                        "vigra::applyWindowFunction():\n" 
  177                        "  Border treatment must be one of follow treatments:\n" 
  178                        "  - BORDER_TREATMENT_AVOID\n" 
  180                        "  - BORDER_TREATMENT_REPEAT\n" 
  181                        "  - BORDER_TREATMENT_REFLECT\n" 
  182                        "  - BORDER_TREATMENT_WRAP\n" 
  183                        "  - BORDER_TREATMENT_ZEROPAD\n" 
  186     typename SrcIterator::difference_type img_shape = s_lr - s_ul;
 
  187     Diff2D win_shape = func.windowShape();
 
  189     vigra_precondition( win_shape.x % 2 == 1 , 
"vigra::applyWindowFunction(): Filter window width has to be of odd size!");
 
  190     vigra_precondition( win_shape.y % 2 == 1 , 
"vigra::applyWindowFunction(): Filter window height has to be of odd size!");
 
  192     vigra_precondition( win_shape.x <= img_shape.x && win_shape.y <= img_shape.y , 
"vigra::applyWindowFunction(): Filter window is larger than image!");
 
  201     SrcIterator     ys  = s_ul, 
 
  204     DestIterator    yd  = d_ul, 
 
  207     SrcIterator     end = s_ul + img_shape - win_shape/2;
 
  209     ys.y += win_shape.y/2;
 
  210     yd.y += win_shape.y/2;
 
  214     for( ; ys.y != end.y; ys.y++, yd.y++, y++)
 
  217         xs.x += win_shape.x/2;
 
  220         xd.x += win_shape.x/2;
 
  222         for( ; xs.x != end.x; xs.x++, xd.x++)
 
  224             func(xs, s_acc, xd, d_acc);
 
  240     if(border == BORDER_TREATMENT_AVOID)
 
  246     BasicImage<typename SrcIterator::PixelType> temp(img_shape.x, win_shape.y + win_shape.y/2);
 
  247     typedef typename BasicImage<typename SrcIterator::PixelType>::Iterator TempIterator;
 
  249     TempIterator    t_ul  = temp.upperLeft(), 
 
  250                     t_lr  = temp.lowerRight();
 
  252     DestAccessor    t_acc = temp.accessor();
 
  254     TempIterator    yt = t_ul,
 
  265     if(border == BORDER_TREATMENT_REPEAT)
 
  268         Diff2D lineDiff(img_shape.x,1);
 
  270         for( ; yt.y != t_lr.y - win_shape.y; ++yt.y)
 
  272             copyImage(ys, ys+lineDiff, s_acc, yt, t_acc);
 
  274         copyImage(ys, ys+Diff2D(img_shape.x,win_shape.y), s_acc, yt, t_acc);
 
  277     else if(border == BORDER_TREATMENT_REFLECT)
 
  279         reflectImage(s_ul, s_ul+Diff2D(img_shape.x,win_shape.y/2), s_acc, t_ul, t_acc, horizontal);
 
  280         copyImage(s_ul, s_ul+Diff2D(img_shape.x,win_shape.y), s_acc, t_ul+Diff2D(0,win_shape.y/2), t_acc);
 
  283     else if(border == BORDER_TREATMENT_WRAP)
 
  285         copyImage(s_ul+Diff2D(0, img_shape.y-win_shape.y/2), s_lr, s_acc, t_ul, t_acc);
 
  286         copyImage(s_ul, s_ul+Diff2D(img_shape.x,win_shape.y), s_acc, t_ul+Diff2D(0,win_shape.y/2), t_acc);
 
  289     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  292         copyImage(s_ul, s_ul+Diff2D(img_shape.x,win_shape.y), s_acc, t_ul+Diff2D(0,win_shape.y/2), t_acc);
 
  297     yt.y += win_shape.y/2;
 
  300     for( ; yt.y != t_lr.y-win_shape.y/2; ++yd.y,  ++yt.y)
 
  303         xt.x += win_shape.x/2;
 
  306         xd.x += win_shape.x/2;
 
  308         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  310             func(xt, t_acc, xd, d_acc);     
 
  321     if(border == BORDER_TREATMENT_REPEAT)
 
  323         ys = s_ul + Diff2D(0, img_shape.y-1);
 
  324         yt = t_ul + Diff2D(0, win_shape.x);
 
  326         Diff2D lineDiff(img_shape.x,1);
 
  328         for( ; yt.y != t_lr.y ; ++yt.y)
 
  330             copyImage(ys, ys+lineDiff, s_acc, yt, t_acc);
 
  332         ys = s_ul + Diff2D(0, img_shape.y-win_shape.y);
 
  334         copyImage(ys, ys+Diff2D(img_shape.x,win_shape.y), s_acc, yt, t_acc);
 
  337     else if(border == BORDER_TREATMENT_REFLECT)
 
  339         reflectImage(s_ul+Diff2D(0, img_shape.y-win_shape.y/2), s_lr, s_acc, t_ul+Diff2D(0, win_shape.y), t_acc, horizontal);
 
  340         copyImage(s_ul+Diff2D(0, img_shape.y-win_shape.y), s_lr, s_acc, t_ul, t_acc);
 
  343     else if(border == BORDER_TREATMENT_WRAP)
 
  345         copyImage(s_ul, s_ul + Diff2D(img_shape.x, win_shape.y/2), s_acc, t_ul+Diff2D(0, win_shape.y), t_acc);
 
  346         copyImage(s_ul+Diff2D(0, img_shape.y-win_shape.y), s_lr, s_acc, t_ul, t_acc);
 
  349     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  352         copyImage(s_ul+Diff2D(0, img_shape.y-win_shape.y), s_lr, s_acc, t_ul, t_acc);
 
  358     yt.y += win_shape.y/2;
 
  360     yd.y += img_shape.y-win_shape.y/2-1;
 
  362     for( ; yt.y != t_lr.y - win_shape.y/2 ; ++yd.y, ++yt.y)
 
  365         xt.x += win_shape.x/2;
 
  368         xd.x += win_shape.x/2;
 
  370         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  372             func(xt, t_acc, xd, d_acc);                 
 
  378     temp.resize(win_shape.x+win_shape.x/2,img_shape.y);
 
  379     t_ul = temp.upperLeft(); t_lr = temp.lowerRight();
 
  380     t_acc = temp.accessor();
 
  391     if(border == BORDER_TREATMENT_REPEAT)
 
  397         Diff2D colDiff(1,img_shape.y);
 
  399         for( ; xt.x != t_lr.x - win_shape.x; ++xt.x)
 
  401             copyImage(xs, xs+colDiff, s_acc, xt, t_acc);
 
  403         copyImage(xs, xs+Diff2D(win_shape.x, img_shape.y), s_acc, xt, t_acc);
 
  406     else if(border == BORDER_TREATMENT_REFLECT)
 
  408         reflectImage(s_ul, s_ul+Diff2D(win_shape.x/2, img_shape.y), s_acc, t_ul, t_acc, vertical);
 
  409         copyImage(s_ul, s_ul+Diff2D(win_shape.x, img_shape.y), s_acc, t_ul + Diff2D(win_shape.x/2, 0), t_acc);
 
  412     else if(border == BORDER_TREATMENT_WRAP)
 
  414         copyImage(s_ul+Diff2D(img_shape.x-win_shape.x/2, 0), s_lr, s_acc, t_ul, t_acc);
 
  415         copyImage(s_ul, s_ul+Diff2D(win_shape.x, img_shape.y), s_acc, t_ul + Diff2D(win_shape.x/2, 0), t_acc);
 
  418     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  421         copyImage(s_ul, s_ul+Diff2D(win_shape.x, img_shape.y), s_acc, t_ul + Diff2D(win_shape.x/2, 0), t_acc);
 
  427     yt.y += win_shape.y/2;
 
  429     yd.y += win_shape.y/2;
 
  431     for( ; yt.y != t_lr.y-win_shape.y/2; ++yd.y,  ++yt.y)
 
  434         xt.x += win_shape.x/2;
 
  438         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  440             func(xt, t_acc, xd, d_acc);                 
 
  452     if(border == BORDER_TREATMENT_REPEAT)
 
  454         xs = s_ul + Diff2D(img_shape.x-1,0);
 
  455         xt = t_ul + Diff2D(win_shape.x,0);
 
  458         Diff2D colDiff(1,img_shape.y);
 
  460         for( ; xt.x != t_lr.x ; ++xt.x)
 
  462             copyImage(xs, xs+colDiff, s_acc, xt, t_acc);
 
  464         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);
 
  466         copyImage(ys, ys+Diff2D(win_shape.x,img_shape.y), s_acc, yt, t_acc);
 
  470     else if(border == BORDER_TREATMENT_REFLECT)
 
  472         reflectImage(s_ul+Diff2D(img_shape.x-win_shape.x/2,0), s_lr, s_acc, t_ul+Diff2D(win_shape.x,0), t_acc, vertical);
 
  473         copyImage(s_ul+Diff2D(img_shape.x-win_shape.x,0), s_lr, s_acc, t_ul, t_acc);
 
  477     else if(border == BORDER_TREATMENT_WRAP)
 
  479         copyImage(s_ul, s_ul+Diff2D(win_shape.x/2,img_shape.y), s_acc, t_ul+Diff2D(win_shape.x,0), t_acc);
 
  480         copyImage(s_ul+Diff2D(img_shape.x-win_shape.x,0), s_lr, s_acc, t_ul, t_acc);
 
  484     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  487         copyImage(s_ul+Diff2D(img_shape.x-win_shape.x,0), s_lr, s_acc, t_ul, t_acc);
 
  493     yt.y += win_shape.x/2;
 
  495     yd.x += img_shape.x-win_shape.x/2-1;
 
  496     yd.y += win_shape.y/2;
 
  498     for( ; yt.y != t_lr.y-win_shape.y/2; ++yd.y,  ++yt.y)
 
  501         xt.x += win_shape.x/2;
 
  505         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  507             func(xt, t_acc, xd, d_acc);             
 
  512     temp.resize(win_shape+win_shape/2);
 
  513     t_ul = temp.upperLeft(); t_lr = temp.lowerRight();
 
  514     t_acc = temp.accessor();
 
  526     if(border == BORDER_TREATMENT_REPEAT)
 
  531         initImage(yt,yt+win_shape/2, t_acc, s_acc(ys));
 
  535         yt = t_ul + Diff2D(win_shape.x/2,0);
 
  536         Diff2D lineDiff(win_shape.x,1);
 
  537         for( ; yt.y != t_lr.y-win_shape.y ; ++yt.y)
 
  539             copyImage(ys, ys+lineDiff, s_acc, yt, t_acc);
 
  544         xt = t_ul + Diff2D(0,win_shape.y/2);
 
  545         Diff2D rowDiff(1, win_shape.y);
 
  546         for( ; xt.x != t_lr.x-win_shape.x ; ++xt.x)
 
  548             copyImage(xs, xs+rowDiff, s_acc, xt, t_acc);
 
  553         yt = t_ul + win_shape/2;
 
  554         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  557     else if(border == BORDER_TREATMENT_REFLECT)
 
  562         rotateImage(ys,ys+win_shape/2, s_acc, yt, t_acc, 180);
 
  566         yt = t_ul + Diff2D(win_shape.x/2,0);
 
  567         reflectImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc, horizontal);
 
  571         xt = t_ul + Diff2D(0,win_shape.y/2);
 
  572         reflectImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc,vertical);
 
  576         yt = t_ul + win_shape/2;
 
  577         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  580     else if(border == BORDER_TREATMENT_WRAP)
 
  583         ys = s_ul+ img_shape - win_shape/2;
 
  588         ys = s_ul + Diff2D(0, img_shape.y-win_shape.y/2);
 
  589         yt = t_ul + Diff2D(win_shape.x/2,0);
 
  590         copyImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc);
 
  593         xs = s_ul + Diff2D(img_shape.x-win_shape.x/2, 0);
 
  594         xt = t_ul + Diff2D(0,win_shape.y/2);
 
  595         copyImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc);
 
  599         yt = t_ul + win_shape/2;
 
  600         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  603     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  609         yt = t_ul + win_shape/2;
 
  610         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  616     yt.y += win_shape.y/2;
 
  619     for( ; yt.y != t_lr.y-win_shape.y/2; ++yd.y,  ++yt.y)
 
  622         xt.x += win_shape.x/2;
 
  626         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  628             func(xt, t_acc, xd, d_acc);             
 
  641     if(border == BORDER_TREATMENT_REPEAT)
 
  644         ys = s_ul + Diff2D(img_shape.x-1,0);
 
  645         yt = t_ul + Diff2D(win_shape.x,0);
 
  646         initImage(yt, yt+win_shape/2, t_acc, s_acc(ys));
 
  649         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);;
 
  651         Diff2D lineDiff(win_shape.x,1);
 
  652         for( ; yt.y != t_lr.y-win_shape.y ; ++yt.y)
 
  654             copyImage(ys, ys+lineDiff, s_acc, yt, t_acc);
 
  658         xs = s_ul + Diff2D(img_shape.x-1,0);;
 
  659         xt = t_ul + Diff2D(win_shape.x,win_shape.y/2);
 
  660         Diff2D rowDiff(1, win_shape.y);
 
  661         for( ; xt.x != t_lr.x; ++xt.x)
 
  663             copyImage(xs, xs+rowDiff, s_acc, xt, t_acc);
 
  667         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);
 
  668         yt = t_ul + Diff2D(0, win_shape.y/2);
 
  669         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  672     else if(border == BORDER_TREATMENT_REFLECT)
 
  675         ys = s_ul + Diff2D(img_shape.x-win_shape.x/2,0);
 
  676         yt = t_ul + Diff2D(win_shape.x,0);      
 
  677         rotateImage(ys, ys+win_shape/2, s_acc, yt, t_acc, 180);
 
  680         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);
 
  682         reflectImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc, horizontal);
 
  685         xs = s_ul + Diff2D(img_shape.x-win_shape.x/2,0);
 
  686         xt = t_ul + Diff2D(win_shape.x,win_shape.y/2);      
 
  687         reflectImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc,vertical);
 
  690         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);
 
  691         yt = t_ul + Diff2D(0, win_shape.y/2);
 
  692         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  695     else if(border == BORDER_TREATMENT_WRAP)
 
  698         ys = s_ul + Diff2D(0, img_shape.y-win_shape.y/2);
 
  699         yt = t_ul + Diff2D(win_shape.x,0);      
 
  700         copyImage(ys, ys+win_shape/2, s_acc, yt, t_acc);
 
  703         ys = s_ul + Diff2D(img_shape.x-win_shape.x, img_shape.y-win_shape.y/2);
 
  705         copyImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc);
 
  709         xt = t_ul + Diff2D(win_shape.x,win_shape.y/2);      
 
  710         copyImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc);
 
  713         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);
 
  714         yt = t_ul + Diff2D(0, win_shape.y/2);
 
  715         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  718     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  723         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);
 
  724         yt = t_ul + Diff2D(0, win_shape.y/2);
 
  725         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  731     yt.y += win_shape.y/2;
 
  732     yd = d_ul + Diff2D(img_shape.x-win_shape.x/2-1, 0);     
 
  734     for( ; yt.y != t_lr.y-win_shape.y/2; ++yd.y,  ++yt.y)
 
  737         xt.x += win_shape.x/2;
 
  741         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  743             func(xt, t_acc, xd, d_acc);                         
 
  755     if(border == BORDER_TREATMENT_REPEAT)
 
  758         ys = s_ul + Diff2D(0,img_shape.y-1);
 
  759         yt = t_ul + Diff2D(0,win_shape.y);
 
  760         initImage(yt, yt+win_shape/2, t_acc, s_acc(ys));
 
  763         ys = s_ul + Diff2D(0,img_shape.y-1);
 
  764         yt = t_ul + Diff2D(win_shape.x/2,win_shape.y);
 
  765         Diff2D lineDiff(win_shape.x,1);
 
  766         for( ; yt.y != t_lr.y ; ++yt.y)
 
  768             copyImage(ys, ys+lineDiff, s_acc, yt, t_acc);
 
  772         xs = s_ul + Diff2D(0,img_shape.y-win_shape.y);
 
  774         Diff2D rowDiff(1, win_shape.y);
 
  775         for( ; xt.x != t_lr.x-win_shape.x; ++xt.x)
 
  777             copyImage(xs, xs+rowDiff, s_acc, xt, t_acc);
 
  781         yt = t_ul + Diff2D(win_shape.x/2,0);
 
  782         ys = s_ul + Diff2D(0,img_shape.y-win_shape.y);
 
  783         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  786     else if(border == BORDER_TREATMENT_REFLECT)
 
  789         ys = s_ul + Diff2D(0,img_shape.y-win_shape.y/2);
 
  790         yt = t_ul + Diff2D(0,win_shape.y);
 
  791         rotateImage(ys, ys+win_shape/2, s_acc, yt, t_acc, 180);
 
  794         ys = s_ul + Diff2D(0,img_shape.y-win_shape.y/2);
 
  795         yt = t_ul + Diff2D(win_shape.x/2,win_shape.y);
 
  796         reflectImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc, horizontal);
 
  799         xs = s_ul + Diff2D(0,img_shape.y-win_shape.y);
 
  801         reflectImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc,vertical);
 
  804         yt = t_ul + Diff2D(win_shape.x/2,0);
 
  805         ys = s_ul + Diff2D(0,img_shape.y-win_shape.y);
 
  806         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  809     else if(border == BORDER_TREATMENT_WRAP)
 
  812         ys = s_ul + Diff2D(img_shape.x-win_shape.x/2,0);
 
  813         yt = t_ul + Diff2D(0,win_shape.y);
 
  814         copyImage(ys, ys+win_shape/2, s_acc, yt, t_acc);
 
  818         yt = t_ul + Diff2D(win_shape.x/2,win_shape.y);
 
  819         copyImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc);
 
  822         xs = s_ul + Diff2D(img_shape.x-win_shape.x/2,img_shape.y-win_shape.y);
 
  824         copyImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc);
 
  827         yt = t_ul + Diff2D(win_shape.x/2,0);
 
  828         ys = s_ul + Diff2D(0,img_shape.y-win_shape.y);
 
  829         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  832     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  837         yt = t_ul + Diff2D(win_shape.x/2,0);
 
  838         ys = s_ul + Diff2D(0,img_shape.y-win_shape.y);
 
  839         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  845     yt.y += win_shape.y/2;
 
  846     yd = d_ul + Diff2D(0, img_shape.y-win_shape.y/2-1);
 
  848     for( ; yt.y != t_lr.y-win_shape.y/2; ++yd.y,  ++yt.y)
 
  851         xt.x += win_shape.x/2;
 
  855         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  857             func(xt, t_acc, xd, d_acc);                             
 
  869     if(border == BORDER_TREATMENT_REPEAT)
 
  872         ys = s_ul + Diff2D(img_shape.x-1,img_shape.y-1);
 
  873         yt = t_ul + win_shape;
 
  874         initImage(yt,yt+win_shape/2, t_acc, s_acc(ys));
 
  877         ys = s_ul + Diff2D(img_shape.x-win_shape.x,img_shape.y-1);
 
  878         yt = t_ul + Diff2D(0,win_shape.y);
 
  879         Diff2D lineDiff(win_shape.x,1);
 
  880         for( ; yt.y != t_lr.y ; ++yt.y)
 
  882             copyImage(ys, ys+lineDiff, s_acc, yt, t_acc);
 
  886         xs = s_ul + Diff2D(img_shape.x-1,img_shape.y-win_shape.y);
 
  887         xt = t_ul + Diff2D(win_shape.x,0);
 
  888         Diff2D rowDiff(1, win_shape.y);
 
  889         for( ; xt.x != t_lr.x; ++xt.x)
 
  891             copyImage(xs, xs+rowDiff, s_acc, xt, t_acc);
 
  895         ys = s_ul  + img_shape - win_shape;
 
  897         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  900     else if(border == BORDER_TREATMENT_REFLECT)
 
  903         ys = s_ul + img_shape-win_shape/2;
 
  904         yt = t_ul + win_shape;
 
  905         rotateImage(ys, ys+win_shape/2, s_acc, yt, t_acc, 180);
 
  908         ys = s_ul + Diff2D(img_shape.x-win_shape.x,img_shape.y-win_shape.y/2);
 
  909         yt = t_ul + Diff2D(0,win_shape.y);
 
  910         reflectImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc, horizontal);
 
  913         xs = s_ul + Diff2D(img_shape.x-win_shape.x/2,img_shape.y-win_shape.y);
 
  914         xt = t_ul + Diff2D(win_shape.x,0);
 
  915         reflectImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc,vertical);
 
  918         ys = s_ul  + img_shape - win_shape;
 
  920         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  923     else if(border == BORDER_TREATMENT_WRAP)
 
  927         yt = t_ul + win_shape;
 
  928         copyImage(ys, ys+win_shape/2, s_acc, yt, t_acc);
 
  931         ys = s_ul + Diff2D(img_shape.x-win_shape.x,0);
 
  932         yt = t_ul + Diff2D(0,win_shape.y);
 
  933         copyImage(ys, ys+Diff2D(win_shape.x, win_shape.y/2), s_acc, yt, t_acc);
 
  936         xs = s_ul + Diff2D(0,img_shape.y-win_shape.y);
 
  937         xt = t_ul + Diff2D(win_shape.x,0);
 
  938         copyImage(xs, xs+Diff2D(win_shape.x/2, win_shape.y), s_acc, xt, t_acc);
 
  941         ys = s_ul  + img_shape-win_shape;
 
  943         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  946     else if(border == BORDER_TREATMENT_ZEROPAD)
 
  951         ys = s_ul  + img_shape - win_shape;
 
  953         copyImage(ys, ys+win_shape, s_acc, yt, t_acc);
 
  959     yt.y += win_shape.y/2;
 
  960     yd = d_ul + img_shape-win_shape/2-Diff2D(1,1);
 
  962     for( ; yt.y != t_lr.y-win_shape.y/2; ++yd.y,  ++yt.y)
 
  965         xt.x += win_shape.x/2;
 
  969         for( ; xt.x != t_lr.x-win_shape.x/2; xd.x++, xt.x++)
 
  971             func(xt, t_acc, xd, d_acc);                             
 
  976 template <
class SrcIterator, 
class SrcAccessor, 
 
  977           class DestIterator, 
class DestAccessor,
 
  978           class ProcessingFunctor>
 
  980                                 pair<DestIterator, DestAccessor> d, 
 
  981                                 ProcessingFunctor func, 
 
  982                                 BorderTreatmentMode border = BORDER_TREATMENT_REPEAT)
 
  990 template <
class T1, 
class S1, 
 
  992           class ProcessingFunctor>
 
  994                                 MultiArrayView<2, T2, S2> dest, 
 
  995                                 ProcessingFunctor func, 
 
  996                                 BorderTreatmentMode border = BORDER_TREATMENT_REPEAT)
 
  998     vigra_precondition(src.shape() == dest.shape(),
 
  999                         "vigra::applyWindowFunction(): shape mismatch between input and output.");
 
 1010 #endif //VIGRA_APPLYWINDOWFUNCTION_HXX 
void initImage(...)
Write a value to every pixel in an image or rectangular ROI. 
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
void copyImage(...)
Copy source image into destination image. 
void applyWindowFunction(...)
Apply a window function to each pixels of a given image.