Документация Engee

Функции фильтрации

Функции

imfilter([T], img, kernel, [border="replicate"], [alg]) --> imgfilt
imfilter([r], img, kernel, [border="replicate"], [alg]) --> imgfilt
imfilter(r, T, img, kernel, [border="replicate"], [alg]) --> imgfilt

Фильтрует одно-, двух- или многомерный массив img с ядром kernel, вычисляя их корреляцию.

Расширенная справка

Варианты для r

При необходимости можно производить диспетчеризацию в различные реализации, передавая ресурс r согласно определению в пакете ComputationalResources.

Пример:

imfilter(ArrayFireLibs(), img, kernel)

Этот вызов запрашивает выполнение вычислений на GPU с использованием библиотек ArrayFire.

Варианты для T

При необходимости можно контролировать тип элементов выходного изображения, передавая тип T первым аргументом.

Варианты для img

Изображение можно передать в виде одно-, двух- или многомерного массива.

Варианты для kernel

Параметр kernel[0, 0,..] соответствует началу (нулевому смещению) ядра. С помощью centered можно установить начало в центре массива. Можно также воспользоваться пакетом OffsetArrays для задания индексов kernel вручную. Например, отфильтровать случайное отцентрированное ядро размером 3x3 можно одним из следующих способов.

kernel = centered(rand(3,3))
kernel = OffsetArray(rand(3,3), -1:1, -1:1)

Параметр kernel можно задать в виде массива или «разложенного ядра», то есть кортежа (filt1, filt2, ...) фильтров, которые будут применены по каждой оси изображения. Если известно, что ядро является разделяющимся, такой формат может ускорить обработку. Каждый фильтр должен быть той же размерности, что и само изображение, и иметь форму, указывающую на ось фильтрации, например фильтр 3x1 для фильтрации первого измерения или фильтр 1x3 для фильтрации второго измерения. В случае с двумя измерениями любое ядро, передаваемое в виде одиночной матрицы, проверяется на разделяемость; чтобы эта проверка не проводилась, передайте ядро в виде одноэлементного кортежа: (kernel,).

Варианты для border

С помощью аргумента border указывается способ дополнения для экстраполяции изображения за пределами его исходных границ.

"replicate" (по умолчанию)

Пиксели границы продолжаются за границами изображения.

   ╭────┏━━━━━━┓────╮
   │aaaa┃abcdef┃ffff│
   ╰────┗━━━━━━┛────╯

"circular"

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

   ╭────┏━━━━━━┓────╮
   │cdef┃abcdef┃abcd│
   ╰────┗━━━━━━┛────╯

"reflect"

Пиксели границы отражаются относительно позиции между пикселями. Пиксель границы при этом опускается.

   ╭────┏━━━━━━┓────╮
   │dcba┃abcdef┃fedc│
   ╰────┗━━━━━━┛────╯

"symmetric"

Пиксели границы отражаются относительно края изображения.

   ╭────┏━━━━━━┓────╮
   │edcb┃abcdef┃edcb│
   ╰────┗━━━━━━┛────╯

Fill(m)

Пиксели границы заполняются указанным значением .

   ╭────┏━━━━━━┓────╮
   │mmmm┃abcdef┃mmmm│
   ╰────┗━━━━━━┛────╯

Inner()

Указывает, что края при фильтрации должны отбрасываться: возвращается только внутренняя часть результата.

NA()

Выбор фильтрации с использованием граничных условий NA (недоступно). Лучше всего подходит для фильтров только с положительными весами, например фильтров размытия.

См. также описание Pad, padarray, Inner, NA и NoPad.

Варианты для alg

Параметр alg позволяет выбрать алгоритм: Algorithm.FIR() (конечная импульсная характеристика, то есть традиционная цифровая фильтрация) или Algorithm.FFT() (фильтрация методом Фурье). Если алгоритм не указан, он выбирается с учетом размера изображения и ядра так, чтобы обеспечивалась высокая производительность. Помимо этого, можно использовать фильтр пользовательского типа, например KernelFactors.IIRGaussian.

imfilter!(imgfilt, img, kernel, [border="replicate"], [alg])
imfilter!(r, imgfilt, img, kernel, border::Pad)
imfilter!(r, imgfilt, img, kernel, border::NoPad, [inds=axes(imgfilt)])

Фильтрует массив img с ядром kernel, вычисляя их корреляцию, и сохраняет результат в imgfilt.

Индексы imgfilt определяют область, в которой вычисляется отфильтрованное изображение. Это позволяет выбрать определенную область интереса, однако имейте в виду, что входной массив img все равно может дополняться. Можно также явным образом задать индексы inds объекта imgfilt, которые нужно вычислить, и использовать граничные условия NoPad. В этом случае вы отвечаете за правильную настройку дополнения: массив img должен быть индексируемым во всех позициях, которые требуются для вычисления результата. Этот синтаксис лучше всего поддерживается при использовании КИХ-фильтрации, в частности по той причине, что БИХ-фильтрация может давать несогласованные результаты при применении ко всему массиву.

См. также описание функции imfilter.

imgradients(img, kernelfun=KernelFactors.ando3, border="replicate") -> gimg1, gimg2, …​

