تأثيرات في الوقت الفعلي للصور والفيديوهات

Mat Scales

تتيح لك العديد من التطبيقات الأكثر رواجًا اليوم تطبيق الفلاتر والتأثيرات على الصور أو الفيديوهات. توضّح هذه المقالة كيفية تنفيذ هذه الميزات على الويب المفتوح.

العملية هي نفسها بشكل أساسي للفيديوهات والصور، ولكن سأتناول بعض الاعتبارات المهمة المتعلقة بالفيديو في النهاية. في هذه المقالة، يمكنك افتراض أنّ كلمة "صورة" تعني "صورة أو إطار واحد من فيديو".

كيفية الوصول إلى بيانات وحدات البكسل لصورة

هناك 3 فئات أساسية شائعة للتلاعب بالصور:

  • تأثيرات Pixel، مثل التباين والسطوع ودفء اللون ودرجة اللون البني الداكن وتشبّع اللون
  • تأثيرات متعددة البكسل، تُسمى فلاتر الالتفاف، مثل زيادة الحدة واكتشاف الحواف والتمويه.
  • تشويه الصورة بأكملها، مثل الاقتصاص أو الانحراف أو التمديد أو تأثيرات العدسة أو التموّج

تتضمن كل هذه الطرق الحصول على بيانات البكسل الفعلية للصورة المصدر ثم إنشاء صورة جديدة منها، والواجهة الوحيدة للقيام بذلك هي لوحة الرسم.

وبالتالي، فإنّ الخيار المهم حقًا هو ما إذا كنت تريد إجراء المعالجة على وحدة المعالجة المركزية (CPU) باستخدام لوحة ثنائية الأبعاد أو على وحدة معالجة الرسومات (GPU) باستخدام WebGL.

لنلقِ نظرة سريعة على الاختلافات بين النهجَين.

لوحة عرض ثنائية الأبعاد

هذا هو بالتأكيد، إلى حد بعيد، أبسط الخيارين. أولاً، ترسم الصورة على لوحة الرسم.

const source = document.getElementById('source-image');

// Create the canvas and get a context
const canvas = document.createElement('canvas');
const context = canvas.getContext('2d');

// Set the canvas to be the same size as the original image
canvas.width = source.naturalWidth;
canvas.height = source.naturalHeight;

// Draw the image onto the top-left corner of the canvas
context.drawImage(theOriginalImage, 0, 0);

بعد ذلك، ستحصل على مصفوفة من قيم وحدات البكسل للّوحة بأكملها.

const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
const pixels = imageData.data;

في هذه المرحلة، يكون المتغيّر pixels عبارة عن Uint8ClampedArray بطول width * height * 4. كل عنصر في الصفيفة هو بايت واحد، وكل أربعة عناصر في الصفيفة تمثل لون بكسل واحد. يمثّل كل عنصر من العناصر الأربعة مقدار اللون الأحمر والأخضر والأزرق والألفا (الشفافية) بهذا الترتيب. يتم ترتيب وحدات البكسل بدءًا من أعلى اليمين ومن اليسار إلى اليمين ومن الأعلى إلى الأسفل.

pixels[0] = red value for pixel 0
pixels[1] = green value for pixel 0
pixels[2] = blue value for pixel 0
pixels[3] = alpha value for pixel 0
pixels[4] = red value for pixel 1
pixels[5] = green value for pixel 1
pixels[6] = blue value for pixel 1
pixels[7] = alpha value for pixel 1
pixels[8] = red value for pixel 2
pixels[9] = green value for pixel 2
pixels[10] = blue value for pixel 2
pixels[11] = alpha value for pixel 2
pixels[12] = red value for pixel 3
...

للعثور على فهرس أي بكسل معيّن من إحداثياته، هناك صيغة بسيطة.

const index = (x + y * imageWidth) * 4;
const red = pixels[index];
const green = pixels[index + 1];
const blue = pixels[index + 2];
const alpha = pixels[index + 3];

