remote-calibrator 0.2.1 → 0.2.2-beta.3

package/src/WebGazer4RC/src/mat.mjs

@@ -0,0 +1,301 @@
+const mat = {};
+/**
+ * Transposes an mxn array
+ * @param {Array.<Array.<Number>>} matrix - of 'M x N' dimensionality
+ * @return {Array.<Array.<Number>>} transposed matrix
+ */
+mat.transpose = function(matrix){
+    var m = matrix.length;
+    var n = matrix[0].length;
+    var transposedMatrix = new Array(n);
+
+    for (var i = 0; i < m; i++){
+        for (var j = 0; j < n; j++){
+            if (i === 0) transposedMatrix[j] = new Array(m);
+            transposedMatrix[j][i] = matrix[i][j];
+        }
+    }
+
+    return transposedMatrix;
+};
+
+/**
+ * Get a sub-matrix of matrix
+ * @param {Array.<Array.<Number>>} matrix - original matrix
+ * @param {Array.<Number>} r - Array of row indices
+ * @param {Number} j0 - Initial column index
+ * @param {Number} j1 - Final column index
+ * @returns {Array} The sub-matrix matrix(r(:),j0:j1)
+ */
+mat.getMatrix = function(matrix, r, j0, j1){
+    var X = new Array(r.length),
+        m = j1-j0+1;
+
+    for (var i = 0; i < r.length; i++){
+        X[i] = new Array(m);
+        for (var j = j0; j <= j1; j++){
+            X[i][j-j0] = matrix[r[i]][j];
+        }
+    }
+    return X;
+};
+
+/**
+ * Get a submatrix of matrix
+ * @param {Array.<Array.<Number>>} matrix - original matrix
+ * @param {Number} i0 - Initial row index
+ * @param {Number} i1 - Final row index
+ * @param {Number} j0 - Initial column index
+ * @param {Number} j1 - Final column index
+ * @return {Array} The sub-matrix matrix(i0:i1,j0:j1)
+ */
+mat.getSubMatrix = function(matrix, i0, i1, j0, j1){
+    var size = j1 - j0 + 1,
+        X = new Array(i1-i0+1);
+
+    for (var i = i0; i <= i1; i++){
+        var subI = i-i0;
+
+        X[subI] = new Array(size);
+
+        for (var j = j0; j <= j1; j++){
+            X[subI][j-j0] = matrix[i][j];
+        }
+    }
+    return X;
+};
+
+/**
+ * Linear algebraic matrix multiplication, matrix1 * matrix2
+ * @param {Array.<Array.<Number>>} matrix1
+ * @param {Array.<Array.<Number>>} matrix2
+ * @return {Array.<Array.<Number>>} Matrix product, matrix1 * matrix2
+ */
+mat.mult = function(matrix1, matrix2){
+
+    if (matrix2.length != matrix1[0].length){
+        console.log('Matrix inner dimensions must agree:');
+
+    }
+
+    var X = new Array(matrix1.length),
+        Bcolj = new Array(matrix1[0].length);
+
+    for (var j = 0; j < matrix2[0].length; j++){
+        for (var k = 0; k < matrix1[0].length; k++){
+            Bcolj[k] = matrix2[k][j];
+        }
+        for (var i = 0; i < matrix1.length; i++){
+
+            if (j === 0)
+                X[i] = new Array(matrix2[0].length);
+
+            var Arowi = matrix1[i];
+            var s = 0;
+            for (var k = 0; k < matrix1[0].length; k++){
+                s += Arowi[k]*Bcolj[k];
+            }
+            X[i][j] = s;
+        }
+    }
+    return X;
+};
+
+
+/**
+ * LUDecomposition to solve A*X = B, based on WEKA code
+ * @param {Array.<Array.<Number>>} A - left matrix of equation to be solved
+ * @param {Array.<Array.<Number>>} B - right matrix of equation to be solved
+ * @return {Array.<Array.<Number>>} X so that L*U*X = B(piv,:)
+ */
+mat.LUDecomposition = function(A,B){
+    var LU = new Array(A.length);
+
+    for (var i = 0; i < A.length; i++){
+        LU[i] = new Array(A[0].length);
+        for (var j = 0; j < A[0].length; j++){
+            LU[i][j] = A[i][j];
+        }
+    }
+
+    var m = A.length;
+    var n = A[0].length;
+    var piv = new Array(m);
+    for (var i = 0; i < m; i++){
+        piv[i] = i;
+    }
+    var pivsign = 1;
+    var LUrowi = new Array();
+    var LUcolj = new Array(m);
+    // Outer loop.
+    for (var j = 0; j < n; j++){
+        // Make a copy of the j-th column to localize references.
+        for (var i = 0; i < m; i++){
+            LUcolj[i] = LU[i][j];
+        }
+        // Apply previous transformations.
+        for (var i = 0; i < m; i++){
+            LUrowi = LU[i];
+            // Most of the time is spent in the following dot product.
+            var kmax = Math.min(i,j);
+            var s = 0;
+            for (var k = 0; k < kmax; k++){
+                s += LUrowi[k]*LUcolj[k];
+            }
+            LUrowi[j] = LUcolj[i] -= s;
+        }
+        // Find pivot and exchange if necessary.
+        var p = j;
+        for (var i = j+1; i < m; i++){
+            if (Math.abs(LUcolj[i]) > Math.abs(LUcolj[p])){
+                p = i;
+            }
+        }
+        if (p != j){
+            for (var k = 0; k < n; k++){
+                var t = LU[p][k];
+                LU[p][k] = LU[j][k];
+                LU[j][k] = t;
+            }
+            var k = piv[p];
+            piv[p] = piv[j];
+            piv[j] = k;
+            pivsign = -pivsign;
+        }
+        // Compute multipliers.
+        if (j < m & LU[j][j] != 0){
+            for (var i = j+1; i < m; i++){
+                LU[i][j] /= LU[j][j];
+            }
+        }
+    }
+    if (B.length != m){
+        console.log('Matrix row dimensions must agree.');
+    }
+    for (var j = 0; j < n; j++){
+        if (LU[j][j] === 0){
+            console.log('Matrix is singular.')
+        }
+    }
+    var nx = B[0].length;
+    var X = self.webgazer.mat.getMatrix(B,piv,0,nx-1);
+    // Solve L*Y = B(piv,:)
+    for (var k = 0; k < n; k++){
+        for (var i = k+1; i < n; i++){
+            for (var j = 0; j < nx; j++){
+                X[i][j] -= X[k][j]*LU[i][k];
+            }
+        }
+    }
+    // Solve U*X = Y;
+    for (var k = n-1; k >= 0; k--){
+        for (var j = 0; j < nx; j++){
+            X[k][j] /= LU[k][k];
+        }
+        for (var i = 0; i < k; i++){
+            for (var j = 0; j < nx; j++){
+                X[i][j] -= X[k][j]*LU[i][k];
+            }
+        }
+    }
+    return X;
+};
+
+/**
+ * Least squares solution of A*X = B, based on WEKA code
+ * @param {Array.<Array.<Number>>} A - left side matrix to be solved
+ * @param {Array.<Array.<Number>>} B - a matrix with as many rows as A and any number of columns.
+ * @return {Array.<Array.<Number>>} X - that minimizes the two norms of QR*X-B.
+ */
+mat.QRDecomposition = function(A, B){
+    // Initialize.
+    var QR = new Array(A.length);
+
+    for (var i = 0; i < A.length; i++){
+        QR[i] = new Array(A[0].length);
+        for (var j = 0; j < A[0].length; j++){
+            QR[i][j] = A[i][j];
+        }
+    }
+    var m = A.length;
+    var n = A[0].length;
+    var Rdiag = new Array(n);
+    var nrm;
+
+    // Main loop.
+    for (var k = 0; k < n; k++){
+        // Compute 2-norm of k-th column without under/overflow.
+        nrm = 0;
+        for (var i = k; i < m; i++){
+            nrm = Math.hypot(nrm,QR[i][k]);
+        }
+        if (nrm != 0){
+            // Form k-th Householder vector.
+            if (QR[k][k] < 0){
+                nrm = -nrm;
+            }
+            for (var i = k; i < m; i++){
+                QR[i][k] /= nrm;
+            }
+            QR[k][k] += 1;
+
+            // Apply transformation to remaining columns.
+            for (var j = k+1; j < n; j++){
+                var s = 0;
+                for (var i = k; i < m; i++){
+                    s += QR[i][k]*QR[i][j];
+                }
+                s = -s/QR[k][k];
+                for (var i = k; i < m; i++){
+                    QR[i][j] += s*QR[i][k];
+                }
+            }
+        }
+        Rdiag[k] = -nrm;
+    }
+    if (B.length != m){
+        console.log('Matrix row dimensions must agree.');
+    }
+    for (var j = 0; j < n; j++){
+        if (Rdiag[j] === 0)
+            console.log('Matrix is rank deficient');
+    }
+    // Copy right hand side
+    var nx = B[0].length;
+    var X = new Array(B.length);
+    for(var i=0; i<B.length; i++){
+        X[i] = new Array(B[0].length);
+    }
+    for (var i = 0; i < B.length; i++){
+        for (var j = 0; j < B[0].length; j++){
+            X[i][j] = B[i][j];
+        }
+    }
+    // Compute Y = transpose(Q)*B
+    for (var k = 0; k < n; k++){
+        for (var j = 0; j < nx; j++){
+            var s = 0.0;
+            for (var i = k; i < m; i++){
+                s += QR[i][k]*X[i][j];
+            }
+            s = -s/QR[k][k];
+            for (var i = k; i < m; i++){
+                X[i][j] += s*QR[i][k];
+            }
+        }
+    }
+    // Solve R*X = Y;
+    for (var k = n-1; k >= 0; k--){
+        for (var j = 0; j < nx; j++){
+            X[k][j] /= Rdiag[k];
+        }
+        for (var i = 0; i < k; i++){
+            for (var j = 0; j < nx; j++){
+                X[i][j] -= X[k][j]*QR[i][k];
+            }
+        }
+    }
+    return mat.getSubMatrix(X,0,n-1,0,nx-1);
+}
+
+export default mat;