Оценивает градиент изображения img в направлении первого и второго измерений во всех точках изображения с использованием ядра, указанного в kernelfun.

Возвращает кортеж массивов (gimg1, gimg2, ...), по одному массиву для каждого измерения во входном массиве: gimg1 соответствует производной относительно первого измерения, gimg2 — второго и т. д.

Пример

using Images, ImageFiltering, TestImages
img = testimage("mandrill")
imgr = imgradients(img, KernelFactors.sobel, "reflect")
mosaicview(imgr...)
mapwindow(f::F, img, window;
    border = "replicate",
    indices = default_imginds(img, window, border), callmode=:copy!)

Применяет f к скользящим окнам img с заданным размером окна или осями, определяемыми окном. Например, mapwindow(median!, img, window) возвращает массив значений, сходный с img (естественно, отфильтрованный по медиане), а mapwindow(extrema, img, window) возвращает массив кортежей (минимум, максимум) для окна размера window с центром в каждой точке img.

Функция f принимает буфер buf для окна данных, окружающего текущую точку.

Если аргумент window задан в виде кортежа измерений (целых чисел), все эти целые числа должны быть нечетными, а центром окна является текущая точка изображения.

Например, при window = (3,3) функция f принимает массив buf, соответствующий смещениям (-1:1, -1:1) от точки imgf[i, j], для которой вычисляется функция. Окном может быть также кортеж значений типа AbstractUnitRange. В этом случае в качестве буфера buf применяются указанные диапазоны, что позволяет при необходимости использовать асимметричные окна.

Ограничение вычислений частью изображения

С помощью именованного аргумента indices можно избежать ненужных вычислений, например, если нужно применить функцию mapwindow к части изображения или использовать функцию mapwindow с заданным шагом.

Следующий вызов:

mapwindow(f, img, window, indices=(2:5, 1:2:7))

эффективнее, чем его аналог:

mapwindow(f, img, window)[2:5, 1:2:7]

так как ненужные значения не вычисляются.

Так как данные в буфере buf, принимаемом функцией f, копируются из img и память буфера используется повторно, функция f не должна возвращать ссылки на buf.

Следующий код:

f = buf -> copy(buf) # а не f = buf -> buf
mapwindow(f, img, window, indices=(2:5, 1:2:7))

должен работать, как ожидается.

Для функций, принимающих только объекты типа AbstractVector, может потребоваться сначала специализировать default_shape:

f = v -> quantile(v, 0.75)
ImageFiltering.MapWindow.default_shape(::typeof(f)) = vec

В результате функция mapwindow(f, img, (m, n)) должна выполнять фильтрацию по 75-му квантилю.

См. также описание функции imfilter.

mapwindow!(f, out, img, window; border="replicate", indices=axes(img))

Вариант функции mapwindow с предварительным выделением памяти для результата. Если области памяти для out и img пересекаются, поведение не определено.

Ядро

Kernel — это модуль, реализующий ядра фильтрации (корреляции) полной размерности. Поддерживаются следующие ядра:

  • sobel

  • prewitt

  • ando3, ando4 и ando5

  • scharr

  • bickley

  • gaussian

  • DoG (разность гауссианов)

  • LoG (лапласиан гауссиана)

  • Laplacian

  • gabor

  • moffat

См. также описание модуля KernelFactors.

    diff1, diff2 = ando3()

Возвращает ядра корреляции для вычисления двухмерного градиента с помощью «оптимальных» фильтров Андо. Ядро diff1 вычисляет градиент по оси y (первое измерение), а ядро diff2 — градиент по оси x (второе измерение). diff1 == rotr90(diff2)

    (diff,) = ando3(extended::NTuple{N,Bool}, d)

Возвращает N-мерное ядро корреляции (кортеж) для вычисления градиента по измерению d с помощью «оптимальных» фильтров Андо размера 3. Если extended[dim] имеет значение false, diff имеет размер 1 по соответствующему измерению.

Цитирование

S.Ando, Consistent gradient operators, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no.3, pp. 252—​265, 2000. doi:10.1109/34.841757

См. также описание функций KernelFactors.ando3, Kernel.ando4, Kernel.ando5 и ImageFiltering.imgradients.

    diff1, diff2 = ando4()

Возвращает ядра корреляции для вычисления двухмерного градиента с помощью «оптимальных» фильтров Андо. Ядро diff1 вычисляет градиент по оси y (первое измерение), а ядро diff2 — градиент по оси x (второе измерение). diff1 == rotr90(diff2)

    (diff,) = ando4(extended::NTuple{N,Bool}, d)

Возвращает N-мерное ядро корреляции (кортеж) для вычисления градиента по измерению d с помощью «оптимальных» фильтров Андо размера 4. Если extended[dim] имеет значение false, diff имеет размер 1 по соответствующему измерению.

Цитирование

S.Ando, Consistent gradient operators, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no.3, pp. 252—​265, 2000. doi:10.1109/34.841757

См. также описание функций KernelFactors.ando4, Kernel.ando3, Kernel.ando5 и ImageFiltering.imgradients.

    diff1, diff2 = ando5()