يمكنك الآن قراءة هذه البيانات وكتابتها بالطريقة التي تريدها، ما يتيح لك تطبيق أي تأثيرات تخطر ببالك. ومع ذلك، فإنّ هذه المصفوفة هي نسخة من بيانات وحدات البكسل الفعلية للّوحة. لكتابة النسخة المعدَّلة، عليك استخدام طريقة putImageData لكتابتها في أعلى يمين اللوحة

context.putImageData(imageData, 0, 0);

WebGL

‫WebGL هو موضوع كبير، ومن المؤكد أنّه كبير جدًا بحيث لا يمكن تناوله بشكل كافٍ في مقالة واحدة. إذا أردت معرفة المزيد من المعلومات حول WebGL، يمكنك الاطّلاع على القراءة المقترَحة في نهاية هذه المقالة.

ومع ذلك، إليك مقدمة موجزة للغاية عما يجب القيام به في حالة معالجة صورة واحدة.

من أهم الأمور التي يجب تذكّرها بشأن WebGL أنّها ليست واجهة برمجة تطبيقات للرسومات الثلاثية الأبعاد. في الواقع، WebGL (وOpenGL) جيد في شيء واحد بالضبط - رسم المثلثات. في تطبيقك، عليك وصف ما تريد رسمه فعليًا باستخدام المثلثات. في حالة الصورة ثنائية الأبعاد، يكون الأمر بسيطًا للغاية، لأن المستطيل عبارة عن مثلثين متشابهين قائمي الزاوية، مرتبين بحيث تكون أوتارهما في نفس المكان.

العملية الأساسية هي:

  • أرسِل البيانات إلى وحدة معالجة الرسومات التي تصف رؤوس (نقاط) المثلثات.
  • أرسِل الصورة المصدر إلى وحدة معالجة الرسومات كبنية (صورة).
  • أنشئ "مُظلِّل رأس".
  • أنشئ "مُظلِّل أجزاء".
  • اضبط بعض متغيّرات التظليل، والتي تُعرف باسم "المتغيّرات الموحّدة".
  • شغِّل أدوات التظليل.

لنتعمّق في التفاصيل. نبدأ بتخصيص بعض الذاكرة على بطاقة الرسومات تُسمى مخزن الرؤوس المؤقت. وتخزّن فيه البيانات التي تصف كل نقطة من كل مثلّث. يمكنك أيضًا ضبط بعض المتغيّرات، تُسمّى "المتغيّرات الموحّدة"، وهي قيم عامة في كلا برنامجي التظليل.

يستخدم مظلل الرؤوس البيانات من مخزن الرؤوس المؤقت لحساب مكان رسم النقاط الثلاث لكل مثلث على الشاشة.

الآن، تعرف وحدة معالجة الرسومات وحدات البكسل التي يجب رسمها داخل اللوحة. يتم استدعاء أداة تظليل الأجزاء مرة واحدة لكل بكسل، ويجب أن تعرض اللون الذي يجب رسمه على الشاشة. يمكن لمظلّل الأجزاء قراءة المعلومات من مادة واحدة أو أكثر لتحديد اللون.

عند قراءة مادة في تظليل جزء، يمكنك تحديد الجزء الذي تريد قراءته من الصورة باستخدام إحداثيين للفاصلة العائمة بين 0 (يسار أو أسفل) و1 (يمين أو أعلى).

إذا أردت قراءة النسيج استنادًا إلى إحداثيات البكسل، عليك تمرير حجم النسيج بالبكسل كمتجه موحّد لتتمكّن من إجراء التحويل لكل بكسل.

varying vec2 pixelCoords;

uniform vec2 textureSize;
uniform sampler2D textureSampler;

main() {
  vec2 textureCoords = pixelCoords / textureSize;
  vec4 textureColor = texture2D(textureSampler, textureCoords);
  gl_FragColor = textureColor;
 }
