Настраиваемый фильтр изображений

Первое, что нужно сделать - профилировать (измерить затраты времени на разные части вашей функции). Это часто показывает, что время тратится в неожиданном месте, и всегда подсказывает, куда направить усилия по оптимизации. Это не означает, что вы должны сосредоточиться на этом, наиболее трудоемком деле, но он покажет вам, на что вы тратите время. К сожалению, я не знаком со Swift, поэтому не могу рекомендовать какой-либо конкретный инструмент.

Что касается перебора всех пикселей - зависит от структуры изображения и ваших предположений о входных данных. Я вижу два случая, когда этого можно избежать:

1. Когда на вашем изображении построена некоторая оптимизированная структура данных (например, некоторая статистика в ее областях). Обычно это имеет смысл, когда вы обрабатываете одно и то же изображение одним и тем же (или похожим) алгоритмом с разными параметрами. Если вы обрабатываете каждое изображение только один раз, скорее всего, это вам не поможет.

2. Когда вы знаете, что зеленые пиксели всегда существуют в группе, поэтому не может быть изолированного единственного пикселя. В этом случае вы можете пропустить один или несколько пикселей и, обнаружив зеленый пиксель, проанализировать его окрестности.

Я не пишу код на вашей платформе, но ...

Что ж, я предполагаю, что ваши замаскированные области (определенного цвета) непрерывны и достаточно велики ... это означает, что у вас есть группы пикселей вместе с достаточно большими областями (а не просто вещи толщиной в несколько пикселей). Исходя из этого предположения, вы можете создать карту плотности для своего цвета. Что я имею в виду, если минимальный размер детализации вашего конкретного цветового материала составляет 10 пикселей, вы можете проверять каждый 8-й пиксель на каждой оси, ускоряя начальное сканирование ~ 64 раза. А затем используйте полное сканирование только для областей, содержащих ваш цвет. Вот что вам нужно сделать:

1. определить свойства

   Вам нужно установить шаг для каждой оси (сколько пикселей вы можете пропустить, не пропуская цветную зону). Назовем это dx, dy.

2. создать карту плотности

   просто создайте 2D-массив, который будет содержать информацию, если центральный пиксель области установлен с вашим конкретным цветом. поэтому, если ваше изображение имеет разрешение xs,ys, ваша карта будет:

   int mx=xs/dx;
   int my=ys/dy;
   int map[mx][my],x,y,xx,yy;
   
   for (yy=0,y=dy>>1;y<ys;y+=dy,yy++)
    for (xx=0,x=dx>>1;x<xs;x+=dx,xx++)
     map[xx][yy]=compare(pixel(x,y) , specific_color)<threshold;
   

3. увеличить области набора карты

   теперь вы должны увеличить установленные области в map[][] до соседних ячеек, потому что # 2 может пропустить край вашей цветовой области.

4. обработать все заданные регионы

   for (yy=0;yy<my;yy++)
    for (xx=0;xx<mx;xx++)
     if (map[xx][yy])
      for (y=yy*dy,y<(yy+1)*dy;y++)
       for (x=xx*dx,x<(xx+1)*dx;x++)
        if (compare(pixel(x,y) , specific_color)>=threshold) pixel(x,y)=0x00000000;
   

Если вы хотите ускорить это даже больше, чем вам нужно для обнаружения набора ячеек map[][], которые находятся на границе (имеют хотя бы одного нулевого соседа), вы можете различать ячейки следующим образом:

0 - no specific color is present
1 - inside of color area
2 - edge of color area

Это можно сделать просто в O(mx*my). После этого вам нужно проверить цвет только краевых областей, поэтому:

for (yy=0;yy<my;yy++)
 for (xx=0;xx<mx;xx++)
  if (map[xx][yy]==2)
   {
   for (y=yy*dy,y<(yy+1)*dy;y++)
    for (x=xx*dx,x<(xx+1)*dx;x++)
     if (compare(pixel(x,y) , specific_color)>=threshold) pixel(x,y)=0x00000000;
   } else if (map[xx][yy]==0)
   {
   for (y=yy*dy,y<(yy+1)*dy;y++)
    for (x=xx*dx,x<(xx+1)*dx;x++)
     pixel(x,y)=0x00000000;
   }

Это должно быть еще быстрее. Если разрешение вашего изображения xs,ys не кратно размеру области mx,my, вам следует обработать внешний край изображения либо нулевым заполнением, либо специальными циклами для этой недостающей части изображения ...

Кстати, сколько времени нужно, чтобы прочитать и установить все изображение?

for (y=0;y<ys;y++)
 for (x=0;x<xs;x++)
  pixel(x,y)=pixel(x,y)^0x00FFFFFF;

если только это работает медленно, это означает, что ваш доступ к пикселям слишком медленный, и вы должны использовать для этого другой api. Это очень распространенная ошибка на платформе Windows GDI, поскольку люди обычно используют Pixels[][], который работает медленнее, чем ползучая улитка. есть и другие способы, такие как битовая блокировка / блиттинг, ScanLine и т. д., поэтому в таком случае вам нужно быстро найти что-то на своей платформе. Если вы не можете ускорить даже этот материал, вы не можете делать ничего другого ... кстати, на каком HW это работает?