NodeJS/Javascript-使用承诺处理图像收集，然后保存聚合结果

库存过剩-

我正在尝试使用NodeJS处理一个图像集合（~2000个图像）。我能够提取所需的信息，但我很难把握好时机，以便将结果保存到

JSON

文件中

到最后你会看到

console.log(palette);
// Push single image data to output array.
output.push(palette);

console.log

工作正常，但是

push

方法似乎是在空的

output

数组写入

data.json

后执行的。尝试使用嵌套承诺，在处理完所有图像之前，我不会编写文件

getPixels中的回调函数异步执行

输出数组的顺序是任意的

非常感谢所有的帮助！谢谢大家!

// Extract color information from all images in imageDirectory

var convert   = require('color-convert'),
    fs        = require('fs'),
    getPixels = require("get-pixels"),
    startTime = Date.now();

var processedImages = new Promise((resolve, reject) => {
  var imageDirectory = 'input',
      images         = fs.readdirSync(imageDirectory),
      output         = [];

  console.log('Found ' + images.length + ' images.');

  for (var image in images) {
    var imageLoaded = new Promise((resolve, reject) => {
      getPixels(imageDirectory + '/' + images[image], function(error, pixels) {
        if(error) {
          return 'Bad image path';
        }
        resolve(pixels);
      });
    });

    imageLoaded.then((pixels) => {
      var palette = {
        coloredPixels  : 0,
        hues           : [],
        image          : images[image],
        classification : false,
        pixelCount     : null
      };

      palette.pixelCount = pixels.shape[0] *
                           pixels.shape[1] *
                           pixels.shape[2];

      for (var i = 0; i < 256; i++) {
        palette.hues[i] = 0;
      }

      for (var i = 0; i < palette.pixelCount; i += 4) {
        var rgb        = [pixels.data[i    ],
                          pixels.data[i + 1],
                          pixels.data[i + 2]],
            hsl        = convert.rgb.hsl(rgb),
            hue        = hsl[0],
            saturation = hsl[1];

        if (saturation) {
          palette.hues[hue]++;
          palette.coloredPixels++;
        }
      }
      console.log(palette);
      // Push single image data to output array.
      output.push(palette);
    });
  }
  resolve(output);
});

processedImages.then((output) => {
  // write output array to data.json
  var json = JSON.stringify(output, null, 2); 
  fs.writeFileSync('data.json', json);

  // Calculate time spent
  var endTime = Date.now();
  console.log('Finished in ' + (endTime - startTime) / 1000 + ' seconds.');
});

//从imageDirectory中的所有图像中提取颜色信息
var convert=require（'color-convert'），
fs=需要（'fs'），
getPixels=require（“获取像素”），
startTime=Date.now（）；
var processedImages=新承诺（（解决、拒绝）=>{
var imageDirectory='input'，
images=fs.readdirSync（imageDirectory），
输出=[]；
log（'Found'+images.length+'images'）；
用于（图像中的var图像）{
var imageLoaded=新承诺（（解决、拒绝）=>{
getPixels（imageDirectory+'/'+图像[image]，函数（错误，像素）{
如果（错误）{
返回“坏映像路径”；
}
分辨率（像素）；
});
});
图像加载。然后（（像素）=>{
变量调色板={
彩色像素：0，
色调：[]，
图像：图像[图像]，
分类：假，
像素计数：空
};
palete.pixelCount=像素。形状[0]*
像素。形状[1]*
像素。形状[2]；
对于（变量i=0；i<256；i++）{
色调[i]=0；
}
对于（变量i=0；i{
//将输出数组写入data.json
var json=json.stringify（输出，null，2）；
fs.writeFileSync（'data.json'，json）；
//计算花费的时间
var endTime=Date.now（）；
log（'在'+（endTime-startTime）/1000+'秒内完成'）；
});

您要做的是将一组“图像”转换为一组承诺，然后等待解析，然后执行更多转换。把它看作是一系列的转换，因为这就是你在这里要做的。简言之：

const imagePromises = images.map(image => new Promise(resolve, reject) {
  getPixels(imageDirectory + '/' + image, (error, pixels) => {
    if(error) {
      reject('Bad image path');
      return;
    }
    resolve(pixels);
  });

const output = Promise.all(imagePromises).then(results => 
 results.map(pixels => { 
  return { 
    // do your crazy palette stuff (build a palette object) 
  };
});

---

您要做的是将一组“图像”转换为一组承诺，然后等待解析，然后执行更多转换。把它看作是一系列的转换，因为这就是你在这里要做的。简言之：

const imagePromises = images.map(image => new Promise(resolve, reject) {
  getPixels(imageDirectory + '/' + image, (error, pixels) => {
    if(error) {
      reject('Bad image path');
      return;
    }
    resolve(pixels);
  });

const output = Promise.all(imagePromises).then(results => 
 results.map(pixels => { 
  return { 
    // do your crazy palette stuff (build a palette object) 
  };
});

---

---

对于（图像中的var图像）{

解析（输出）；

在循环结束时，因此基本上你可以立即解析。你需要使用

Promise。所有
而不是
新的Promise
围绕该循环。你的
图像
变量
你需要使用Promise。所有
希望图像不会太大。。（~2000个图像）感谢大家的投入。我正在尝试实现Andy的解决方案。图像为256x256px，平均每个约50KB。
for（图像中的var图像）{
resolve（输出）
在循环结束时，基本上你可以立即解析。你需要使用
Promise。所有的
而不是
新的Promise
围绕这个循环。你的
图像
变量
你需要使用Promise。所有的
希望图像不要太大。（~2000张图像）谢谢大家的意见。我正在尝试实现Andy的解决方案。图像是256x256px，平均每个约50KB。我不明白为什么不，但你可以将大量承诺分解成块。
我不明白为什么不，
有人和你的代表，我想你会……是的，分解成块等等，甚至只是这样做线性。不管怎么说，OP说每个都只有50K，所以这不是一个真正的问题，把它们变成7兆肯定会引起问题。这个问题不是关于如何扩展解决方案-这是一个不同的问题。手头的问题是理解如何处理多个承诺。
这是一个不同的问题，你可以刚刚介绍。不管怎样，我知道这是怎么回事。期待着你的回答，我的兄弟。我不知道为什么不，但你可以把大量的承诺分成几块。
我不知道为什么不，
你的代表，我想你会。。是的，分成几块等等。甚至只是线性地做。无论如何，OP说每个都只有5万，所以不是联合一个问题，将它们变成7兆肯定会引起问题。这个问题不是关于如何扩展解决方案-这是一个不同的问题。手头的问题是理解如何使用多个承诺。
这是一个不同的问题，你可以刚刚介绍。无论如何，我可以看到这是怎么回事。正在寻找听你的回答，伙计。