Pretty much every kind of 2D image manipulation that you might want to do can be done in the
fragment shader, and all of the other WebGL parts can be abstracted away. You can see [the
abstraction layer](https://github.com/GoogleChromeLabs/snapshot/blob/master/src/filters/image-shader.ts) (in
TypeScript) that is being in used in one of our sample applications if you'd like to see an example.

### Which should I use?

For pretty much any professional quality image manipulation, you should use WebGL. There is no
getting away from the fact that this kind of work is the whole reason GPUs were invented. You can
process images an order of magnitude faster on the GPU, which is essential for any real-time
effects.

The way that graphics cards work means that every pixel can be calculated in it's own thread. Even
if you parallelize your code CPU-based code with `Worker`s, your GPU may have 100s of times as many
specialized cores as your CPU has general cores.

2D canvas is much simpler, so is great for prototyping and may be fine for one-off transformations.
However, there are plenty of abstractions around for WebGL that mean you can get the performance
boost without needing to learn the details.

Examples in this article are mostly for 2D canvas to make explanations easier, but the principles
should translate pretty easily to fragment shader code.

## Effect types

### Pixel effects

This is the simplest category to both understand and implement. All of these transformations take
the color value of a single pixel and pass it into a function that returns another color value.

There are many variations on these operations that are more or less complicated. Some will take into
account how the human brain processes visual information based on decades of research, and some will
be dead simple ideas that give an effect that's mostly reasonable.

For example, a brightness control can be implemented by simply taking the red, green and blue values
of the pixel and multiplying them by a brightness value. A brightness of 0 will make the image
entirely black. A value of 1 will leave the image unchanged. A value greater than 1 will make it
brighter.

For 2D canvas:

