integral channel storage are cached as a cascade's field

modules/gpu/src/icf.hpp

@@ -54,79 +54,93 @@
 
 namespace icf {
 
-    struct Cascade
+using cv::gpu::PtrStepSzb;
+using cv::gpu::PtrStepSzf;
+
+struct Cascade
+{
+    Cascade() {}
+    Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
+        const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
+    : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
+
+    PtrStepSzb octaves;
+    PtrStepSzf stages;
+    PtrStepSzb nodes;
+    PtrStepSzf leaves;
+    PtrStepSzb features;
+
+    PtrStepSzb levels;
+
+};
+
+struct ChannelStorage
+{
+    ChannelStorage(){}
+    ChannelStorage(const cv::gpu::PtrStepSzb& buff, const cv::gpu::PtrStepSzb& shr,
+        const cv::gpu::PtrStepSzb& itg, const int s)
+    : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
+
+    void frame(const cv::gpu::PtrStepSzb& image) {}
+
+    PtrStepSzb dmem;
+    PtrStepSzb shrunk;
+    PtrStepSzb hogluv;
+
+    int shrinkage;
+};
+
+struct __align__(16) Octave
+{
+    ushort index;
+    ushort stages;
+    ushort shrinkage;
+    ushort2 size;
+    float scale;
+
+    Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
+    : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
+};
+
+struct __align__(8) Node
+{
+    int feature;
+    float threshold;
+
+    Node(const int f, const float t) : feature(f), threshold(t) {}
+};
+
+struct __align__(8) Feature
+{
+    int channel;
+    uchar4 rect;
+
+    Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
+};
+
+struct __align__(8) Level //is actually 24 bytes
+{
+    int octave;
+
+    // float origScale; //not actually used
+    float relScale;
+    float shrScale;   // used for marking detection
+    float scaling[2]; // calculated according to Dollal paper
+
+    // for 640x480 we can not get overflow
+    uchar2 workRect;
+    uchar2 objSize;
+
+    Level(int idx, const Octave& oct, const float scale, const int w, const int h)
+    :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
     {
-        Cascade() {}
-        Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
-            const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
-        : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
+        workRect.x = round(w / (float)oct.shrinkage);
+        workRect.y = round(h / (float)oct.shrinkage);
 
-        cv::gpu::PtrStepSzb octaves;
-        cv::gpu::PtrStepSzf stages;
-        cv::gpu::PtrStepSzb nodes;
-        cv::gpu::PtrStepSzf leaves;
-        cv::gpu::PtrStepSzb features;
-
-        cv::gpu::PtrStepSzb levels;
-
-    };
-
-    struct ChannelStorage
-    {
-        ChannelStorage(const cv::gpu::PtrStepSzb& /*f*/, const int /*shrinkage*/) {}
-    };
-
-    struct __align__(16) Octave
-    {
-        ushort index;
-        ushort stages;
-        ushort shrinkage;
-        ushort2 size;
-        float scale;
-
-        Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
-        : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
-    };
-
-    struct __align__(8) Node
-    {
-        int feature;
-        float threshold;
-
-        Node(const int f, const float t) : feature(f), threshold(t) {}
-    };
-
-    struct __align__(8) Feature
-    {
-        int channel;
-        uchar4 rect;
-
-        Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
-    };
-
-    struct __align__(8) Level //is actually 24 bytes
-    {
-        int octave;
-
-        // float origScale; //not actually used
-        float relScale;
-        float shrScale;   // used for marking detection
-        float scaling[2]; // calculated according to Dollal paper
-
-        // for 640x480 we can not get overflow
-        uchar2 workRect;
-        uchar2 objSize;
-
-        Level(int idx, const Octave& oct, const float scale, const int w, const int h)
-        :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
-        {
-            workRect.x = round(w / (float)oct.shrinkage);
-            workRect.y = round(h / (float)oct.shrinkage);
-
-            objSize.x  = round(oct.size.x * relScale);
-            objSize.y  = round(oct.size.y * relScale);
-        }
-    };
+        objSize.x  = round(oct.size.x * relScale);
+        objSize.y  = round(oct.size.y * relScale);
+    }
+};
 }
 
 #endif
\ No newline at end of file

modules/gpu/src/softcascade.cpp

@@ -84,9 +84,10 @@ struct cv::gpu::SoftCascade::Filds
     std::vector<float> scales;
 
     icf::Cascade cascade;
+    icf::ChannelStorage storage;
 
     bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect(const icf::ChannelStorage& /*channels*/) const {}
+    void detect() const {}
 
     enum { BOOST = 0 };
     enum
@@ -281,6 +282,7 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
     hogluv.create( (FRAME_HEIGHT / shrinkage * HOG_LUV_BINS) + 1, (FRAME_WIDTH / shrinkage) + 1, CV_16UC1);
 
+    storage = icf::ChannelStorage(dmem, shrunk, hogluv, shrinkage);
     return true;
 }
 
@@ -398,13 +400,10 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& image, const GpuMat& /
     // only this window size allowed
     CV_Assert(image.cols == 640 && image.rows == 480);
 
+    Filds& flds = *filds;
 
-    // ToDo: add shrincage in whole cascade.
-    const int shrincage = 4;
-    icf::ChannelStorage storage(image, shrincage);
-
-    const Filds& flds = *filds;
-    flds.detect(storage);
+    flds.storage.frame(image);
+    flds.detect();
 }
 
 #endif