Возвращает ядра корреляции для вычисления двухмерного градиента с помощью «оптимальных» фильтров Андо. Ядро diff1 вычисляет градиент по оси y (первое измерение), а ядро diff2 — градиент по оси x (второе измерение). diff1 == rotr90(diff2)

    (diff,) = ando5(extended::NTuple{N,Bool}, d)

Возвращает N-мерное ядро корреляции (кортеж) для вычисления градиента по измерению d с помощью «оптимальных» фильтров Андо размера 5. Если extended[dim] имеет значение false, diff имеет размер 1 по соответствующему измерению.

Цитирование

S.Ando, Consistent gradient operators, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no.3, pp. 252—​265, 2000. doi:10.1109/34.841757

См. также описание функций KernelFactors.ando5, Kernel.ando3, Kernel.ando4 и ImageFiltering.imgradients.

    diff1, diff2 = bickley()

Возвращает ядра корреляции для вычисления двухмерного градиента с помощью оператора Бикли. Ядро diff1 вычисляет градиент по оси y (первое измерение), а ядро diff2 — градиент по оси x (второе измерение). diff1 == rotr90(diff2)

    (diff,) = bickley(extended::NTuple{N,Bool}, d)

Возвращает N-мерное ядро корреляции (кортеж) для вычисления градиента по измерению d с помощью оператора Бикли. Если extended[dim] имеет значение false, diff имеет размер 1 по соответствующему измерению.

Цитирование

W.G. Bickley, Finite difference formulae for the square lattice, The Quarterly Journal of Mechanics and Applied Mathematics, vol. 1, no. 1, pp. 35—​42, 1948. doi:10.1093/qjmam/1.1.35

См. также описание функций KernelFactors.bickley, Kernel.prewitt, Kernel.ando3, Kernel.scharr и ImageFiltering.imgradients.

DoG((σp1, σp2, ...), (σm1, σm2, ...), [l1, l2, ...]) -> k
DoG((σ1, σ2, ...))                                   -> k
DoG(σ::Real)                                         -> k

Создает многомерное ядро на основе разницы гауссианов k, равное gaussian(σp, l)-gaussian(σm, l). Если предоставлено только одно значение σ, по умолчанию выбирается σp = σ, σm = √2 σ. Можно также указать длину ядра l; по умолчанию ядро простирается на два max(σp,σm) в каждом направлении от центра. Значение l должно быть нечетным.

Если значение σ задано в виде одного числа, возвращается симметричное двухмерное ядро на основе разницы гауссианов.

См. также описание функции KernelFactors.IIRGaussian.

gabor(size_x,size_y,σ,θ,λ,γ,ψ) -> (k_real,k_complex)

Возвращает двухмерное комплексное ядро Габора, содержащееся в кортеже:

  • size_x, size_y означают размер ядра;

  • σ означает среднеквадратичное отклонение от огибающей Гаусса;

  • θ представляет ориентацию нормали относительно параллельных полос функции Габора;

  • λ представляет длину волны периодической составляющей;

  • γ — пространственное характеристическое отношение, определяющее эллиптичность носителя функции Габора;

  • ψ — сдвиг фаз.

#Citation N. Petkov and P. Kruizinga, Computational models of visual neurons specialised in the detection of periodic and aperiodic oriented visual stimuli: bar and grating cells, Biological Cybernetics, vol. 76, no. 2, pp. 83—​96, Feb. 1997. doi.org/10.1007/s004220050323

gaussian((σ1, σ2, ...), [(l1, l2, ...)]) -> g
gaussian(σ)                  -> g

Создает многомерный фильтр Гаусса со среднеквадратичным отклонением σd по измерению d. Можно также указать длину ядра l в виде кортежа той же длины.

Если значение σ задано в виде одного числа, возвращается симметричное двухмерное ядро.

См. также описание функции KernelFactors.gaussian.

Laplacian((true,true,false,...))
Laplacian(dims, N)
Laplacian()

Ядро на основе лапласиана в N измерениях, принимающее производные в направлениях, помеченных как true в переданном кортеже. В аргументе dims можно также передать список измерений для дифференцирования. (Однако такой вариант не является выводимым.)

Laplacian() — это двухмерный лапласиан, эквивалентный Laplaciantrue,true.

Ядро представлено как непрозрачный тип, но с помощью функции convert(AbstractArray, L) его можно преобразовать в формат массива.

LoG((σ1, σ2, ...)) -> k
LoG(σ)             -> k

Создает ядро на основе лапласиана гауссиана k. σd — это ширина гауссиана по измерению d. Если значение σ задано в виде одного числа, возвращается симметричное двухмерное ядро.

См. также описание функции KernelFactors.IIRGaussian и типа Kernel.Laplacian.

moffat(α, β, ls) -> k

Создает двухмерное симметричное ядро Моффата k с шириной сердцевины α и степенью β. Ядро имеет размер, равный 4 * максимальный размер половины полной ширины или указанный в ls. Подробные сведения см. в этой записной книжке.

Цитирование

Moffat, A. F. J. A theoretical investigation of focal stellar images in the photographic emulsion and application to photographic photometry. Astronomy and Astrophysics 3 (1969): 455.

    diff1, diff2 = prewitt()