```js
const brightness = 1.1; // Make the image 10% brighter
for (let i = 0; i < imageData.data.length; i += 4) {
  imageData.data[i] = imageData.data[i] * brightness;
  imageData.data[i + 1] = imageData.data[i + 1] * brightness;
  imageData.data[i + 2] = imageData.data[i + 2] * brightness;
}

يُرجى العِلم أنّ الحلقة تنقل 4 بايت في كل مرة، ولكنّها تغيّر ثلاث قيم فقط، لأنّ هذا التحويل تحديدًا لا يغيّر قيمة ألفا. يُرجى أيضًا تذكُّر أنّ Uint8ClampedArray ستقرّب جميع القيم إلى أعداد صحيحة، وتثبّت القيم لتكون بين 0 و255.

مُظلِّل أجزاء WebGL:

    float brightness = 1.1;
    gl_FragColor = textureColor;
    gl_FragColor.rgb *= brightness;

وبالمثل، يتم ضرب جزء RGB فقط من لون الإخراج لهذا التحويل المعين.

تتطلّب بعض هذه الفلاتر معلومات إضافية، مثل متوسط الإضاءة للصورة بأكملها، ولكن يمكن احتساب هذه المعلومات مرة واحدة للصورة بأكملها.

على سبيل المثال، تتمثّل إحدى طرق تغيير التباين في تحريك كل بكسل باتجاه قيمة "رمادية" معيّنة أو بعيدًا عنها، للحصول على تباين أقل أو أعلى على التوالي. يتم اختيار القيمة الرمادية عادةً لتكون لونًا رماديًا يكون سطوعه هو متوسط سطوع جميع وحدات البكسل في الصورة.

يمكنك احتساب هذه القيمة مرة واحدة عند تحميل الصورة، ثم استخدامها في كل مرة تحتاج فيها إلى تعديل تأثير الصورة.

متعددة البكسل

تستخدم بعض التأثيرات لون وحدات البكسل المجاورة عند تحديد لون وحدة البكسل الحالية.

يؤدي ذلك إلى تغيير طريقة تنفيذ الإجراءات في لوحة الرسم الثنائية الأبعاد قليلاً لأنّك تريد أن تكون قادرًا على قراءة الألوان الأصلية للصورة، وكان المثال السابق يحدّث وحدات البكسل في مكانها.

ومع ذلك، هذا سهل بما فيه الكفاية. عند إنشاء كائن بيانات الصورة في البداية، يمكنك إنشاء نسخة من البيانات.

const originalPixels = new Uint8Array(imageData.data);

بالنسبة إلى WebGL، ليس عليك إجراء أي تغييرات، لأنّ برنامج التظليل لا يكتب في مادة الإدخال.

تُعرف الفئة الأكثر شيوعًا من التأثيرات المتعددة البكسل باسم الفلتر الالتفافي. يستخدم الفلتر الالتفافي عدة وحدات بكسل من الصورة المُدخلة لاحتساب لون كل بكسل في الصورة المُدخلة. يُطلق على مستوى تأثير كل بكسل في الإدخال على الإخراج اسم الوزن.

يمكن تمثيل الأوزان بمصفوفة، تسمى النواة، مع القيمة المركزية المقابلة للبكسل الحالي. على سبيل المثال، هذه هي النواة لتمويه غاوسي 3x3.

    | 0  1  0 |
    | 1  4  1 |
    | 0  1  0 |

لنفترض أنّك تريد حساب لون الناتج للبكسل عند (23, 19). خذ 8 بكسل المحيطة (23، 19) وكذلك البكسل نفسه، واضرب قيم اللون لكل منها بالوزن المقابل.

    (22, 18) x 0    (23, 18) x 1    (24, 18) x 0
    (22, 19) x 1    (23, 19) x 4    (24, 19) x 1
    (22, 20) x 0    (23, 20) x 1    (24, 20) x 0

اجمعها معًا ثم اقسم النتيجة على 8، وهو مجموع الأوزان. يمكنك أن ترى كيف ستكون النتيجة بكسل هو في الغالب الأصلي، ولكن مع نزيف البكسل القريب.

const kernel = [
  [0, 1, 0],
  [1, 4, 1],
  [0, 1, 0],
];

for (let y = 0; y < imageHeight; y++) {
  for (let x = 0; x < imageWidth; x++) {
    let redTotal = 0;
    let greenTotal = 0;
    let blueTotal = 0;
    let weightTotal = 0;
    for (let i = -1; i <= 1; i++) {
      for (let j = -1; j <= 1; j++) {
        // Filter out pixels that are off the edge of the image
        if (
          x + i > 0 &&
          x + i < imageWidth &&
          y + j > 0 &&
          y + j < imageHeight
        ) {
          const index = (x + i + (y + j) * imageWidth) * 4;
          const weight = kernel[i + 1][j + 1];
          redTotal += weight * originalPixels[index];
          greenTotal += weight * originalPixels[index + 1];
          blueTotal += weight * originalPixels[index + 2];
          weightTotal += weight;
        }
      }
    }

    const outputIndex = (x + y * imageWidth) * 4;
    imageData.data[outputIndex] = redTotal / weightTotal;
    imageData.data[outputIndex + 1] = greenTotal / weightTotal;
    imageData.data[outputIndex + 2] = blueTotal / weightTotal;
  }
}

يقدّم هذا المثال فكرة أساسية، ولكن هناك أدلة تقدّم تفاصيل أكثر وتدرج العديد من النواة المفيدة الأخرى.

الصورة بأكملها

بعض عمليات تحويل الصور بالكامل بسيطة. في لوحة العرض الثنائية الأبعاد، يُعدّ الاقتصاص وتغيير الحجم أمرًا بسيطًا يتمثّل في رسم جزء فقط من الصورة المصدر على اللوحة.

// Set the canvas to be a little smaller than the original image
canvas.width = source.naturalWidth - 100;
canvas.height = source.naturalHeight - 100;

// Draw only part of the image onto the canvas
const sx = 50; // The left-most part of the source image to copy
const sy = 50; // The top-most part of the source image to copy
const sw = source.naturalWidth - 100; // How wide the rectangle to copy is
const sh = source.naturalHeight - 100; // How tall the rectangle to copy is

const dx = 0; // The left-most part of the canvas to draw over
const dy = 0; // The top-most part of the canvas to draw over
const dw = canvas.width; // How wide the rectangle to draw over is
const dh = canvas.height; // How tall the rectangle to draw over is

context.drawImage(theOriginalImage, sx, sy, sw, sh, dx, dy, dw, dh);

يتوفّر التدوير والانعكاس مباشرةً في السياق الثنائي الأبعاد. قبل رسم الصورة في اللوحة، قم بتغيير التحويلات المختلفة.

// Move the canvas so that the center of the canvas is on the Y-axis
context.translate(-canvas.width / 2, 0);

// An X scale of -1 reflects the canvas in the Y-axis
context.scale(-1, 1);

// Rotate the canvas by 90°
context.rotate(Math.PI / 2);

والأهم من ذلك، يمكن كتابة العديد من التحويلات الثنائية الأبعاد كمصفوفات 2x3 وتطبيقها على اللوحة باستخدام setTransform(). يستخدم هذا المثال مصفوفة تجمع بين الدوران والتحويل.

const matrix = [
  Math.cos(rot) * x1,
  -Math.sin(rot) * x2,
  tx,
  Math.sin(rot) * y1,
  Math.cos(rot) * y2,
  ty,
];

context.setTransform(
  matrix[0],
  matrix[1],
  matrix[2],
  matrix[3],
  matrix[4],
  matrix[5],
);

تتضمن التأثيرات الأكثر تعقيدًا، مثل تشويه العدسة أو التموجات، تطبيق بعض الإزاحة على كل إحداثي وجهة لحساب إحداثيات البكسل المصدر. على سبيل المثال، للحصول على تأثير موجة أفقي، يمكنك إزاحة الإحداثي السيني للبكسل المصدر بقيمة ما بناءً على الإحداثي الصادي.

for (let y = 0; y < canvas.height; y++) {
  const xOffset = 20 * Math.sin((y * Math.PI) / 20);
  for (let x = 0; x < canvas.width; x++) {
    // Clamp the source x between 0 and width
    const sx = Math.min(Math.max(0, x + xOffset), canvas.width);

    const destIndex = (y * canvas.width + x) * 4;
    const sourceIndex = (y * canvas.width + sx) * 4;

    imageData.data[destIndex] = originalPixels.data[sourceIndex];
    imageData.data[destIndex + 1] = originalPixels.data[sourceIndex + 1];
    imageData.data[destIndex + 2] = originalPixels.data[sourceIndex + 2];
  }
}

فيديو

وكل ما ورد في المقالة ينطبق على الفيديو إذا استخدمت عنصر video كصورة المصدر.

Canvas 2D:

context.drawImage(<strong>video</strong>, 0, 0);

‫WebGL:

gl.texImage2D(
  gl.TEXTURE_2D,
  0,
  gl.RGBA,
  gl.RGBA,
  gl.UNSIGNED_BYTE,
  <strong>video</strong>,
);

ومع ذلك، سيتم استخدام إطار الفيديو الحالي فقط. لذا، إذا أردت تطبيق تأثير على فيديو قيد التشغيل، عليك استخدام drawImage/texImage2D على كل إطار للحصول على إطار فيديو جديد ومعالجته على كل إطار متحرك في المتصفح.

const draw = () => {
  requestAnimationFrame(draw);

  context.drawImage(video, 0, 0);

  // ...image processing goes here
};

عند العمل مع الفيديو، يصبح من المهم بشكل خاص أن تكون المعالجة سريعة. في حالة الصورة الثابتة، قد لا يلاحظ المستخدم تأخيرًا بمقدار 100 ملي ثانية بين النقر على زر وتطبيق التأثير. ومع ذلك، عند استخدام الصور المتحركة، يمكن أن يؤدي التأخير لمدة 16 ملي ثانية فقط إلى حدوث اهتزاز مرئي.

الملاحظات