package/src/WebGazer4RC/src/params.mjs

@@ -0,0 +1,29 @@
+const params = {
+  moveTickSize: 50,
+  videoContainerId: 'webgazerVideoContainer',
+  videoElementId: 'webgazerVideoFeed',
+  videoElementCanvasId: 'webgazerVideoCanvas',
+  faceOverlayId: 'webgazerFaceOverlay',
+  faceFeedbackBoxId: 'webgazerFaceFeedbackBox',
+  gazeDotId: 'webgazerGazeDot',
+  videoViewerWidth: 320,
+  videoViewerHeight: 240,
+  faceFeedbackBoxRatio: 0.66,
+  // View options
+  showVideo: true,
+  mirrorVideo: true,
+  showFaceOverlay: true,
+  showFaceFeedbackBox: true,
+  showGazeDot: true,
+  camConstraints: { video: { width: { min: 320, ideal: 640, max: 1920 }, height: { min: 240, ideal: 480, max: 1080 }, facingMode: "user" } },
+  dataTimestep: 50,
+  showVideoPreview: true,
+  applyKalmanFilter: true,
+  saveDataAcrossSessions: true,
+  // Whether or not to store accuracy eigenValues, used by the calibration example file
+  storingPoints: false,
+  ////
+  videoIsOn: false,
+};
+
+export default params;

