Impala Documentation

00001 #ifndef Impala_Core_Array_Pattern_FuncNgbOp2dExtra_h
00002 #define Impala_Core_Array_Pattern_FuncNgbOp2dExtra_h
00003 
00004 #include "Core/Array/Pattern/Categories.h"
00005 #include "Core/Array/Pattern/ArrayFunc.h"
00006 
00007 namespace Impala
00008 {
00009 namespace Core
00010 {
00011 namespace Array
00012 {
00013 namespace Pattern
00014 {
00015 
00016 
00017 /**********************************************************************/
00049 template <class SrcArrayT, class ExtraArrayT, class NgbT>
00050 inline void
00051 FuncNgbOp2dExtra_Pix_P1Cnum(SrcArrayT* src, ExtraArrayT* extra, int x, int y,
00052                             NgbT& ngb)
00053 {
00054     typedef typename SrcArrayT::StorType SrcStorT;
00055     typedef typename SrcArrayT::ArithType SrcArithT;
00056     typedef typename ExtraArrayT::StorType ExtraStorT;
00057     typedef typename ExtraArrayT::ArithType ExtraArithT;
00058     typedef typename NgbT::CnumType CnumType;
00059 
00060     for (CnumType cnum = ngb.Begin() ; cnum != ngb.End() ; cnum.Inc())
00061     {
00062         SrcStorT* nPtr = ArrayCPB(src, x + cnum.X(), y + cnum.Y());
00063         SrcStorT* ePtr = ArrayCPB(extra, x + cnum.X(), y + cnum.Y());
00064         ngb.NextEl(cnum.X(), cnum.Y(), PtrRead(nPtr, SrcArithT()),
00065                    PtrRead(ePtr, ExtraArithT()));
00066     }
00067 }
00068 
00071 template <class SrcStorT, class SrcArithT, class ExtraStorT, class ExtraArithT,
00072           class NgbT>
00073 inline void
00074 FuncNgbOp2dExtra_Pix_P1Loop(SrcStorT* sPtr, ExtraStorT* ePtr, NgbT& ngb,
00075                             int ngbWidth, int ngbHeight,
00076                             int srcIncX, int srcIncY, SrcArithT,
00077                             int extraIncX, int extraIncY, ExtraArithT)
00078 {
00079     for (int j=0 ; j<ngbHeight ; j++)
00080     {
00081         for (int i=0 ; i<ngbWidth ; i++)
00082         {
00083             ngb.NextEl(i, j, PtrRead(sPtr, SrcArithT()),
00084                        PtrRead(ePtr, ExtraArithT()));
00085             sPtr += srcIncX;
00086             ePtr += extraIncX;
00087         }
00088         sPtr += srcIncY;
00089         ePtr += extraIncY;
00090     }
00091 }
00092 
00095 template <class SrcStorT, class SrcArithT,  class ExtraStorT, class ExtraArithT,
00096           class NgbT>
00097 inline void
00098 FuncNgbOp2dExtra_Pix_P2Loop(SrcStorT* sPtr, ExtraStorT* ePtr, NgbT& ngb,
00099                             int ngbWidth, int ngbHeight,
00100                             int srcIncX, int srcIncY, SrcArithT,
00101                             int extraIncX, int extraIncY, ExtraArithT)
00102 {
00103     for (int j=0 ; j<ngbHeight ; j++)
00104     {
00105         for (int i=0 ; i<ngbWidth ; i++)
00106         {
00107             ngb.NextEl2(i, j, PtrRead(sPtr, SrcArithT()),
00108                         PtrRead(ePtr, ExtraArithT()));
00109             sPtr += srcIncX;
00110             ePtr += extraIncX;
00111         }
00112         sPtr += srcIncY;
00113         ePtr += extraIncY;
00114     }
00115 }
00116 
00117 
00119 //End of Pix_variations.
00120 
00121 
00123 
00127 template <class DstArrayT, class SrcArrayT, class ExtraArrayT, class NgbT>
00128 inline void
00129 FuncNgbOp2dExtra_Row(DstArrayT* dst, SrcArrayT* src, ExtraArrayT* extra,
00130                      NgbT& ngb, int y, Tag1Phase dummy1, TagCnum dummy2)
00131 {
00132     typedef typename DstArrayT::StorType DstStorT;
00133     typedef typename DstArrayT::ArithType DstArithT;
00134     typedef typename SrcArrayT::StorType SrcStorT;
00135     typedef typename SrcArrayT::ArithType SrcArithT;
00136     typedef typename ExtraArrayT::StorType ExtraStorT;
00137     typedef typename ExtraArrayT::ArithType ExtraArithT;
00138 
00139     int width = ArrayCW(dst);
00140     DstStorT* dPtr = ArrayCPB(dst, 0, y);
00141     SrcStorT* sPtr = ArrayCPB(src, 0, y);
00142     SrcStorT* ePtr = ArrayCPB(extra, 0, y);
00143     for (int x=0 ; x<width ; x++)
00144     {
00145         ngb.Init(x, y, PtrRead(sPtr, SrcArithT()),
00146                  PtrRead(ePtr, ExtraArithT()));
00147         FuncNgbOp2dExtra_Pix_P1Cnum(src, extra, x, y, ngb);
00148         PtrWrite(dPtr, ngb.Result());
00149         dPtr += DstArrayT::ElemSize();
00150         sPtr += SrcArrayT::ElemSize();
00151         ePtr += ExtraArrayT::ElemSize();
00152     }
00153 }
00154 
00157 template <class DstArrayT, class SrcArrayT, class ExtraArrayT, class NgbT>
00158 inline void
00159 FuncNgbOp2dExtra_Row(DstArrayT* dst, SrcArrayT* src, ExtraArrayT* extra,
00160                      NgbT& ngb, int y, Tag1Phase dummy1, TagLoop dummy2)
00161 {
00162     typedef typename DstArrayT::StorType DstStorT;
00163     typedef typename DstArrayT::ArithType DstArithT;
00164     typedef typename SrcArrayT::StorType SrcStorT;
00165     typedef typename SrcArrayT::ArithType SrcArithT;
00166     typedef typename ExtraArrayT::StorType ExtraStorT;
00167     typedef typename ExtraArrayT::ArithType ExtraArithT;
00168 
00169     int ngbWidth = ngb.Width();
00170     int ngbHeight = ngb.Height();
00171     int width = ArrayCW(dst);
00172     DstStorT* dPtr = ArrayCPB(dst, 0, y);
00173     SrcStorT* sPtr = ArrayCPB(src, -ngbWidth/2, y-ngbHeight/2);
00174     SrcStorT* ePtr = ArrayCPB(extra, -ngbWidth/2, y-ngbHeight/2);
00175     SrcStorT* cenPtr = ArrayCPB(src, 0, y);
00176     SrcStorT* ecenPtr = ArrayCPB(extra, 0, y);
00177     int srcIncX = ArrayInc(src, 1, 0);
00178     int srcIncY = ArrayInc(src, -ngbWidth, 1);
00179     int extraIncX = ArrayInc(extra, 1, 0);
00180     int extraIncY = ArrayInc(extra, -ngbWidth, 1);
00181     for (int x=0 ; x<width ; x++)
00182     {
00183         ngb.Init(x, y, PtrRead(cenPtr, SrcArithT()),
00184                  PtrRead(ecenPtr, ExtraArithT()));
00185         FuncNgbOp2dExtra_Pix_P1Loop(sPtr, ePtr, ngb, ngbWidth, ngbHeight,
00186                                     srcIncX, srcIncY, SrcArithT(),
00187                                     extraIncX, extraIncY, ExtraArithT());
00188         PtrWrite(dPtr, ngb.Result());
00189         dPtr += DstArrayT::ElemSize();
00190         sPtr += SrcArrayT::ElemSize();
00191         ePtr += ExtraArrayT::ElemSize();
00192         cenPtr += SrcArrayT::ElemSize();
00193         ecenPtr += ExtraArrayT::ElemSize();
00194     }
00195 }
00196 
00199 template <class DstArrayT, class SrcArrayT, class ExtraArrayT, class NgbT>
00200 inline void
00201 FuncNgbOp2dExtra_Row(DstArrayT* dst, SrcArrayT* src, ExtraArrayT* extra,
00202                      NgbT& ngb, int y, Tag2Phase dummy1, TagLoop dummy2)
00203 {
00204     typedef typename DstArrayT::StorType DstStorT;
00205     typedef typename DstArrayT::ArithType DstArithT;
00206     typedef typename SrcArrayT::StorType SrcStorT;
00207     typedef typename SrcArrayT::ArithType SrcArithT;
00208     typedef typename ExtraArrayT::StorType ExtraStorT;
00209     typedef typename ExtraArrayT::ArithType ExtraArithT;
00210 
00211     int ngbWidth = ngb.Width();
00212     int ngbHeight = ngb.Height();
00213     int width = ArrayCW(dst);
00214     DstStorT* dPtr = ArrayCPB(dst, 0, y);
00215     SrcStorT* sPtr = ArrayCPB(src, -ngbWidth/2, y-ngbHeight/2);
00216     SrcStorT* ePtr = ArrayCPB(extra, -ngbWidth/2, y-ngbHeight/2);
00217     SrcStorT* cenPtr = ArrayCPB(src, 0, y);
00218     SrcStorT* ecenPtr = ArrayCPB(extra, 0, y);
00219     int srcIncX = ArrayInc(src, 1, 0);
00220     int srcIncY = ArrayInc(src, -ngbWidth, 1);
00221     int extraIncX = ArrayInc(extra, 1, 0);
00222     int extraIncY = ArrayInc(extra, -ngbWidth, 1);
00223     for (int x=0 ; x<width ; x++)
00224     {
00225         ngb.Init(x, y, PtrRead(cenPtr, SrcArithT()),
00226                  PtrRead(ecenPtr, ExtraArithT()));
00227         FuncNgbOp2dExtra_Pix_P1Loop(sPtr, ePtr, ngb, ngbWidth, ngbHeight,
00228                                     srcIncX, srcIncY, SrcArithT(),
00229                                     extraIncX, extraIncY, ExtraArithT());
00230         ngb.Init2(x, y, PtrRead(cenPtr, SrcArithT()),
00231                   PtrRead(ecenPtr, ExtraArithT()));
00232         FuncNgbOp2dExtra_Pix_P2Loop(sPtr, ePtr, ngb, ngbWidth, ngbHeight,
00233                                     srcIncX, srcIncY, SrcArithT(),
00234                                     extraIncX, extraIncY, ExtraArithT());
00235         PtrWrite(dPtr, ngb.Result());
00236         dPtr += DstArrayT::ElemSize();
00237         sPtr += SrcArrayT::ElemSize();
00238         ePtr += ExtraArrayT::ElemSize();
00239         cenPtr += SrcArrayT::ElemSize();
00240         ecenPtr += ExtraArrayT::ElemSize();
00241     }
00242 }
00243 
00244 
00247 template <class DstArrayT, class SrcArrayT, class ExtraArrayT, class NgbT>
00248 inline void
00249 FuncNgbOp2dExtra_Row(DstArrayT* dst, SrcArrayT* src, ExtraArrayT* extra,
00250                      NgbT& ngb, int y, TagNPhase dummy1, TagLoop dummy2)
00251 {
00252     typedef typename DstArrayT::StorType DstStorT;
00253     typedef typename DstArrayT::ArithType DstArithT;
00254     typedef typename SrcArrayT::StorType SrcStorT;
00255     typedef typename SrcArrayT::ArithType SrcArithT;
00256     typedef typename ExtraArrayT::StorType ExtraStorT;
00257     typedef typename ExtraArrayT::ArithType ExtraArithT;
00258 
00259     int ngbWidth = ngb.Width();
00260     int ngbHeight = ngb.Height();
00261     int width = ArrayCW(dst);
00262     DstStorT* dPtr = ArrayCPB(dst, 0, y);
00263     SrcStorT* sPtr = ArrayCPB(src, -ngbWidth/2, y-ngbHeight/2);
00264     SrcStorT* ePtr = ArrayCPB(extra, -ngbWidth/2, y-ngbHeight/2);
00265     SrcStorT* cenPtr = ArrayCPB(src, 0, y);
00266     SrcStorT* ecenPtr = ArrayCPB(extra, 0, y);
00267     int srcIncX = ArrayInc(src, 1, 0);
00268     int srcIncY = ArrayInc(src, -ngbWidth, 1);
00269     int extraIncX = ArrayInc(extra, 1, 0);
00270     int extraIncY = ArrayInc(extra, -ngbWidth, 1);
00271     for (int x=0 ; x<width ; x++)
00272     {
00273         int phase = 1;
00274         do {
00275             ngb.Init(phase, x, y, PtrRead(cenPtr, SrcArithT()),
00276                      PtrRead(ecenPtr, ExtraArithT()));
00277             FuncNgbOp2dExtra_Pix_P1Loop(sPtr, ePtr, ngb, ngbWidth, ngbHeight,
00278                                         srcIncX, srcIncY, SrcArithT(),
00279                                         extraIncX, extraIncY, ExtraArithT());
00280             ngb.Done(phase);
00281         } while (ngb.HasNextPhase(phase++));
00282         PtrWrite(dPtr, ngb.Result());
00283         dPtr += DstArrayT::ElemSize();
00284         sPtr += SrcArrayT::ElemSize();
00285         ePtr += ExtraArrayT::ElemSize();
00286         cenPtr += SrcArrayT::ElemSize();
00287         ecenPtr += ExtraArrayT::ElemSize();
00288     }
00289 }
00290 
00292 //End of Row_variations.
00293 
00297 template<class DstArrayT, class SrcArrayT, class ExtraArrayT, class NgbT>
00298 void
00299 FuncNgbOp2dExtraDispatch(DstArrayT* dst, SrcArrayT* src, ExtraArrayT* extra,
00300                          NgbT& ngb)
00301 {
00302     int height = ArrayCH(dst);
00303     for (int y=0 ; y<height ; y++)
00304     {
00305         FuncNgbOp2dExtra_Row(dst, src, extra, ngb, y,
00306                              typename NgbT::PhaseCategory(),
00307                              typename NgbT::IteratorCategory());
00308     }
00309 }
00310 
00311 } // namespace Pattern
00312 } // namespace Array
00313 } // namespace Core
00314 } // namespace Impala
00315 
00316 #endif
FuncNgbOp2dExtra.h
