es6_perspective_transform.js

/**
 *  2016-02-15
 *  2018-02-15 - UPDATE for ECMAScript 2015+
 * Jean-Christophe Taveau
 *
 * Adapted From OpenVG
 *  Taken from http://read.pudn.com/downloads159/sourcecode/graph/713580/ri_package_1.1/ri/src/riVGU.cpp__.htm
 *  VGUErrorCode RI_APIENTRY vguComputeWarpSquareToQuad(
 *      VGfloat dx0, VGfloat dy0, 
 *      VGfloat dx1, VGfloat dy1, 
 *      VGfloat dx2, VGfloat dy2, 
 *      VGfloat dx3, VGfloat dy3, 
 *      VGfloat * matrix 
 * 
 * from Heckbert:Fundamentals of Texture Mapping and Image Warping  
 * Note that his mapping of vertices is different from OpenVG's  
 * (0,0) => (dx0,dy0)  
 * (1,0) => (dx1,dy1)  
 * (0,1) => (dx2,dy2)  
 * (1,1) => (dx3,dy3)  
 */

const WARP = {};

WARP.interpolateNone = (img,x,y) => {
    return img.get(Math.floor(x),Math.floor(y));
}

WARP.interpolateBilinear = (img,x,y) => {
  let dx = x - Math.floor(x);
  let dy = y - Math.floor(y);
  let pix00 = img.get(Math.floor(x),Math.floor(y));
  let pix01 = img.get(Math.floor(x),Math.floor(y)+1);
  let pix10 = img.get(Math.floor(x)+1,Math.floor(y));
  let pix11 = img.get(Math.floor(x)+1,Math.floor(y)+1);

  let R1 = (1 - dx) * pix00 + dx * pix10;
  let R2 = (1 - dx) * pix01 + dx * pix11;

  return (1 - dy) * R1 + dy * R2;
}

WARP.mult = (matrix,x,y) => {
  let xo=matrix[0]*x+matrix[3]*y + matrix[6];
  let yo=matrix[1]*x+matrix[4]*y + matrix[7];
  let w =matrix[2]*x+matrix[5]*y + matrix[8];
  let arr=[];
  arr[0]=xo/w;
  arr[1]=yo/w;
  return arr;
}

WARP.computeSquareToQuad = (x,y) => {
  let matrix = new Array(9);
  let dx0 = x[0]; var dy0 = y[0];
  let dx1 = x[1]; var dy1 = y[1];
  let dx2 = x[2]; var dy2 = y[2];
  let dx3 = x[3]; var dy3 = y[3];
  let diffx1 = dx1 - dx3;  
  let diffy1 = dy1 - dy3;  
  let diffx2 = dx2 - dx3;  
  let diffy2 = dy2 - dy3;  
   
  let det = diffx1*diffy2 - diffx2*diffy1;  
  if (det == 0.0) {  
    return null;  
  }
  let sumx = dx0 - dx1 + dx3 - dx2;  
  let sumy = dy0 - dy1 + dy3 - dy2;  
   
  if (sumx === 0.0 && sumy === 0.0)  {   
    //affine mapping  
    matrix[0] = dx1 - dx0;  
    matrix[1] = dy1 - dy0;  
    matrix[2] = 0.0;  
    matrix[3] = dx3 - dx1;  
    matrix[4] = dy3 - dy1;  
    matrix[5] = 0.0;  
    matrix[6] = dx0;  
    matrix[7] = dy0;  
    matrix[8] = 1.0;  
    return matrix; 
   }  

  let oodet = 1.0 / det;  
  let g = (sumx*diffy2 - diffx2*sumy) * oodet;  
  let h = (diffx1*sumy - sumx*diffy1) * oodet;  
   
  matrix[0] = dx1-dx0+g*dx1;  
  matrix[1] = dy1-dy0+g*dy1;  
  matrix[2] = g;  
  matrix[3] = dx2-dx0+h*dx2;  
  matrix[4] = dy2-dy0+h*dy2;  
  matrix[5] = h;  
  matrix[6] = dx0;  
  matrix[7] = dy0;  
  matrix[8] = 1.0; 
 
  return matrix;  
}  

WARP.warp = (inp,outp,matrix,size) => {
  for (let y=0;y<size;y++) {
    for (let x=0;x<size;x++)
    {
      let xy = WARP.mult(matrix,x/size,y/size);
      // Calc pixel value depending of interpolation mode
      let pix = interpolate(inp,xy[0],xy[1]);
      outp.set(x,y,pix);
    }
  }
}