Javascript 使用谷歌NaCl读取画布上的像素值吗？

我正在使用此库跟踪彩色对象：

该库似乎在一组像素上迭代，这些像素从网络摄像头中获取并跟踪颜色。

• 问题是这个算法非常慢。我正在努力 要将此检测作为一个简单的2D游戏的一部分，我正在我的基础上构建 画布，它会让它慢下来像爬行一样

• 我正在构建的游戏将只在1台电脑上运行，所以我有足够的内存 控制我可以使用的浏览器

• 很明显，这种性能影响是由 正在搜索画布上的颜色

我想也许我可以使用谷歌的NaCl（原生客户端）来迭代“像素数组”，而不是Javascript。从我所知道的，编译的语言，如C++，比解释语言（如JavaScript）快得多。 因此，场景是我获取网络摄像头提要，将其作为消息发布到NaCl，然后获取检测坐标

问题是：

我会从这种情况中受益吗

PS：我之所以询问而不是直接测试，是因为我从未接触过编译语言。我严格地说来自WebDev背景，我需要得到一些建议，如果这件事值得尝试或不值得，在我用一个全新的范例弄脏我的手之前

---

当前源代码：

在任何情况下，这都是发生颜色跟踪的源代码：

tracking.ColorTracker.prototype.calculateDimensions_ = function(cloud, total) {
    var maxx = -1;
    var maxy = -1;
    var minx = Infinity;
    var miny = Infinity;

    for (var c = 0; c < total; c += 2) {
      var x = cloud[c];
      var y = cloud[c + 1];

      if (x < minx) {
        minx = x;
      }
      if (x > maxx) {
        maxx = x;
      }
      if (y < miny) {
        miny = y;
      }
      if (y > maxy) {
        maxy = y;
      }
    }

    return {
      width: maxx - minx,
      height: maxy - miny,
      x: minx,
      y: miny
    };
  };

  /**
   * Gets the colors being tracked by the `ColorTracker` instance.
   * @return {Array.<string>}
   */
  tracking.ColorTracker.prototype.getColors = function() {
    return this.colors;
  };

  /**
   * Gets the minimum dimension to classify a rectangle.
   * @return {number}
   */
  tracking.ColorTracker.prototype.getMinDimension = function() {
    return this.minDimension;
  };

  /**
   * Gets the maximum dimension to classify a rectangle.
   * @return {number}
   */
  tracking.ColorTracker.prototype.getMaxDimension = function() {
    return this.maxDimension;
  };

  /**
   * Gets the minimum group size to be classified as a rectangle.
   * @return {number}
   */
  tracking.ColorTracker.prototype.getMinGroupSize = function() {
    return this.minGroupSize;
  };

  /**
   * Gets the eight offset values of the neighbours surrounding a pixel.
   * @param {number} width The image width.
   * @return {array} Array with the eight offset values of the neighbours
   *     surrounding a pixel.
   * @private
   */
  tracking.ColorTracker.prototype.getNeighboursForWidth_ = function(width) {
    if (tracking.ColorTracker.neighbours_[width]) {
      return tracking.ColorTracker.neighbours_[width];
    }

    var neighbours = new Int32Array(8);

    neighbours[0] = -width * 4;
    neighbours[1] = -width * 4 + 4;
    neighbours[2] = 4;
    neighbours[3] = width * 4 + 4;
    neighbours[4] = width * 4;
    neighbours[5] = width * 4 - 4;
    neighbours[6] = -4;
    neighbours[7] = -width * 4 - 4;

    tracking.ColorTracker.neighbours_[width] = neighbours;

    return neighbours;
  };

  /**
   * Unites groups whose bounding box intersect with each other.
   * @param {Array.<Object>} rects
   * @private
   */
  tracking.ColorTracker.prototype.mergeRectangles_ = function(rects) {
    var intersects;
    var results = [];
    var minDimension = this.getMinDimension();
    var maxDimension = this.getMaxDimension();

    for (var r = 0; r < rects.length; r++) {
      var r1 = rects[r];
      intersects = true;
      for (var s = r + 1; s < rects.length; s++) {
        var r2 = rects[s];
        if (tracking.Math.intersectRect(r1.x, r1.y, r1.x + r1.width, r1.y + r1.height, r2.x, r2.y, r2.x + r2.width, r2.y + r2.height)) {
          intersects = false;
          var x1 = Math.min(r1.x, r2.x);
          var y1 = Math.min(r1.y, r2.y);
          var x2 = Math.max(r1.x + r1.width, r2.x + r2.width);
          var y2 = Math.max(r1.y + r1.height, r2.y + r2.height);
          r2.height = y2 - y1;
          r2.width = x2 - x1;
          r2.x = x1;
          r2.y = y1;
          break;
        }
      }

      if (intersects) {
        if (r1.width >= minDimension && r1.height >= minDimension) {
          if (r1.width <= maxDimension && r1.height <= maxDimension) {
            results.push(r1);
          }
        }
      }
    }

    return results;
  };

tracking.ColorTracker.prototype.calculateDimensions=函数（云，总计）{
var maxx=-1；
var maxy=-1；
var minx=无穷大；
var miny=无穷大；
对于（var c=0；cmaxx）{
maxx=x；
}
if（ymaxy）{
maxy=y；
}
}
返回{
宽度：maxx-minx，
身高：maxy-miny，
x:minx，
y:米尼
};
};
/**
*获取“ColorTracker”实例正在跟踪的颜色。
*@return{Array.}
*/
tracking.ColorTracker.prototype.getColors=函数（）{
返回此文件。颜色；
};
/**
*获取对矩形进行分类的最小维度。
*@return{number}
*/
tracking.ColorTracker.prototype.GetMindImmension=函数（）{
返回此.minDimension；
};
/**
*获取对矩形进行分类的最大维度。
*@return{number}
*/
tracking.ColorTracker.prototype.getMaxDimension=函数（）{
返回此.maxDimension；
};
/**
*获取要分类为矩形的最小组大小。
*@return{number}
*/
tracking.ColorTracker.prototype.getMinGroupSize=函数（）{
返回此.minGroupSize；
};
/**
*获取像素周围相邻像素的八个偏移值。
*@param{number}width图像宽度。
*@return{array}数组，具有相邻数组的八个偏移量值
*围绕一个像素。
*@私人
*/
tracking.ColorTracker.prototype.getNeighboursForWidth=函数（宽度）{
if（tracking.ColorTracker.neights[width]）{
返回tracking.ColorTracker.neights[width]；
}
var邻居=新的Int32Array（8）；
邻域[0]=-宽度*4；
邻居[1]=-宽度*4+4；
邻居[2]=4；
邻居[3]=宽度*4+4；
邻居[4]=宽度*4；
邻居[5]=宽度*4-4；
邻居[6]=-4；
邻居[7]=-宽度*4-4；
tracking.ColorTracker.neights_u[width]=neights；
返回邻居；
};
/**
*统一边界框彼此相交的组。
*@param{Array.}rects
*@私人
*/
tracking.ColorTracker.prototype.mergeRectangles=函数（矩形）{
var相交；
var结果=[]；
var minDimension=this.getMinDimension（）；
var maxDimension=this.getMaxDimension（）；
for（var r=0；r=MindDimension和&r1.height>=MindDimension）{
如果（r1.width我怀疑本机客户端在不重构应用程序的情况下是否会有所帮助；从画布读取像素、将其发送到NaCl、处理数据以及将结果发送回的开销可能会很慢。通常，当处理量非常大时，这种权衡是值得的；我不清楚在这里就是这样。有道理，谢谢。