diff --git a/openbr/plugins/classification/cascade.cpp b/openbr/plugins/classification/cascade.cpp
index e37160d..196e400 100644
--- a/openbr/plugins/classification/cascade.cpp
+++ b/openbr/plugins/classification/cascade.cpp
@@ -13,14 +13,14 @@ namespace br
 
 struct Miner
 {
-    Mat src;
-    Mat scaledSrc;
+    Template src;
+    Template scaledSrc;
     Size windowSize;
     Point offset, point;
     float scale, scaleFactor, stepFactor;
 
-    Miner(const Mat &m, const Size &windowSize, const Point &offset) :
-        src(m),
+    Miner(const Template &t, const Size &windowSize, const Point &offset) :
+        src(t),
         windowSize(windowSize),
         offset(offset),
         point(offset)
@@ -29,43 +29,57 @@ struct Miner
         scaleFactor = 1.4142135623730950488016887242097F;
         stepFactor  = 0.5F;
 
-        scale = max(((float)windowSize.width + point.x) / ((float)src.cols),
-                    ((float)windowSize.height + point.y) / ((float)src.rows));
-        Size size((int)(scale*src.cols + 0.5F), (int)(scale*src.rows + 0.5F));
-        resize(src, scaledSrc, size);
+        scale = max(((float)windowSize.width + point.x) / ((float)src.m().cols),
+                    ((float)windowSize.height + point.y) / ((float)src.m().rows));
+        Size size((int)(scale*src.m().cols + 0.5F), (int)(scale*src.m().rows + 0.5F));
+        scaledSrc = resize(src, size);
     }
 
-    Mat mine(bool *newImg)
+    Template resize(const Template &src, const Size &size)
     {
-        // Copy region of winSize region of img into m
-        Mat window(windowSize.height, windowSize.width, CV_8U,
-                   (void*)(scaledSrc.data + point.y * scaledSrc.step + point.x * scaledSrc.elemSize()),
-                   scaledSrc.step);
+        Template dst(src.file);
+        for (int i=0; i<src.size(); i++) {
+            Mat buffer;
+            cv::resize(src[i], buffer, size);
+            dst.append(buffer);
+        }
+        return dst;
+    }
 
-        Mat sample;
-        window.copyTo(sample);
+    Template mine(bool *newImg)
+    {
+        Template dst(src.file);
+        // Copy region of winSize region of img into m
+        for (int i=0; i<scaledSrc.size(); i++) {
+            Mat window(windowSize.height, windowSize.width, CV_8U,
+                       (void*)(scaledSrc[i].data + point.y * scaledSrc[i].step + point.x * scaledSrc[i].elemSize()),
+                       scaledSrc[i].step);
+            Mat sample;
+            window.copyTo(sample);
+            dst.append(sample);
+        }
 
-        if ((int)(point.x + (1.0F + stepFactor) * windowSize.width) < scaledSrc.cols)
+        if ((int)(point.x + (1.0F + stepFactor) * windowSize.width) < scaledSrc.m().cols)
             point.x += (int)(stepFactor * windowSize.width);
         else {
             point.x = offset.x;
-            if ((int)(point.y + (1.0F + stepFactor) * windowSize.height) < scaledSrc.rows)
+            if ((int)(point.y + (1.0F + stepFactor) * windowSize.height) < scaledSrc.m().rows)
                 point.y += (int)(stepFactor * windowSize.height);
             else {
                 point.y = offset.y;
                 scale *= scaleFactor;
                 if (scale <= 1.0F) {
-                    Size size((int)(scale*src.cols), (int)(scale*src.rows));
-                    resize(src, scaledSrc, size);
+                    Size size((int)(scale*src.m().cols), (int)(scale*src.m().rows));
+                    scaledSrc = resize(src, size);
                 } else {
                     *newImg = true;
-                    return sample;
+                    return dst;
                 }
             }
         }
 
         *newImg = false;
-        return sample;
+        return dst;
     }
 };
 
