remote-calibrator 0.2.2-beta.2 → 0.2.2

package/src/WebGazer4RC/src/mat.mjs

@@ -1,301 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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;