implement sampled functions based on the PDF spec

src/function.js

@@ -125,109 +125,67 @@ var PDFFunction = (function PDFFunctionClosure() {
       else
         decode = toMultiArray(decode);
 
-      // Precalc the multipliers
-      var inputMul = new Float64Array(inputSize);
-      for (var i = 0; i < inputSize; ++i) {
-        inputMul[i] = (encode[i][1] - encode[i][0]) /
-                  (domain[i][1] - domain[i][0]);
-      }
-
-      var idxMul = new Int32Array(inputSize);
-      idxMul[0] = outputSize;
-      for (i = 1; i < inputSize; ++i) {
-        idxMul[i] = idxMul[i - 1] * size[i - 1];
-      }
-
-      var nSamples = outputSize;
-      for (i = 0; i < inputSize; ++i)
-          nSamples *= size[i];
-
       var samples = this.getSampleArray(size, outputSize, bps, str);
 
       return [
         CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size,
-        outputSize, bps, range, inputMul, idxMul, nSamples
+        outputSize, Math.pow(2, bps) - 1, range
       ];
     },
 
     constructSampledFromIR: function pdfFunctionConstructSampledFromIR(IR) {
-      var inputSize = IR[1];
+      // See chapter 3, page 109 of the PDF reference
-      var domain = IR[2];
+      function interpolate(x, xmin, xmax, ymin, ymax) {
-      var encode = IR[3];
+        return ymin + ((x - xmin) * ((ymax - ymin) / (xmax - xmin)));
-      var decode = IR[4];
+      }
-      var samples = IR[5];
-      var size = IR[6];
-      var outputSize = IR[7];
-      var bps = IR[8];
-      var range = IR[9];
-      var inputMul = IR[10];
-      var idxMul = IR[11];
-      var nSamples = IR[12];
 
       return function constructSampledFromIRResult(args) {
-        if (inputSize != args.length)
+        // See chapter 3, page 110 of the PDF reference.
+        var m = IR[1];
+        var domain = IR[2];
+        var encode = IR[3];
+        var decode = IR[4];
+        var samples = IR[5];
+        var size = IR[6];
+        var n = IR[7];
+        var mask = IR[8];
+        var range = IR[9];
+
+        if (m != args.length)
           error('Incorrect number of arguments: ' + inputSize + ' != ' +
                 args.length);
-        // Most of the below is a port of Poppler's implementation.
-        // TODO: There's a few other ways to do multilinear interpolation such
-        // as piecewise, which is much faster but an approximation.
-        var out = new Float64Array(outputSize);
-        var x;
-        var e = new Array(inputSize);
-        var efrac0 = new Float64Array(inputSize);
-        var efrac1 = new Float64Array(inputSize);
-        var sBuf = new Float64Array(1 << inputSize);
-        var i, j, k, idx, t;
 
-        // map input values into sample array
+        var x = args;
-        for (i = 0; i < inputSize; ++i) {
+        var y = new Float64Array(n * m);
-          x = (args[i] - domain[i][0]) * inputMul[i] + encode[i][0];
-          if (x < 0) {
-            x = 0;
-          } else if (x > size[i] - 1) {
-            x = size[i] - 1;
-          }
-          e[i] = [Math.floor(x), 0];
-          if ((e[i][1] = e[i][0] + 1) >= size[i]) {
-            // this happens if in[i] = domain[i][1]
-            e[i][1] = e[i][0];
-          }
-          efrac1[i] = x - e[i][0];
-          efrac0[i] = 1 - efrac1[i];
-        }
 
-        // for each output, do m-linear interpolation
+        // Map x_i to y_j for 0 <= i < m using the sampled function.
-        for (i = 0; i < outputSize; ++i) {
+        for (var i = 0; i < m; ++i) {
+          // x_i' = min(max(x_i, Domain_2i), Domain_2i+1)
+          var domain_2i = domain[2 * i];
+          var domain_2i_1 = domain[2 * i + 1];
+          var xi = Math.min(Math.max(x[i], domain_2i), domain_2i_1);
 
-          // pull 2^m values out of the sample array
+          // e_i = Interpolate(x_i', Domain_2i, Domain_2i+1, Encode_2i, Encode_2i+1)
-          for (j = 0; j < (1 << inputSize); ++j) {
+          var e = interpolate(xi, domain_2i, domain_2i_1, encode[2 * i], encode[2 * i + 1]);
-            idx = i;
-            for (k = 0, t = j; k < inputSize; ++k, t >>= 1) {
-              idx += idxMul[k] * (e[k][t & 1]);
-            }
-            if (idx >= 0 && idx < nSamples) {
-              sBuf[j] = samples[idx];
-            } else {
-              sBuf[j] = 0; // TODO Investigate if this is what Adobe does
-            }
-          }
 
-          // do m sets of interpolations
+          // e_i' = min(max(e_i, 0), Size_i - 1)
-          for (j = 0, t = (1 << inputSize); j < inputSize; ++j, t >>= 1) {
+          e = Math.min(Math.max(e, 0), size[i] - 1);
-            for (k = 0; k < t; k += 2) {
-              sBuf[k >> 1] = efrac0[j] * sBuf[k] + efrac1[j] * sBuf[k + 1];
-            }
-          }
 
-          // map output value to range
+          var in = i * n;
-          out[i] = (sBuf[0] * (decode[i][1] - decode[i][0]) + decode[i][0]);
+
-          if (out[i] < range[i][0]) {
+          for (var j = 0; j < n; ++j) {
-            out[i] = range[i][0];
+            // average the two nearest neighbors in the sampling table
-          } else if (out[i] > range[i][1]) {
+            var rj = (samples[Math.floor(e) * n + j] + samples[Math.ceil(e) * n + j]) / 2;
-            out[i] = range[i][1];
+
+            // r_j' = Interpolate(r_j, 0, 2^BitsPerSample - 1, Decode_2j, Decode_2j+1)
+            rj = interpolate(rj, 0, mask, 1, decode[2 * j], decode[2 * j + 1]);
+
+            // y_j = min(max(r_j, range_2j, range_2j+1)
+            y[in + j] = Math.min(Math.max(rj, range[2 * j], range[2 * j + 1]));
           }
         }
-        return out;
+
+        return y;
       }
     },