diff --git a/sdk/plugins/algorithms.cpp b/sdk/plugins/algorithms.cpp
index 5858336..809e094 100644
--- a/sdk/plugins/algorithms.cpp
+++ b/sdk/plugins/algorithms.cpp
@@ -32,7 +32,6 @@ class AlgorithmsInitializer : public Initializer
     {
         // Face
         Globals->abbreviations.insert("FaceRecognition", "FaceDetection!<FaceRecognitionRegistration>!<FaceRecognitionExtraction>+<FaceRecognitionEmbedding>+<FaceRecognitionQuantization>:MatchProbability(ByteL1)");
-        Globals->abbreviations.insert("FaceRecognitionNoTraining", "Open+Cascade(FrontalFace)+ASEFEyes+Affine(256,256,0.25,0.35)+(RG+MAdd(0.5))/(Cvt(Gray)+Gradient+Bin(0,360,8,true))+Merge+Integral+IntegralSampler+CvtFloat:L2");
         Globals->abbreviations.insert("GenderClassification", "FaceDetection!<FaceClassificationRegistration>!<FaceClassificationExtraction>+<GenderClassifier>+Discard");
         Globals->abbreviations.insert("AgeRegression", "FaceDetection!<FaceClassificationRegistration>!<FaceClassificationExtraction>+<AgeRegressor>+Discard");
         Globals->abbreviations.insert("FaceQuality", "Open!Cascade(FrontalFace)+ASEFEyes+Affine(64,64,0.25,0.35)+ImageQuality+Cvt(Gray)+DFFS+Discard");
@@ -43,7 +42,7 @@ class AlgorithmsInitializer : public Initializer
         Globals->abbreviations.insert("OpenBR", "FaceRecognition");
         Globals->abbreviations.insert("GenderEstimation", "GenderClassification");
         Globals->abbreviations.insert("AgeEstimation", "AgeRegression");
-        Globals->abbreviations.insert("ImageRetrieval", "Open+(RG+MAdd(0.5))/(Cvt(Gray)+Gradient+Bin(0,360,8,true))+Merge+Integral+IntegralSampler+CvtFloat+WordWise(RowWisePCA(8)+RowWiseMeanCenter+Binarize,RowWisePCA)+Sentence:SentenceSimilarity");
+        Globals->abbreviations.insert("FaceRecognitionHoG", "Open+Cvt(Gray)+Cascade(FrontalFace)+ASEFEyes+Affine(64,64,0.25,0.35)+Gradient+Bin(0,360,8,true)+Merge+Integral+IntegralSampler+ProductQuantization:ProductQuantization");
 
         // Generic Image Processing
         Globals->abbreviations.insert("SIFT", "Open+KeyPointDetector(SIFT)+KeyPointDescriptor(SIFT):KeyPointMatcher(BruteForce)");
@@ -51,6 +50,7 @@ class AlgorithmsInitializer : public Initializer
         Globals->abbreviations.insert("SmallSIFT", "Open+LimitSize(512)+KeyPointDetector(SIFT)+KeyPointDescriptor(SIFT):KeyPointMatcher(BruteForce)");
         Globals->abbreviations.insert("SmallSURF", "Open+LimitSize(512)+KeyPointDetector(SURF)+KeyPointDescriptor(SURF):KeyPointMatcher(BruteForce)");
         Globals->abbreviations.insert("ColorHist", "Open+LimitSize(512)!EnsureChannels(3)+SplitChannels+Hist(256,0,8)+Cat+Normalize(L1):L2");
+        Globals->abbreviations.insert("ImageRetrieval", "Open+Cvt(Gray)+Cascade(FrontalFace)+ASEFEyes+Affine(88,88,0.25,0.35)+Gradient+Bin(0,360,8,true)+Merge+Integral+IntegralSampler+WordWise(RowWisePCA(8)+RowWiseMeanCenter+Binarize,RowWisePCA)+Sentence:SentenceSimilarity");
 
         // Hash
         Globals->abbreviations.insert("FileName", "Name+Identity:Identical");
diff --git a/sdk/plugins/integral.cpp b/sdk/plugins/integral.cpp
index e32dd89..3bfd356 100644
--- a/sdk/plugins/integral.cpp
+++ b/sdk/plugins/integral.cpp
@@ -38,9 +38,9 @@ class IntegralSamplerTransform : public UntrainableTransform
     Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
     Q_PROPERTY(float stepFactor READ get_stepFactor WRITE set_stepFactor RESET reset_stepFactor STORED false)
     Q_PROPERTY(int minSize READ get_minSize WRITE set_minSize RESET reset_minSize STORED false)
-    BR_PROPERTY(int, scales, 4)
+    BR_PROPERTY(int, scales, 5)
     BR_PROPERTY(float, scaleFactor, 1.5)
-    BR_PROPERTY(float, stepFactor, 0.25)
+    BR_PROPERTY(float, stepFactor, 0.75)
     BR_PROPERTY(int, minSize, 8)
 
     void project(const Template &src, Template &dst) const
@@ -53,21 +53,23 @@ class IntegralSamplerTransform : public UntrainableTransform
         const int rowStep = channels * m.cols;
 
         int descriptors = 0;
-        int currentSize = min(m.rows, m.cols)-1;
+        float idealSize = min(m.rows, m.cols)-1;
         for (int scale=0; scale<scales; scale++) {
-            descriptors += (1+(m.rows-currentSize)/int(currentSize*stepFactor)) *
-                           (1+(m.cols-currentSize)/int(currentSize*stepFactor));
-            currentSize /= scaleFactor;
-            if (currentSize < minSize) break;
+            const int currentSize(idealSize);
+            descriptors += (1+(m.rows-currentSize-1)/int(idealSize*stepFactor)) *
+                           (1+(m.cols-currentSize-1)/int(idealSize*stepFactor));
+            idealSize /= scaleFactor;
+            if (idealSize < minSize) break;
         }
         Mat n(descriptors, channels, CV_32FC1);
 
         const qint32 *dataIn = (qint32*)m.data;
         float *dataOut = (float*)n.data;
-        currentSize = min(m.rows, m.cols)-1;
+        idealSize = min(m.rows, m.cols)-1;
         int index = 0;
         for (int scale=0; scale<scales; scale++) {
-            const int currentStep = currentSize * stepFactor;
+            const int currentSize(idealSize);
+            const int currentStep(idealSize*stepFactor);
             for (int i=currentSize; i<m.rows; i+=currentStep) {
                 for (int j=currentSize; j<m.cols; j+=currentStep) {
                     InputDescriptor a(dataIn+((i-currentSize)*rowStep+(j-currentSize)*channels), channels, 1);
@@ -79,8 +81,8 @@ class IntegralSamplerTransform : public UntrainableTransform
                     index++;
                 }
             }
-            currentSize /= scaleFactor;
-            if (currentSize < minSize) break;
+            idealSize /= scaleFactor;
+            if (idealSize < minSize) break;
         }
 
         if (descriptors != index)
diff --git a/sdk/plugins/quantize.cpp b/sdk/plugins/quantize.cpp
index acc9c00..90b928d 100644
--- a/sdk/plugins/quantize.cpp
+++ b/sdk/plugins/quantize.cpp
@@ -109,58 +109,90 @@ class PackTransform : public UntrainableTransform
 
 BR_REGISTER(Transform, PackTransform)
 
-QVector<Mat> BayesianProductQuantizationLUTs;
+QVector<Mat> ProductQuantizationLUTs;
+
+/*!
+ * \ingroup distances
+ * \brief Distance in a product quantized space \cite jegou11
+ * \author Josh Klontz
+ */
+class ProductQuantizationDistance : public Distance
+{
+    Q_OBJECT
+    Q_PROPERTY(bool bayesian READ get_bayesian WRITE set_bayesian RESET reset_bayesian STORED false)
+    BR_PROPERTY(bool, bayesian, false)
+
+    float compare(const Template &a, const Template &b) const
+    {
+        float distance = 0;
+        for (int i=0; i<a.size(); i++) {
+            const int elements = a[i].total();
+            const uchar *aData = a[i].data;
+            const uchar *bData = b[i].data;
+            const float *lut = (const float*)ProductQuantizationLUTs[i].data;
+            for (int j=0; j<elements; j++)
+                distance += lut[i*256*256 + aData[j]*256+bData[j]];
+        }
+        if (!bayesian) distance = -log(distance+1);
+        return distance;
+    }
+};
+
+BR_REGISTER(Distance, ProductQuantizationDistance)
 
 /*!
  * \ingroup transforms
- * \brief A bayesian extension to product quantization \cite jegou11
+ * \brief Product quantization \cite jegou11
  * \author Josh Klontz \cite jklontz
  */
-class BayesianProductQuantizationTransform : public Transform
+class ProductQuantizationTransform : public Transform
 {
     Q_OBJECT
     Q_PROPERTY(int n READ get_n WRITE set_n RESET reset_n STORED false)
-    BR_PROPERTY(int, n, 3)
+    Q_PROPERTY(bool bayesian READ get_bayesian WRITE set_bayesian RESET reset_bayesian STORED false)
+    BR_PROPERTY(int, n, 2)
+    BR_PROPERTY(bool, bayesian, false)
 
     int index;
     QList<Mat> centers;
 
 public:
-    BayesianProductQuantizationTransform()
+    ProductQuantizationTransform()
     {
-        index = BayesianProductQuantizationLUTs.size();
-        BayesianProductQuantizationLUTs.append(Mat());
+        index = ProductQuantizationLUTs.size();
+        ProductQuantizationLUTs.append(Mat());
     }
 
 private:
     void train(const TemplateList &src)
     {
-        Mat data = OpenCVUtils::toMatByRow(src.data());
+        Mat data = OpenCVUtils::toMat(src.data());
+        qDebug() << data.rows << data.cols;
         if (data.cols % n != 0) qFatal("Expected dimensionality to be divisible by n.");
 
-        Mat &lut = BayesianProductQuantizationLUTs[index];
+        Mat &lut = ProductQuantizationLUTs[index];
         lut = Mat(data.cols/n, 256*256, CV_32FC1);
 
-        for (int i=0; i<data.cols/n; i++) {
+        for (int i=0; i<lut.rows; i++) {
             Mat labels, center;
             kmeans(data.colRange(i*n,(i+1)*n), 256, labels, TermCriteria(TermCriteria::MAX_ITER, 10, 0), 3, KMEANS_PP_CENTERS, center);
-
             for (int j=0; j<256; j++)
                 for (int k=0; k<256; k++)
-                    lut.at<float>(i,j*256+k) = norm(center.row(k), center.row(k), NORM_L2);
+                    lut.at<float>(i,j*256+k) = norm(center.row(j), center.row(k), NORM_L2);
             centers.append(center);
         }
     }
 
     void project(const Template &src, Template &dst) const
     {
+        Mat m = src.m().reshape(1, 1);
         dst = Mat(1, src.m().cols/n, CV_8UC1);
-        for (int i=0; i<src.m().cols/n; i++) {
+        for (int i=0; i<m.cols/n; i++) {
             uchar bestIndex = -1;
             double bestDistance = std::numeric_limits<double>::max();
-            Mat m = src.m().colRange(i*n, (i+1)*n);
+            Mat m_i = m.colRange(i*n, (i+1)*n);
             for (uchar i=0; i<256; i++) {
-                double distance = norm(m, centers[index].row(i), NORM_L2);
+                double distance = norm(m_i, centers[index].row(i), NORM_L2);
                 if (distance < bestDistance) {
                     bestDistance = distance;
                     bestIndex = i;
@@ -172,16 +204,16 @@ private:
 
     void store(QDataStream &stream) const
     {
-        stream << centers << BayesianProductQuantizationLUTs[index];
+        stream << centers << ProductQuantizationLUTs[index];
     }
 
     void load(QDataStream &stream)
     {
-        stream >> centers >> BayesianProductQuantizationLUTs[index];
+        stream >> centers >> ProductQuantizationLUTs[index];
     }
 };
 
-BR_REGISTER(Transform, BayesianProductQuantizationTransform)
+BR_REGISTER(Transform, ProductQuantizationTransform)
 
 } // namespace br