package/src/WebGazer4RC/src/pupil.mjs

@@ -0,0 +1,109 @@
+const pupil = {};
+
+/**
+ * Returns intensity value at x,y position of a pixels image
+ * @param {Array} pixels - array of size width*height
+ * @param {Number} x -  input x value
+ * @param {Number} y - input y value
+ * @param {Number} width - width of pixels image
+ * @returns {Number} - intensity value in [0,255]
+ */
+const getValue = function (pixels, x, y, width){
+  return pixels[y * width + x];
+};
+
+/**
+ * Computes summation area table/integral image of a pixel matrix
+ * @param {Array} pixels value of eye area
+ * @param {Number} width - of image in 'pixels'
+ * @param {Number} height - of image in 'pixels'
+ * @returns {Array} - integral image
+ */
+const getSumTable = function (pixels, width, height){
+  var integralImage = new Array(width);
+  var sumx = 0;
+  var sumy = 0;
+
+  for (var i = 0; i < width; i++){
+    integralImage[i] = new Array(height);
+    sumx += getValue(pixels, i, 0, width);
+    integralImage[i][0] = sumx;
+  }
+
+  for (var i = 0; i < height; i++){
+    sumy += getValue(pixels, 0, i, width);
+    integralImage[0][i] = sumy;
+  }
+
+  for (var x = 1; x < width; x++){
+    for (var y = 1; y < height; y++){
+      integralImage[x][y] = getValue(pixels, x, y, width) + integralImage[x - 1][y] + integralImage[x][y - 1] - integralImage[x - 1][y - 1];
+    }
+  }
+  return integralImage;
+};
+
+/**
+ * Detects a pupil in a set of pixels
+ * @param  {Array} pixels - patch of pixels to look for pupil into
+ * @param  {Number} width  - of pixel patch
+ * @param  {Number} height - of pixel patch
+ * @return {Array} coordinate of the bottom right corner and width of the best fitted pupil
+ */
+const getSinglePupil = function (pixels, width, height){
+  var summedAreaTable = getSumTable(pixels, width, height);
+  var bestAvgScore = 999999; //want to minimize this score
+  var bestPoint = [0, 0]; //bottom right corner of best fitted pupil
+  var bestHalfWidth = 0; //corresponding half width of the best fitted pupil
+  var offset = Math.floor(width / 10.0); //padding
+  //halfWidth could also start at 1, but this makes it faster
+  for (var halfWidth = Math.floor(height / 10.0); halfWidth < width / 2; halfWidth++){
+    //think of a sliding rectangular window of width halfWidth*2 that goes through the whole eye pixel matrix and does the following:
+    //1) computes the irisArea, which is the total intensity of the iris
+    //2) computes the scleraIrisArea, which is multiple rows of pixels including the sclera and iris.
+    //3) computes avg, which is the intensity of the area divided by the number of pixels.
+    //start at the bottom right of the rectangle!not top left
+    for (var x = halfWidth; x < width - offset; x++){
+      for (var y = halfWidth; y < height - offset; y++){
+        //evaluate area by the formula found on wikipedia about the summed area table: I(D)+I(A)-I(B)-I(C)
+        var irisArea = summedAreaTable[x + offset][y + offset] + summedAreaTable[x + offset - halfWidth][y + offset - halfWidth] - summedAreaTable[x + offset][y + offset - halfWidth] - summedAreaTable[x + offset - halfWidth][y + offset];
+        var avgScore = 1.0 * irisArea / ((halfWidth + 1) * (halfWidth + 1)) + 1;
+        //summation area table again
+        var scleraIrisArea = ((1.0 * summedAreaTable[width - 1 - offset][y + offset] + summedAreaTable[0 + offset][y + offset - halfWidth] - summedAreaTable[0 + offset][y + offset] - summedAreaTable[width - 1 - offset][y + offset - halfWidth]) - irisArea);
+        //minimize avgScore/scleraIrisArea. 150 is too high, might have to change since it's closer to white
+        if ((avgScore) / scleraIrisArea < bestAvgScore && avgScore < 150){
+          bestAvgScore = (avgScore) / scleraIrisArea;
+          bestPoint = [x + offset, y + offset];
+          bestHalfWidth = halfWidth;
+        }
+      }
+    }
+  }
+  return [bestPoint, bestHalfWidth];
+};
+
+/**
+ * Given an object with two eye patches it finds the location of the detected pupils
+ * @param  {Object} eyesObj - left and right detected eye patches
+ * @return {Object} eyesObj - updated eye patches with information about pupils' locations
+ */
+const getPupils = function(eyesObj) {
+  if (!eyesObj) {
+    return eyesObj;
+  }
+  if (!eyesObj.left.blink) {
+    eyesObj.left.pupil = getSinglePupil(Array.prototype.slice.call(webgazer.util.grayscale(eyesObj.left.patch.data, eyesObj.left.width, eyesObj.left.height)), eyesObj.left.width, eyesObj.left.height);
+    eyesObj.left.pupil[0][0] -= eyesObj.left.pupil[1];
+    eyesObj.left.pupil[0][1] -= eyesObj.left.pupil[1];
+  }
+  if (!eyesObj.right.blink) {
+    eyesObj.right.pupil = getSinglePupil(Array.prototype.slice.call(webgazer.util.grayscale(eyesObj.right.patch.data, eyesObj.right.width, eyesObj.right.height)), eyesObj.right.width, eyesObj.right.height);
+    eyesObj.right.pupil[0][0] -= eyesObj.right.pupil[1];
+    eyesObj.right.pupil[0][1] -= eyesObj.right.pupil[1];
+  }
+  return eyesObj;
+}
+
+pupil.getPupils = getPupils;
+
+export default pupil;