Возвращает ядра корреляции для вычисления двухмерного градиента с помощью оператора Прюитта. Ядро diff1 вычисляет градиент по оси y (первое измерение), а ядро diff2 — градиент по оси x (второе измерение). diff1 == rotr90(diff2)

    (diff,) = prewitt(extended::NTuple{N,Bool}, d)

Возвращает N-мерное ядро корреляции (кортеж) для вычисления градиента по измерению d с помощью оператора Прюитта. Если extended[dim] имеет значение false, diff имеет размер 1 по соответствующему измерению.

Цитирование

J.M. Prewitt, Object enhancement and extraction, Picture processing and Psychopictorics, vol. 10, no. 1, pp. 15—​19, 1970.

См. также описание функций KernelFactors.prewitt, Kernel.sobel, Kernel.ando3, Kernel.scharr,Kernel.bickley и ImageFiltering.imgradients.

    diff1, diff2 = scharr()

Возвращает ядра корреляции для вычисления двухмерного градиента с помощью оператора Шарра. Ядро diff1 вычисляет градиент по оси y (первое измерение), а ядро diff2 — градиент по оси x (второе измерение). diff1 == rotr90(diff2)

    (diff,) = scharr(extended::NTuple{N,Bool}, d)

Возвращает N-мерное ядро корреляции (кортеж) для вычисления градиента по измерению d с помощью оператора Шарра. Если extended[dim] имеет значение false, diff имеет размер 1 по соответствующему измерению.

Цитирование

H.Scharr and J. Weickert, An anisotropic diffusion algorithm with optimized rotation invariance, Mustererkennung 2000, pp. 460—​467, 2000. doi:10.1007/978-3-642-59802-9_58

См. также описание функций KernelFactors.scharr, Kernel.prewitt, Kernel.ando3, Kernel.bickley и ImageFiltering.imgradients.

    diff1, diff2 = sobel()

Возвращает ядра корреляции для вычисления двухмерного градиента с помощью оператора Собеля. Ядро diff1 вычисляет градиент по оси y (первое измерение), а ядро diff2 — градиент по оси x (второе измерение). diff1 == rotr90(diff2)

    (diff,) = sobel(extended::NTuple{N,Bool}, d)

Возвращает N-мерное ядро корреляции (кортеж) для вычисления градиента по измерению d с помощью оператора Собеля. Если extended[dim] имеет значение false, diff имеет размер 1 по соответствующему измерению.

Цитирование

P.-E. Danielsson and O. Seger, Generalized and separable sobel operators, in Machine Vision for Three-Dimensional Scenes, H. Freeman, Ed. Academic Press, 1990, pp. 347—​379. doi:10.1016/b978-0-12-266722-0.50016-6

См. также описание функций KernelFactors.sobel, Kernel.prewitt, Kernel.ando3, Kernel.scharr, Kernel.bickley и imgradients.

KernelFactors

KernelFactors — это модуль, реализующий разделяемые ядра фильтрации, каждое из которых хранится в виде множителей. Поддерживаются следующие ядра:

  • box

  • sobel

  • prewitt

  • ando3, ando4 и ando5 (последнее только в двухмерном варианте)

  • scharr

  • bickley

  • gaussian

  • IIRGaussian (приближенная гауссова фильтрация, выполняющаяся быстро даже при большом σ)

См. также описание модуля Kernel.

    kern1, kern2 = ando3()

Возвращает разложенную форму «оптимальных» градиентных фильтров Андо для измерений 1 и 2 изображения.

Цитирование

S.Ando, Consistent gradient operators, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no.3, pp. 252—​265, 2000. doi:10.1109/34.841757

См. также описание функций Kernel.ando3, KernelFactors.ando4, KernelFactors.ando5 и ImageFiltering.imgradients.

    kern = ando3(extended::NTuple{N,Bool}, d)

Возвращает разложенный фильтр Андо (размера 3) для вычисления градиента в N измерениях по оси d. Если extended[dim] имеет значение false, kern имеет размер 1 по соответствующему измерению.

См. также описание функций KernelFactors.ando4, KernelFactors.ando5 и ImageFiltering.imgradients.

    kern1, kern2 = ando4()

Возвращает разделяемые аппроксимации «оптимальных» фильтров Андо 4x4 для измерений 1 и 2 изображения.

Цитирование

S.Ando, Consistent gradient operators, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no.3, pp. 252—​265, 2000. doi:10.1109/34.841757

См. также описание функций Kernel.ando4 и ImageFiltering.imgradients.

    kern = ando4(extended::NTuple{N,Bool}, d)

Возвращает разложенный фильтр Андо (размера 4) для вычисления градиента в N измерениях по оси d. Если extended[dim] имеет значение false, kern имеет размер 1 по соответствующему измерению.

Цитирование

S.Ando, Consistent gradient operators, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no.3, pp. 252—​265, 2000. doi:10.1109/34.841757

См. также описание функций Kernel.ando4 и ImageFiltering.imgradients.

    kern1, kern2 = ando5()

Возвращает разделяемые аппроксимации «оптимальных» градиентных фильтров Андо 5x5 для измерений 1 и 2 изображения.

