ports for mac, ios, android, linux, windows

experimental/skpdiff/SkPMetric.cpp

 #include <cmath>
 
 #include "SkBitmap.h"
 #include "skpdiff_util.h"
 #include "SkPMetric.h"
 #include "SkPMetricUtil_generated.h"
 
 struct RGB {
     float r, g, b;
 };
@@ skipping 72 matching lines @@
         SkASSERT(z < slices);
         return image[z];
     }
 };
 
 typedef ImageArray<float> ImageL3D;
 
 
 #define MAT_ROW_MULT(rc,gc,bc) r*rc + g*gc + b*bc
 
-
-void adobergb_to_cielab(float r, float g, float b, LAB* lab) {
+static void adobergb_to_cielab(float r, float g, float b, LAB* lab) {
     // Conversion of Adobe RGB to XYZ taken from from "Adobe RGB (1998) ColorImage Encoding"
     // URL:http://www.adobe.com/digitalimag/pdfs/AdobeRGB1998.pdf
     // Section: 4.3.5.3
     // See Also: http://en.wikipedia.org/wiki/Adobe_rgb
     float x = MAT_ROW_MULT(0.57667f, 0.18556f, 0.18823f);
     float y = MAT_ROW_MULT(0.29734f, 0.62736f, 0.07529f);
     float z = MAT_ROW_MULT(0.02703f, 0.07069f, 0.99134f);
 
     // The following is the white point in XYZ, so it's simply the row wise addition of the above
     // matrix.
@@ skipping 40 matching lines @@
             adobergb_to_cielab(rgb.r, rgb.g, rgb.b, &lab);
             outImageLAB->writePixel(x, y, lab);
         }
     }
     bitmap->unlockPixels();
 }
 
 // From Barten SPIE 1989
 static float contrast_sensitivity(float cyclesPerDegree, float luminance) {
     float a = 440.0f * powf(1.0f + 0.7f / luminance, -0.2f);
-    float b = 0.3f * powf(1 + 100.0 / luminance, 0.15f);
+    float b = 0.3f * powf(1.0f + 100.0f / luminance, 0.15f);
     return a *
            cyclesPerDegree *
            expf(-b * cyclesPerDegree) *
            sqrtf(1.0f + 0.06f * expf(b * cyclesPerDegree));
 }
 
 #if 0
 // We're keeping these around for reference and in case the lookup tables are no longer desired.
 // They are no longer called by any code in this file.
 
@@ skipping 86 matching lines @@
         // As we move down, scroll the row pointers down with us
         for (int y = 0; y < matrixCount - 1; y++)
         {
             rowPtrs[y] = rowPtrs[y + 1];
         }
         rowPtrs[matrixCount - 1] += imageL->width;
         writeRow += imageL->width;
     }
 }
 