package/src/WebGazer4RC/src/ridgeReg.mjs

@@ -0,0 +1,104 @@
+import util from './util.mjs';
+import util_regression from './util_regression.mjs';
+import params from './params.mjs';
+
+const reg = {};
+
+/**
+ * Constructor of RidgeReg object,
+ * this object allow to perform ridge regression
+ * @constructor
+ */
+reg.RidgeReg = function() {
+  this.init();
+};
+
+/**
+ * Initialize new arrays and initialize Kalman filter.
+ */
+reg.RidgeReg.prototype.init = util_regression.InitRegression
+
+/**
+ * Add given data from eyes
+ * @param {Object} eyes - eyes where extract data to add
+ * @param {Object} screenPos - The current screen point
+ * @param {Object} type - The type of performed action
+ */
+reg.RidgeReg.prototype.addData = util_regression.addData
+
+/**
+ * Try to predict coordinates from pupil data
+ * after apply linear regression on data set
+ * @param {Object} eyesObj - The current user eyes object
+ * @returns {Object}
+ */
+reg.RidgeReg.prototype.predict = function(eyesObj) {
+  if (!eyesObj || this.eyeFeaturesClicks.length === 0) {
+    return null;
+  }
+  var acceptTime = performance.now() - this.trailTime;
+  var trailX = [];
+  var trailY = [];
+  var trailFeat = [];
+  for (var i = 0; i < this.trailDataWindow; i++) {
+    if (this.trailTimes.get(i) > acceptTime) {
+      trailX.push(this.screenXTrailArray.get(i));
+      trailY.push(this.screenYTrailArray.get(i));
+      trailFeat.push(this.eyeFeaturesTrail.get(i));
+    }
+  }
+
+  var screenXArray = this.screenXClicksArray.data.concat(trailX);
+  var screenYArray = this.screenYClicksArray.data.concat(trailY);
+  var eyeFeatures = this.eyeFeaturesClicks.data.concat(trailFeat);
+
+  var coefficientsX = util_regression.ridge(screenXArray, eyeFeatures, this.ridgeParameter);
+  var coefficientsY = util_regression.ridge(screenYArray, eyeFeatures, this.ridgeParameter);
+
+  var eyeFeats = util.getEyeFeats(eyesObj);
+  var predictedX = 0;
+  for(var i=0; i< eyeFeats.length; i++){
+    predictedX += eyeFeats[i] * coefficientsX[i];
+  }
+  var predictedY = 0;
+  for(var i=0; i< eyeFeats.length; i++){
+    predictedY += eyeFeats[i] * coefficientsY[i];
+  }
+
+  predictedX = Math.floor(predictedX);
+  predictedY = Math.floor(predictedY);
+
+  if (params.applyKalmanFilter) {
+    // Update Kalman model, and get prediction
+    var newGaze = [predictedX, predictedY]; // [20200607 xk] Should we use a 1x4 vector?
+    newGaze = this.kalman.update(newGaze);
+
+    return {
+      x: newGaze[0],
+      y: newGaze[1]
+    };
+  } else {
+    return {
+      x: predictedX,
+      y: predictedY
+    };
+  }
+};
+
+reg.RidgeReg.prototype.setData = util_regression.setData;
+
+/**
+ * Return the data
+ * @returns {Array.<Object>|*}
+ */
+reg.RidgeReg.prototype.getData = function() {
+  return this.dataClicks.data;
+}
+
+/**
+ * The RidgeReg object name
+ * @type {string}
+ */
+reg.RidgeReg.prototype.name = 'ridge';
+
+export default reg;