Цитирование

S.Ando, Consistent gradient operators, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no.3, pp. 252—​265, 2000. doi:10.1109/34.841757

См. также описание функций Kernel.ando5 и ImageFiltering.imgradients.

    kern = ando5(extended::NTuple{N,Bool}, d)

Возвращает разложенный фильтр Андо (размера 5) для вычисления градиента в N измерениях по оси d. Если extended[dim] имеет значение false, kern имеет размер 1 по соответствующему измерению.

    kern1, kern2 = bickley()

Возвращает разложенные фильтры Бикли для измерений 1 и 2 изображения. Каждый из них представляет собой кортеж из двух одномерных фильтров.

Цитирование

W.G. Bickley, Finite difference formulae for the square lattice, The Quarterly Journal of Mechanics and Applied Mathematics, vol. 1, no. 1, pp. 35—​42, 1948. doi:10.1093/qjmam/1.1.35

См. также описание функций Kernel.bickley и ImageFiltering.imgradients.

    kern = bickley(extended::NTuple{N,Bool}, d)

Возвращает разложенный фильтр Бикли для вычисления градиента в N измерениях по оси d. Если extended[dim] имеет значение false, kern имеет размер 1 по соответствующему измерению.

См. также описание функций Kernel.bickley и ImageFiltering.imgradients.

gaussian(σ::Real, [l]) -> g

Создает одномерное гауссово ядро g со среднеквадратичным отклонением σ; при необходимости можно указать длину ядра l. По умолчанию ядро простирается на два σ в каждом направлении от центра. Значение l должно быть нечетным.

gaussian((σ1, σ2, ...), [l]) -> (g1, g2, ...)

Создает многомерный фильтр Гаусса как произведение одномерных множителей со среднеквадратичным отклонением σd по измерению d. Можно также указать длину ядра l в виде кортежа той же длины.

IIRGaussian([T], σ; emit_warning::Bool=true)

Создает аппроксимацию бесконечной импульсной характеристики (БИХ) к гауссиану среднеквадратичного отклонения σ. σ может быть одним вещественным числом или кортежем чисел; в последнем случае создается кортеж таких фильтров, каждый из которых предназначен для фильтрации отдельного измерения массива.

При необходимости можно указать тип T для коэффициентов фильтра; если тип не указан, он будет соответствовать типу σ (если σ не является значением с плавающей запятой, выбирается тип Float64).

Цитирование

I.T. Young, L. J. van Vliet, and M. van Ginkel, Recursive Gabor Filtering. IEEE Trans. Sig. Proc., 50: 2798-2805 (2002).

    kern1, kern2 = prewitt()

Возвращает разложенные фильтры Прюитта для измерений 1 и 2 изображения. Каждый из них представляет собой кортеж из двух одномерных фильтров.

Цитирование

J.M. Prewitt, Object enhancement and extraction, Picture processing and Psychopictorics, vol. 10, no. 1, pp. 15—​19, 1970.

См. также описание функций Kernel.prewitt и ImageFiltering.imgradients.

    kern = prewitt(extended::NTuple{N,Bool}, d)

Возвращает разложенный фильтр Прюитта для вычисления градиента в N измерениях по оси d. Если extended[dim] имеет значение false, kern имеет размер 1 по соответствующему измерению.

См. также описание функций Kernel.prewitt и ImageFiltering.imgradients.

    kern1, kern2 = scharr()

Возвращает разложенные фильтры Шарра для измерений 1 и 2 изображения. Каждый из них представляет собой кортеж из двух одномерных фильтров.

Цитирование

H.Scharr and J. Weickert, An anisotropic diffusion algorithm with optimized rotation invariance, Mustererkennung 2000, pp. 460—​467, 2000. doi:10.1007/978-3-642-59802-9_58

См. также описание функций Kernel.scharr и ImageFiltering.imgradients.

    kern = scharr(extended::NTuple{N,Bool}, d)

Возвращает разложенный фильтр Шарра для вычисления градиента в N измерениях по оси d. Если extended[dim] имеет значение false, kern имеет размер 1 по соответствующему измерению.

См. также описание функций Kernel.scharr и ImageFiltering.imgradients.

    kern1, kern2 = sobel()

Возвращает разложенные фильтры Собеля для измерений 1 и 2 двухмерного изображения. Каждый из них представляет собой кортеж из двух одномерных фильтров.

Цитирование

P.-E. Danielsson and O. Seger, Generalized and separable sobel operators, in Machine Vision for Three-Dimensional Scenes, H. Freeman, Ed. Academic Press, 1990, pp. 347—​379. doi:10.1016/b978-0-12-266722-0.50016-6

См. также описание функций Kernel.sobel и ImageFiltering.imgradients.

    kern = sobel(extended::NTuple{N,Bool}, d)

Возвращает разложенный фильтр Собеля для вычисления градиента в N измерениях по оси d. Если extended[dim] имеет значение false, kern имеет размер 1 по соответствующему измерению.

См. также описание функций Kernel.sobel и ImageFiltering.imgradients.

TriggsSdika(a, b, scale, M)

