Масштабирование. Алгоритм Уменьшения и Увеличения изображения

В этой статье я хочу затронуть проблемы построения алгоритмов масштабирования изображения.

Наверняка когда вы пытались найти алгоритмы масштабирована вы находили в первую что-то вроде: Существуют несколько алгоритмов самое простое это алгоритм Ближайший сосед потом билинейная , бикубическая интерполяция и.т.д

И какие могут быть проблемы?

Первая проблема

Ну начнем с того, что по сути своей реализует масштабирована только алгоритм Ближайшего соседа, оставшиеся лишь реализуют сглаживание более пикселизированого и грубого изображения полученного таким способом. Нет вы конечно можете реализовать другие алгоритмы и без Ближайшего соседа, только ваш алгоритмом будет встроен тот же принцип.

Вторая проблема

Прекрасно казалось бы всё мы используем алгоритмом ближайшего соседа, поверх используем какую-нибудь интерполяцию либо функцию Ланцоша и воля, у нас все хорошо. Хорошо до того момента как мы не уменьшаем изображение и получаем это.

Конечно после этого мы начнем искать решение проблемы. Будем использовать разные фильтры, несколько циклов поэтапного уменьшения и всё рано получим тот же ужасный результат.

А почему? Да потому, что сам принцип алгоритма Ближайший сосед, не является верным для уменьшения изображения.

Я приведу аналогию: Перед нами стоит яблок так, что мы видим, что оно состоит из сочетания зеленого и красного цвета, мы отходим на значительное расстояние и видим что наша яблоко перестаёт быть зелено-красным и теперь оно жёлтое. И почему так произошло, да потому, что яблоко теперь в меньшом площади обозрения и зелёный с красным цветом смешиваются становясь одним желтым цветом.

Как понимаете алгоритмом Ближайший сосед не способен обеднять информацию, он лишь выборочно предаёт те или иные цвета. Как если бы в дали яблоко виделось бы нам только зеленом или красном цвете. Иза этого при использование алгоритма изображение оказывается рваным.

Если это так то как передать информацию полностью, обледенив её. Я думаю, что кто-то уже догадался, что мы можем все пиксели попадающие в одну ячейку массива, просто привести к среднему цвету.

Вот пример алгоритма на C#

  public static Color[,] ConvertImage(Color[,] image, double percentageValue)
  {
      int width = (int)Math.Round(image.GetLength(0) * percentageValue);
      int height = (int)Math.Round(image.GetLength(1) * percentageValue);
  
      double[,,] valuesSum = new double[width, height, 4];
      int[,] quantities = new int[width, height];
  
  
      for (int y = 0; y < image.GetLength(0); y++)
      {
          int y2 = (int)Math.Ceiling(y * percentageValue);
  
          if (y2 >= width)
              y2 = width - 1;
  
          for (int x = 0; x < image.GetLength(1); x++)
          {
              int x2 = (int)Math.Ceiling(x * percentageValue);
  
              if (x2 >= height)
                  x2 = height - 1;
  
              valuesSum[y2, x2, 0] += image[y, x].A;
              valuesSum[y2, x2, 1] += image[y, x].R;
              valuesSum[y2, x2, 2] += image[y, x].G;
              valuesSum[y2, x2, 3] += image[y, x].B;
  
              quantities[y2, x2]++;
          }
      }
  
      Color[,] newImage = new Color[width, height];
  
      for (int y = 0; y < newImage.GetLength(0); y++)
      {
          for (int x = 0; x < newImage.GetLength(1); x++)
          {
              int A = (int)(valuesSum[y, x, 0] / quantities[y, x]);
              int R = (int)(valuesSum[y, x, 1] / quantities[y, x]);
              int G = (int)(valuesSum[y, x, 2] / quantities[y, x]);
              int B = (int)(valuesSum[y, x, 3] / quantities[y, x]);
  
              newImage[y, x] = Color.FromArgb(A, R, G, B);
          }
      }
  
      return newImage;
  }

Результат

Как видите мы получили совершено иной итог.

И хотелось ещё добавить что, при увеличение наша изображение мы можем применить те же заглаживающие алгоритмы.