Определение границ заливки изображения

var getPolygons = function(image){
  var buffer = document.createElement("canvas").getContext("2d");
  buffer.canvas.width = image.width + 2;
  buffer.canvas.height = image.height + 2;
  
  buffer.save();
  buffer.fillStyle = "white";
  buffer.fillRect(0, 0, buffer.canvas.width, buffer.canvas.height);
  buffer.globalCompositeOperation = "destination-in";
  buffer.drawImage(image, 1, 1);
  buffer.restore();
  
  var data = buffer.getImageData(0, 0, buffer.canvas.width, buffer.canvas.height);
  var pixs = data.data;
  var pols = [];
  var steps = [
     0, -1,
     1,  0,
     0,  1,
    -1,  0,
  ];
  var walls = [
     1,  0,
     1,  1,
     0,  1,
     0,  0,
  ];
 
  var WHITE = 0xFFFFFFFF | 0;
  var BLACK = 0x00000000 | 0;
  var RED = 0xFFF00000 | 0;
  var SUBRED = 0x000F0000 | 0;
 
  var width = data.width;
  var len = data.width * data.height * 4;
 
  var inOpen = false;
  var outOpen = false;
  for (var i = 0; i < len; i += 4) {
    // noprotect
    var pix = (pixs[i] << 24) | (pixs[i + 1] << 16) | (pixs[i + 2] << 8) | (pixs[i + 3]);
    if (pix === SUBRED) {
      outOpen = true;
      inOpen = false;
    } else if (pix >>> 24 === 0) {
      outOpen = false;
      inOpen = false;
    } else {
      if (pix === RED){
        inOpen = true;
      }
      
      if (outOpen && inOpen) {
        continue;
      }
      outOpen = true;
      inOpen = true;
      var startX = (i >> 2) % width - 1;
      var startY = (i >> 2) / width | 0;
      var x = startX;
      var y = startY;
 
      pols.push([]);
 
      var stepIndex = 0;
      var stepX = steps[stepIndex];
      var stepY = steps[stepIndex + 1];
 
      for(;;) {
        x = x + stepX;
        y = y + stepY;
        if (pixs[(y * width + x) << 2]) {
          pixs.set([0xFF, 0xF0, 0, 0], (y * width + x) << 2);
          x = x - stepX;
          y = y - stepY;
          pixs.set([0, 0x0F, 0, 0], (y * width + x) << 2);
 
          pols[pols.length - 1].push(new Point(x + walls[stepIndex], y + walls[stepIndex + 1]));
 
          stepIndex = stepIndex + 6 & 7;
          stepX = steps[stepIndex];
          stepY = steps[stepIndex + 1];
        }else if (pixs[((y + stepX) * width + x - stepY) << 2]) {
          pixs.set([0xFF, 0xF0, 0, 0], ((y + stepX) * width + x - stepY) << 2);
          pixs.set([0, 0x0F, 0, 0], (y * width + x) << 2);
        }else {
          stepIndex = stepIndex + 2 & 7;
          stepX = steps[stepIndex];
          stepY = steps[stepIndex + 1];
          pols[pols.length - 1].push(new Point(x + walls[stepIndex], y + walls[stepIndex + 1]));
        }
        if (stepIndex === 0 && x === startX && y === startY) {
          break;
        }
      }
    }
  }
  
  for (i = 0; i < pols.length; i++ ) {
    var pol = pols[i];
    if (pol[0].x > pol[1].x && pol[0].y === pol[1].y) {
      var j = i - 1;
      for (; j >= 0; j-- ) {
        var isin = rectangleInOrthogonalPolygon(new Rectangle(pol[0].x + 0.5, pol[0].y + 0.5, 0, 0), pols[j]);
 
        if (isin !== -1) {
          pols.splice(pols.indexOf(pol), 1);
 
          var resPol = pols[j];
          var controlPoint = resPol[isin + 1];
 
          var newPol = [];// (pol.length + resPol.length + 2);
 
          var resPolIndex = 0;
          while (resPolIndex <= isin) {
            newPol.push(resPol[resPolIndex++]);
          }
          newPol.push(new Point(pol[0].x, controlPoint.y));
          for (var polIndex = 0; polIndex < pol.length; polIndex++ ) {
            newPol.push(pol[polIndex]);
          }
          newPol.push(new Point(pol[0].x, controlPoint.y));
          while (resPolIndex < resPol.length) {
            newPol.push(resPol[resPolIndex++]);
          }
          pols[j] = newPol;
          i--;
        }
      }
    }
  }
  pols.forEach(function(pol){
    pol.forEach(function(v){
      v.x -= 1;
      v.y -= 1;
    });
  });
  return pols;
};
 
var rectangleInOrthogonalPolygon = function(rect, pol) {
  var counter = 0;
  var result = -1;
  
  for (var vertexIndex = 0; vertexIndex < pol.length; vertexIndex++ ) {
    var s = pol[vertexIndex]; // s - start of line
    var e = pol[(vertexIndex + 1) % pol.length]; // e - end of line
    
    if (s.x > e.x) {
      s = e;
      e = pol[vertexIndex];
    }
    
    if (s.x <= rect.x + rect.width && rect.x <= e.x) {
      if (s.y > e.y) {
        s = e;
        e = pol[vertexIndex];
      }
      if (s.y <= rect.y + rect.height && rect.y <= e.y) {
        result = vertexIndex;
        return result;
      }else if (s.x !== e.x && rect.y > s.y && rect.x > s.x && rect.x <= e.x) {
        if (result !== -1 && Math.abs(rect.y - pol[result].y) > Math.abs(rect.y - e.y)) {
          result = vertexIndex;
        }
        if (result === -1) {
          result = vertexIndex;
        }
        counter++;
      }
    }
  }
  if (counter % 2) {
    return result;
  }else {
    result = -1;
  }
  
  return result;
};