Определяет ядро для одномерной фильтрации с бесконечной импульсной характеристикой (БИХ). a — это «прямой» фильтр, b — «обратный» фильтр, M — матрица для сопоставления граничных условий на правом краю, а scale — константа масштабирования, применяемая к каждому элементу по завершении фильтрации.

Цитирование

B.Triggs and M. Sdika, Boundary conditions for Young-van Vliet recursive filtering. IEEE Trans. on Sig. Proc. 54: 2365-2367 (2006).

TriggsSdika(ab, scale)

Создает симметричный фильтр Триггса-Сдики (с a = b = ab). M вычисляется автоматически. В настоящее время поддерживаются только фильтры длиной 3.

Служебные средства для ядер

center(A, [r::RoundingMode=RoundDown])::Dims

Возвращает координату центра заданного массива A. Если значение size(A, k) является четным числом, то будет применена процедура округления с режимом r.

Совместимость: OffsetArrays 1.9

Для этого метода требуется версия OffsetArrays не ниже 1.9.

Примеры

julia> A = reshape(collect(1:9), 3, 3)
3×3 Matrix{Int64}:
 1  4  7
 2  5  8
 3  6  9

julia> c = OffsetArrays.center(A)
(2, 2)

julia> A[c...]
5

julia> Ao = OffsetArray(A, -2, -2); # оси (-1:1, -1:1)

julia> c = OffsetArrays.center(Ao)
(0, 0)

julia> Ao[c...]
5

Чтобы сместить центральную координату заданного массива в точку (0, 0, ...), можно использовать centered.

centered(A, cp=center(A)) -> Ao

Смещает центральную координату / точку cp массива A в точку (0, 0, ..., 0). Внутренне это эквивалентно OffsetArray(A, .-cp).

Совместимость: OffsetArrays 1.9

Для этого метода требуется версия OffsetArrays не ниже 1.9.

Примеры

julia> A = reshape(collect(1:9), 3, 3)
3×3 Matrix{Int64}:
 1  4  7
 2  5  8
 3  6  9

julia> Ao = OffsetArrays.centered(A); # оси (-1:1, -1:1)

julia> Ao[0, 0]
5

julia> Ao = OffsetArray(A, OffsetArrays.Origin(0)); # оси (0:2, 0:2)

julia> Aoo = OffsetArrays.centered(Ao); # оси (-1:1, -1:1)

julia> Aoo[0, 0]
5

Пользователи могут передавать cp, чтобы изменить интерпретацию «центральной точки», но значение выходного массива также должно быть переосмыслено. Например, если cp = map(last, axes(A)), то эта функция смещает уже не центральную точку, а правую нижнюю точку в точку (0, 0, ..., 0). Обычно cp используется для изменения поведения округления, когда массив имеет четное значение размера в некотором измерении:

julia> A = reshape(collect(1:4), 2, 2) # В идеале центр должен быть в точке (1.5, 1.5), но OffsetArrays поддерживают только целочисленные смещения.
2×2 Matrix{Int64}:
 1  3
 2  4

julia> OffsetArrays.centered(A, OffsetArrays.center(A, RoundUp)) # задание (2, 2) в качестве центральной точки
2×2 OffsetArray(::Matrix{Int64}, -1:0, -1:0) with eltype Int64 with indices -1:0×-1:0:
 1  3
 2  4

julia> OffsetArrays.centered(A, OffsetArrays.center(A, RoundDown)) # задание (1, 1) в качестве центральной точки
2×2 OffsetArray(::Matrix{Int64}, 0:1, 0:1) with eltype Int64 with indices 0:1×0:1:
 1  3
 2  4

См. также описание функции center.

kernelfactors(factors::Tuple)

Подготавливает разложенное ядро для фильтрации. Если передан кортеж из двух векторов длиной m и n, возвращается кортеж из двух векторов ReshapedVector, имеющих размеры m×1 и 1×n. В общем случае форма каждого следующего множителя factor изменяется так, чтобы он простирался вдоль соответствующего измерения.

Если передан кортеж общих массивов, предполагается, что каждый из них имеет соответствующую форму вдоль «ведущих» измерений; размерность каждого массива «расширяется» до N = length(factors) с добавлением значений 1 к размеру при необходимости.

reflect(kernel) --> reflectedkernel

Вычисляет поточечное отражение относительно 0, 0, …​ ядра kernel. При использовании imfilter с reflectedkernel выполняется свертка, а не корреляция, относительно исходного ядра kernel.

Границы и дополнение

BorderArray(inner::AbstractArray, border::AbstractBorder) <: AbstractArray

Создает тонкую оболочку вокруг массива inner с заданной границей border. Данные в конструктор не копируются; вместо этого граничные значения вычисляются динамически в вызовах getindex. Полезно для шаблонных вычислений. См. также описание функции padarray.

Примеры

julia> using ImageFiltering

julia> arr = reshape(1:6, (2,3))
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6

julia> BorderArray(arr, Pad((1,1)))
BorderArray{Int64,2,Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Pad{2}} with indices 0:3×0:4:
 1  1  3  5  5
 1  1  3  5  5
 2  2  4  6  6
 2  2  4  6  6