@@ -156,10 +170,10 @@ class CascadeClassifier : public Classifier
             negative = getNegative(offset);
             samplingLocker.unlock();
 
-            Miner miner(negative.m(), windowSize(), offset);
+            Miner miner(negative, windowSize(), offset);
             forever {
                 bool newImg;
-                Template sample(negative.file, miner.mine(&newImg));
+                Template sample = miner.mine(&newImg);
                 if (!newImg) {
                     if (negSamples.size() >= numNegs)
                         return passedNegatives;
@@ -169,7 +183,6 @@ class CascadeClassifier : public Classifier
                         QMutexLocker miningLocker(&miningMutex);
                         if (negSamples.size() >= numNegs)
                             return passedNegatives;
-
                         negSamples.append(sample);
                         printf("Negative samples: %d\r", negSamples.size());
                     }
@@ -198,7 +211,7 @@ class CascadeClassifier : public Classifier
             stages.append(next_stage);
         }
 
-        for (int i = 0; i < numStages; i++) {
+        for (int i = 0; i < stages.size(); i++) {
             qDebug() << "===== TRAINING" << i << "stage =====";
             qDebug() << "<BEGIN";
 
diff --git a/openbr/plugins/imgproc/slidingwindow.cpp b/openbr/plugins/imgproc/slidingwindow.cpp
index 67ec3d6..af76329 100644
--- a/openbr/plugins/imgproc/slidingwindow.cpp
+++ b/openbr/plugins/imgproc/slidingwindow.cpp
@@ -95,75 +95,77 @@ class SlidingWindowTransform : public MetaTransform
             Size minObjectSize(minSize, minSize);
             Size maxObjectSize;
 
-            for (int i=0; i<t.size(); i++) {
-                Mat m;
-                OpenCVUtils::cvtUChar(t[i], m);
-                QList<Rect> rects;
-                QList<float> confidences;
-
-                if (maxObjectSize.height == 0 || maxObjectSize.width == 0)
-                    maxObjectSize = m.size();
-
-                Mat imageBuffer(m.rows + 1, m.cols + 1, CV_8U);
-
-                for (double factor = 1; ; factor *= scaleFactor) {
-                    int dx, dy;
-                    Size originalWindowSize = classifier->windowSize(&dx, &dy);
-
-                    Size windowSize(cvRound(originalWindowSize.width*factor), cvRound(originalWindowSize.height*factor) );
-                    Size scaledImageSize(cvRound(m.cols/factor ), cvRound(m.rows/factor));
-                    Size processingRectSize(scaledImageSize.width - originalWindowSize.width, scaledImageSize.height - originalWindowSize.height);
-
-                    if (processingRectSize.width <= 0 || processingRectSize.height <= 0)
-                        break;
-                    if (windowSize.width > maxObjectSize.width || windowSize.height > maxObjectSize.height)
-                        break;
-                    if (windowSize.width < minObjectSize.width || windowSize.height < minObjectSize.height)
-                        continue;
-
-                    Mat scaledImage(scaledImageSize, CV_8U, imageBuffer.data);
-                    resize(m, scaledImage, scaledImageSize, 0, 0, CV_INTER_LINEAR);
+            Mat m = t.m();
+            QList<Rect> rects;
+            QList<float> confidences;
+
+            if (maxObjectSize.height == 0 || maxObjectSize.width == 0)
+                maxObjectSize = m.size();
+
+            for (double factor = 1; ; factor *= scaleFactor) {
+                int dx, dy;
+                Size originalWindowSize = classifier->windowSize(&dx, &dy);
+
+                Size windowSize(cvRound(originalWindowSize.width*factor), cvRound(originalWindowSize.height*factor) );
+                Size scaledImageSize(cvRound(m.cols/factor ), cvRound(m.rows/factor));
+                Size processingRectSize(scaledImageSize.width - originalWindowSize.width, scaledImageSize.height - originalWindowSize.height);
+
+                if (processingRectSize.width <= 0 || processingRectSize.height <= 0)
+                    break;
+                if (windowSize.width > maxObjectSize.width || windowSize.height > maxObjectSize.height)
+                    break;
+                if (windowSize.width < minObjectSize.width || windowSize.height < minObjectSize.height)
+                    continue;
+
+                Template scaleBuffer(t.file);
+                for (int i=0; i<t.size(); i++) {
+                    Mat scaledImage;
+                    resize(t[i], scaledImage, scaledImageSize, 0, 0, CV_INTER_LINEAR);
+                    scaleBuffer.append(scaledImage);
+                }
 
-                    Template repImage(t.file, scaledImage);
-                    repImage = classifier->preprocess(repImage);
+                Template rep(t.file);
+                rep = classifier->preprocess(scaleBuffer);
 
-                    int step = factor > 2. ? 1 : 2;
-                    for (int y = 0; y < processingRectSize.height; y += step) {
-                        for (int x = 0; x < processingRectSize.width; x += step) {
-                            Mat window = repImage.m()(Rect(Point(x, y), Size(originalWindowSize.width + dx, originalWindowSize.height + dy))).clone();
-                            Template t(window);
+                int step = factor > 2. ? 1 : 2;
+                for (int y = 0; y < processingRectSize.height; y += step) {
+                    for (int x = 0; x < processingRectSize.width; x += step) {
+                        Template window(t.file);
+                        for (int i=0; i<rep.size(); i++) {
+                            Mat w = rep[i](Rect(Point(x, y), Size(originalWindowSize.width + dx, originalWindowSize.height + dy))).clone();
+                            window.append(w);
+                        }
 
-                            float confidence = 0;
-                            int result = classifier->classify(t, false, &confidence);
+                        float confidence = 0;
+                        int result = classifier->classify(window, false, &confidence);
 
-                            if (result == 1) {
-                                rects.append(Rect(cvRound(x*factor), cvRound(y*factor), windowSize.width, windowSize.height));
-                                confidences.append(confidence);
-                            }
+                        if (result == 1) {
+                            rects.append(Rect(cvRound(x*factor), cvRound(y*factor), windowSize.width, windowSize.height));
+                            confidences.append(confidence);
+                        }
 
-                            // TODO: Add non ROC mode
+                        // TODO: Add non ROC mode
 
-                            if (result == 0)
-                                x += step;
-                        }
+                        if (result == 0)
+                            x += step;
                     }
                 }
+            }
 
-                OpenCVUtils::group(rects, confidences, confidenceThreshold, minNeighbors, eps);
+            OpenCVUtils::group(rects, confidences, confidenceThreshold, minNeighbors, eps);
 
-                if (!enrollAll && rects.empty()) {
-                    rects.append(Rect(0, 0, m.cols, m.rows));
-                    confidences.append(-std::numeric_limits<float>::max());
-                }
+            if (!enrollAll && rects.empty()) {
+                rects.append(Rect(0, 0, m.cols, m.rows));
+                confidences.append(-std::numeric_limits<float>::max());
+            }
 
-                for (int j=0; j<rects.size(); j++) {
-                    Template u(t.file, m);
-                    u.file.set("Confidence", confidences[j]);
-                    const QRectF rect = OpenCVUtils::fromRect(rects[j]);
-                    u.file.appendRect(rect);
-                    u.file.set("Face", rect);
-                    dst.append(u);
-                }
+            for (int j=0; j<rects.size(); j++) {
+                Template u(t.file, m);
+                u.file.set("Confidence", confidences[j]);
+                const QRectF rect = OpenCVUtils::fromRect(rects[j]);
+                u.file.appendRect(rect);
+                u.file.set("Face", rect);
+                dst.append(u);
             }
         }
     }