integral channel storage are cached as a cascade's field

modules/gpu/src/icf.hpp

@@ -54,30 +54,44 @@
 
 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) {}
 
-        cv::gpu::PtrStepSzb octaves;
-        cv::gpu::PtrStepSzf stages;
-        cv::gpu::PtrStepSzb nodes;
-        cv::gpu::PtrStepSzf leaves;
-        cv::gpu::PtrStepSzb features;
+    PtrStepSzb octaves;
+    PtrStepSzf stages;
+    PtrStepSzb nodes;
+    PtrStepSzf leaves;
+    PtrStepSzb features;
 
-        cv::gpu::PtrStepSzb levels;
+    PtrStepSzb levels;
 
-    };
+};
 
-    struct ChannelStorage
-    {
-        ChannelStorage(const cv::gpu::PtrStepSzb& /*f*/, const int /*shrinkage*/) {}
-    };
+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) {}
 
-    struct __align__(16) Octave
-    {
+    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;
@@ -86,26 +100,26 @@ namespace icf {
 
     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
-    {
+struct __align__(8) Node
+{
     int feature;
     float threshold;
 
     Node(const int f, const float t) : feature(f), threshold(t) {}
-    };
+};
 
-    struct __align__(8) Feature
-    {
+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
-    {
+struct __align__(8) Level //is actually 24 bytes
+{
     int octave;
 
     // float origScale; //not actually used
@@ -126,7 +140,7 @@ namespace icf {
         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