julia> BorderArray(arr, Fill(10, (2,1)))
BorderArray{Int64,2,Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Fill{Int64,2}} with indices -1:4×0:4:
 10  10  10  10  10
 10  10  10  10  10
 10   1   3   5  10
 10   2   4   6  10
 10  10  10  10  10
 10  10  10  10  10
struct Fill{T,N} <: AbstractBorder
    value::T
    lo::Dims{N}
    hi::Dims{N}
end

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

Вывод

Тип Fill, определяющий значение, которым будет дополняться граница изображения.

Подробные сведения

Когда операция фильтрации двухмерного пространственного изображения представлена в виде дискретной свертки между изображением и фильтром , результаты не определены для пикселей, которые находятся ближе пикселей к границе изображения. Чтобы определить операцию для пикселей, находящихся ближе к границе и на ней, требуется схема экстраполяции пикселей за границей. Тип Fill позволяет указать конкретное значение, которое будет использоваться при экстраполяции. Подробные схемы экстраполяции см. в описании типа Pad.

Этот тип упрощает дополнение одно-, двух- или многомерных изображений.

Можно указать другую степень дополнения на нижней и верхней границах каждого измерения изображения (верхней, левой, нижней и правой границах в двух измерениях).

Пример

Для иллюстрации рассмотрим изображение, состоящее из строки из шести пикселей, которые следуют по алфавиту:

    ┏━━━━━━┓
    ┃abcdef┃
    ┗━━━━━━┛

Дополнение постоянным значением m только на левой и правой границах выглядит следующим образом:

╭────┏━━━━━━┓────╮
│mmmm┃abcdef┃mmmm│
╰────┗━━━━━━┛────╯

(Аналогичным будет результат и для верхней и нижней границ.)

См. также описание Pad, padarray, Inner и NoPad.

Inner()
Inner(lo, hi)

Указывает, что края при фильтрации должны отбрасываться: возвращается только внутренняя часть результата.

Пример:

imfilter(img, kernel, Inner())
NA(na=isnan)

Выбор фильтрации с использованием граничных условий NA (недоступно). Лучше всего подходит для фильтров только с положительными весами, например фильтров размытия. Выходное значение фактически нормализуется следующим образом:

          filtered array with Fill(0) boundary conditions
output =  -----------------------------------------------
          filtered 1     with Fill(0) boundary conditions

Элементы массива, для которых na возвращает значение true, также считаются находящимися за границами массива.

NoPad()
NoPad(border)

Указывает, что дополнение не должно применяться к входному массиву или что входное изображение уже предварительно дополнено. Передача объекта border позволяет сэкономить память на выборе границы; его можно получить по индексу в [].

Пример

Следующие команды:

np = NoPad(Pad(:replicate))
imfilter!(out, img, kernel, np)

позволяют выполнить фильтрацию напрямую, пропустив дополнение. Каждый элемент out должен быть вычислим с использованием операций в пределах границ с img и kernel.

    struct Pad{N} <: AbstractBorder
        style::Symbol
        lo::Dims{N}    # число, на которое следует расширить изображение с нижнего края каждого измерения
        hi::Dims{N}    # число, на которое следует расширить изображение с верхнего края каждого измерения
    end

Pad — это тип, определяющий форму дополнения, которая должна использоваться для экстраполяции пикселей за границами изображения. В экземплярах должен быть задан style, символ, определяющий граничные условия изображения.

Вывод

Тип Pad, определяющий способ дополнения границы изображения.

Расширенная справка

Когда операция фильтрации двухмерного пространственного изображения представлена в виде дискретной свертки между изображением и фильтром , результаты не определены для пикселей, которые находятся ближе пикселей к границе изображения. Чтобы определить операцию для пикселей, находящихся ближе к границе и на ней, требуется схема экстраполяции пикселей за границей. Тип Pad позволяет указать необходимую схему экстраполяции.

Этот тип упрощает дополнение одно-, двух- или многомерных изображений.

Можно указать другую степень дополнения на нижней и верхней границах каждого измерения изображения (верхней, левой, нижней и правой границах в двух измерениях).

Параметры

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

        ┏━━━━━━┓
        ┃abcdef┃
        ┗━━━━━━┛

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

:replicate (по умолчанию)

Пиксели границы продолжаются за границами изображения.

   ╭────┏━━━━━━┓────╮
   │aaaa┃abcdef┃ffff│
   ╰────┗━━━━━━┛────╯

См. также описание Fill, padarray, Inner и NoPad.

:circular

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

   ╭────┏━━━━━━┓────╮
   │cdef┃abcdef┃abcd│
   ╰────┗━━━━━━┛────╯

См. также описание Fill, padarray, Inner и NoPad.

:symmetric

Пиксели границы отражаются относительно позиции между пикселями. Пиксель границы при этом опускается.

   ╭────┏━━━━━━┓────╮
   │edcb┃abcdef┃edcb│
   ╰────┗━━━━━━┛────╯

:reflect

Пиксели границы отражаются относительно края изображения.

   ╭────┏━━━━━━┓────╮
   │dcba┃abcdef┃fedc│
   ╰────┗━━━━━━┛────╯

См. также описание Fill,padarray, Inner и NoPad.

padarray([T], img, border)