-float pmetric(const ImageLAB* baselineLAB, const ImageLAB* testLAB, SkTDArray<SkIPoint>* poi) {
+static double pmetric(const ImageLAB* baselineLAB, const ImageLAB* testLAB, SkTDArray<SkIPoint>* poi) {
     int width = baselineLAB->width;
     int height = baselineLAB->height;
-    int maxLevels = (int)log2(width < height ? width : height);
+    int maxLevels = 0;
 
-    const float fov = M_PI / 180.0f * 45.0f;
+    // Calculates how many levels to make by how many times the image can be divided in two
+    int smallerDimension = width < height ? width : height;
+    for ( ; smallerDimension > 1; smallerDimension /= 2) {
+        maxLevels++;
+    }
+
+    const float fov = SK_ScalarPI / 180.0f * 45.0f;
     float contrastSensitivityMax = contrast_sensitivity(3.248f, 100.0f);
-    float pixelsPerDegree = width / (2.0f * tanf(fov * 0.5f) * 180.0f / M_PI);
+    float pixelsPerDegree = width / (2.0f * tanf(fov * 0.5f) * 180.0f / SK_ScalarPI);
 
     ImageL3D baselineL(width, height, maxLevels);
     ImageL3D testL(width, height, maxLevels);
     ImageL scratchImageL(width, height);
     float* cyclesPerDegree = SkNEW_ARRAY(float, maxLevels);
     float* thresholdFactorFrequency = SkNEW_ARRAY(float, maxLevels - 2);
     float* contrast = SkNEW_ARRAY(float, maxLevels - 2);
 
     lab_to_l(baselineLAB, baselineL.getLayer(0));
     lab_to_l(testLAB, testL.getLayer(0));
@@ skipping 39 matching lines @@
             float lTest;
             baselineL.getLayer(0)->readPixel(x, y, &lBaseline);
             testL.getLayer(0)->readPixel(x, y, &lTest);
 
             float avgLBaseline;
             float avgLTest;
             baselineL.getLayer(maxLevels - 1)->readPixel(x, y, &avgLBaseline);
             testL.getLayer(maxLevels - 1)->readPixel(x, y, &avgLTest);
 
             float lAdapt = 0.5f * (avgLBaseline + avgLTest);
-            if (lAdapt < 1e-5) {
-                lAdapt = 1e-5;
+            if (lAdapt < 1e-5f) {
+                lAdapt = 1e-5f;
             }
 
             float contrastSum = 0.0f;
             for (int levelIndex = 0; levelIndex < maxLevels - 2; levelIndex++) {
                 float baselineL0, baselineL1, baselineL2;
                 float testL0, testL1, testL2;
                 baselineL.getLayer(levelIndex + 0)->readPixel(x, y, &baselineL0);
                 testL.    getLayer(levelIndex + 0)->readPixel(x, y, &testL0);
                 baselineL.getLayer(levelIndex + 1)->readPixel(x, y, &baselineL1);
                 testL.    getLayer(levelIndex + 1)->readPixel(x, y, &testL1);
                 baselineL.getLayer(levelIndex + 2)->readPixel(x, y, &baselineL2);
                 testL.    getLayer(levelIndex + 2)->readPixel(x, y, &testL2);
 
                 float baselineContrast1 = fabsf(baselineL0 - baselineL1);
                 float testContrast1     = fabsf(testL0 - testL1);
                 float numerator = (baselineContrast1 > testContrast1) ?
                                    baselineContrast1 : testContrast1;
 
                 float baselineContrast2 = fabsf(baselineL2);
                 float testContrast2     = fabsf(testL2);
                 float denominator = (baselineContrast2 > testContrast2) ?
                                     baselineContrast2 : testContrast2;
 
                 // Avoid divides by close to zero
-                if (denominator < 1e-5) {
-                    denominator = 1e-5;
+                if (denominator < 1e-5f) {
+                    denominator = 1e-5f;
                 }
                 contrast[levelIndex] = numerator / denominator;
                 contrastSum += contrast[levelIndex];
             }
 
-            if (contrastSum < 1e-5) {
-                contrastSum = 1e-5;
+            if (contrastSum < 1e-5f) {
+                contrastSum = 1e-5f;
             }
 
             float F = 0.0f;
             for (int levelIndex = 0; levelIndex < maxLevels - 2; levelIndex++) {
                 float contrastSensitivity = contrastSensitivityTable[levelIndex * 1000 +
                                                                      (int)(lAdapt * 10.0)];
                 float mask = SkPMetricUtil::get_visual_mask(contrast[levelIndex] *
                                                             contrastSensitivity);
 
                 F += contrast[levelIndex] +
@@ skipping 88 matching lines @@
     return fQueuedDiffs[id].result;
 }
 
 int SkPMetric::getPointsOfInterestCount(int id) {
     return fQueuedDiffs[id].poi.count();
 }
 
 SkIPoint* SkPMetric::getPointsOfInterest(int id) {
     return fQueuedDiffs[id].poi.begin();
 }