package/src/WebGazer4RC/src/ridgeRegThreaded.mjs

@@ -0,0 +1,161 @@
+import util from './util.mjs';
+import numeric from 'numeric';
+import util_regression from './util_regression.mjs';
+import params from './params.mjs';
+
+const reg = {};
+
+var ridgeParameter = Math.pow(10,-5);
+var dataWindow = 700;
+var weights = {'X':[0],'Y':[0]};
+var trailDataWindow = 10;
+
+
+/**
+ * Constructor of RidgeRegThreaded object,
+ * it retrieve data window, and prepare a worker,
+ * this object allow to perform threaded ridge regression
+ * @constructor
+ */
+reg.RidgeRegThreaded = function() {
+    this.init();
+};
+
+/**
+ * Initialize new arrays and initialize Kalman filter.
+ */
+reg.RidgeRegThreaded.prototype.init = function() { 
+    this.screenXClicksArray = new util.DataWindow(dataWindow);  
+    this.screenYClicksArray = new util.DataWindow(dataWindow);  
+    this.eyeFeaturesClicks = new util.DataWindow(dataWindow);   
+
+    this.screenXTrailArray = new util.DataWindow(trailDataWindow);  
+    this.screenYTrailArray = new util.DataWindow(trailDataWindow);  
+    this.eyeFeaturesTrail = new util.DataWindow(trailDataWindow);   
+
+    this.dataClicks = new util.DataWindow(dataWindow);  
+    this.dataTrail = new util.DataWindow(dataWindow);   
+
+    // Place the src/ridgeworker.js file into the same directory as your html file. 
+    if (!this.worker) { 
+        this.worker = new Worker('ridgeWorker.mjs'); // [20200708] TODO: Figure out how to make this inline 
+        this.worker.onerror = function(err) { console.log(err.message); };  
+        this.worker.onmessage = function(evt) { 
+            weights.X = evt.data.X; 
+            weights.Y = evt.data.Y; 
+        };  
+        console.log('initialized worker');  
+    }   
+
+    // Initialize Kalman filter [20200608 xk] what do we do about parameters?   
+    // [20200611 xk] unsure what to do w.r.t. dimensionality of these matrices. So far at least 
+    //               by my own anecdotal observation a 4x1 x vector seems to work alright   
+    var F = [ [1, 0, 1, 0], 
+              [0, 1, 0, 1], 
+              [0, 0, 1, 0], 
+              [0, 0, 0, 1]];    
+
+    //Parameters Q and R may require some fine tuning   
+    var Q = [ [1/4, 0,    1/2, 0],  
+              [0,   1/4,  0,   1/2],    
+              [1/2, 0,    1,   0],  
+              [0,  1/2,  0,   1]];// * delta_t  
+    var delta_t = 1/10; // The amount of time between frames    
+    Q = numeric.mul(Q, delta_t);    
+
+    var H = [ [1, 0, 0, 0, 0, 0],   
+              [0, 1, 0, 0, 0, 0],   
+              [0, 0, 1, 0, 0, 0],   
+              [0, 0, 0, 1, 0, 0]];  
+    var H = [ [1, 0, 0, 0], 
+              [0, 1, 0, 0]];    
+    var pixel_error = 47; //We will need to fine tune this value [20200611 xk] I just put a random value here   
+
+    //This matrix represents the expected measurement error 
+    var R = numeric.mul(numeric.identity(2), pixel_error);  
+
+    var P_initial = numeric.mul(numeric.identity(4), 0.0001); //Initial covariance matrix   
+    var x_initial = [[500], [500], [0], [0]]; // Initial measurement matrix 
+
+    this.kalman = new util_regression.KalmanFilter(F, H, Q, R, P_initial, x_initial);  
+}
+/**
+ * Add given data from eyes
+ * @param {Object} eyes - eyes where extract data to add
+ * @param {Object} screenPos - The current screen point
+ * @param {Object} type - The type of performed action
+ */
+reg.RidgeRegThreaded.prototype.addData = function(eyes, screenPos, type) {
+    if (!eyes) {
+        return;
+    }
+    //not doing anything with blink at present
+    // if (eyes.left.blink || eyes.right.blink) {
+    //     return;
+    // }
+    this.worker.postMessage({'eyes':util.getEyeFeats(eyes), 'screenPos':screenPos, 'type':type});
+};
+
+/**
+ * Try to predict coordinates from pupil data
+ * after apply linear regression on data set
+ * @param {Object} eyesObj - The current user eyes object
+ * @returns {Object}
+ */
+reg.RidgeRegThreaded.prototype.predict = function(eyesObj) {
+    // console.log('LOGGING..');
+    if (!eyesObj) {
+        return null;
+    }
+    var coefficientsX = weights.X;
+    var coefficientsY = weights.Y;
+
+    var eyeFeats = util.getEyeFeats(eyesObj);
+    var predictedX = 0, predictedY = 0;
+    for(var i=0; i< eyeFeats.length; i++){
+        predictedX += eyeFeats[i] * coefficientsX[i];
+        predictedY += eyeFeats[i] * coefficientsY[i];
+    }
+
+    predictedX = Math.floor(predictedX);
+    predictedY = Math.floor(predictedY);
+
+    if (params.applyKalmanFilter) {
+        // Update Kalman model, and get prediction
+        var newGaze = [predictedX, predictedY]; // [20200607 xk] Should we use a 1x4 vector?
+        newGaze = this.kalman.update(newGaze);
+
+        return {
+            x: newGaze[0],
+            y: newGaze[1]
+        };
+    } else {
+        return {
+            x: predictedX,
+            y: predictedY
+        };
+    }
+};
+
+/**
+ * Add given data to current data set then,
+ * replace current data member with given data
+ * @param {Array.<Object>} data - The data to set
+ */
+reg.RidgeRegThreaded.prototype.setData = util_regression.setData
+
+/**
+ * Return the data
+ * @returns {Array.<Object>|*}
+ */
+reg.RidgeRegThreaded.prototype.getData = function() {
+    return this.dataClicks.data;
+};
+
+/**
+ * The RidgeRegThreaded object name
+ * @type {string}
+ */
+reg.RidgeRegThreaded.prototype.name = 'ridge';
+
+export default reg;