Generate a padded image from an array img and a specification border of the boundary conditions and amount of padding to add.

Return a padded image. The function supports one, two or multi-dimensional images. You can specify the element type T of the output image.

Подробные сведения см. в описании Pad и Fill.

Примеры

Дополнение

Основной синтаксис для Pad имеет вид (style, m, n, ...) или (style, (m, n)), где m пикселей добавляются к измерению 1 (сверху и снизу), n пикселей — к измерению 2 и т. д.

Добавляем 30 пикселей слева и справа, 40 пикселей сверху и снизу:

padarray(A, Pad(:replicate, 30, 40))
padarray(A, Pad(:circular, 30, 40))
padarray(A, Pad(:symmetric, 30, 40))
padarray(A, Pad(:reflect, 30, 40))

Добавляем 30 пикселей сверху, 40 пикселей слева, 50 пикселей снизу, 60 пикселей справа:

padarray(A, Pad(0, (30, 40), (50, 60)))
padarray(A, Pad(0, (30, 40), (50, 60)))

3 измерения

padarray(A, Pad(:replicate, 1, 1, 1))
padarray(A, Fill(0, (1, 1, 1)))

Заполнение

Основной синтаксис для Fill имеет вид (value, m, n) или (value, (m, n)), где в начале каждого измерения добавляется m пикселей, а в конце — n пикселей.

Добавляем 20 значений -1 сверху, 30 — слева, 40 — снизу, 50 — справа:

padarray(A, Fill(-1, (20, 30), (40, 50)))

Нахождение локальных экстремумов

findlocalmaxima(img; window=default_window(img), edges=true) -> Vector{CartesianIndex}

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

default_window имеет значение 3 для каждого пространственного измерения img и значение 1 в остальных случаях, что подразумевает нахождение максимумов среди смежных элементов по умолчанию в каждом пространственном «срезе».

findlocalminima(img; window=default_window(img), edges=true) -> Vector{CartesianIndex}

Аналогично findlocalmaxima, но возвращает координаты наименьших элементов.

Алгоритмы

Выполняет фильтрацию с использованием прямого алгоритма.

Выполняет фильтрацию с использованием быстрого преобразования Фурье.

Выполняет фильтрацию с использованием фильтра с бесконечной импульсной характеристикой.

Выполняет фильтрацию с использованием каскада смешанных типов (БИХ, КИХ).

Решатели для готовых моделей

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

  • Решает модель Рудина-Ошера-Фатеми (ROF) прямодвойственным методом: solve_ROF_PD и solve_ROF_PD!

solve_ROF_PD!(out, buffer, img, λ, num_iters)

Выполняемая на месте версия solve_ROF_PD.

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

!!! note "Buffer" Содержимое и назначение аргумента buffer может измениться без уведомления при изменении внутренней реализации. Во избежание возможных изменений используйте вспомогательную функцию preallocate_solve_ROF_PD.

Примеры

using ImageFiltering.Models: preallocate_solve_ROF_PD

out = similar(img)
buffer = preallocate_solve_ROF_PD(img)
solve_ROF_PD!(out, buffer, img, 0.2, 30)
solve_ROF_PD([T], img::AbstractArray, λ; kwargs...)

Возвращает сглаженную версию img с использованием фильтрации Рудина-Ошера-Фатеми (ROF), более известной как сглаживание или регуляризация методом полной вариации (TV). Этот алгоритм основан на прямодвойственном методе.

Эта функция применяется к универсальному N-мерному цветовому массиву и совместима с CUDA. Есть также выполняемая на месте версия: solve_ROF_PD!.

Аргументы

  • T: тип выходных элементов. По умолчанию float32(eltype(img)).

  • img: входное изображение, обычное зашумленное.

  • λ: коэффициент регуляризации. Чем больше значение λ, тем выше степень сглаживания.

Параметры

  • num_iters::Int: число итераций перед остановкой.

Примеры

using ImageFiltering
using ImageFiltering.Models: solve_ROF_PD
using ImageQualityIndexes
using TestImages

img_ori = float.(testimage("cameraman"))
img_noisy = img_ori .+ 0.1 .* randn(size(img_ori))
assess_psnr(img_noisy, img_ori) # ~20 дБ

img_smoothed = solve_ROF_PD(img_noisy, 0.015, 50)
assess_psnr(img_smoothed, img_ori) # ~27 дБ

# при больших значениях λ результат будет чрезмерно сглаженным
img_smoothed = solve_ROF_PD(img_noisy, 5, 50)
assess_psnr(img_smoothed, img_ori) # ~21 дБ

Расширенная справка

С математической точки зрения эта функция решает следующую модель (ROF) прямодвойственным методом:

Справочные материалы

Внутренние механизмы

ReshapedOneD{N,Npre}(data)

Возвращает объект размерности N, где data должно иметь размерность 1. Он имеет оси 0:0 для первых Npre измерений, оси data для измерения Npre+1 и оси 0:0 для оставшихся измерений.

Объект data должен поддерживать eltype и ndims, но не обязательно должен быть массивом AbstractArray.

ReshapedOneDs позволяет указать «измерение фильтрации» для одномерного фильтра.