Справочник по функциям

Справочник по функциям

Общие функции

# ImageEdgeDetection.EdgeDetectionAPI.detect_edges — Function

out = detect_edges([T::Type,] img, f::AbstractEdgeDetectionAlgorithm, args...; kwargs...)

Обнаруживает края изображения (img), используя алгоритм f. Если не указано, f считается как Canny.

Вывод

Возвращаемое изображение out является Array{T}. Если T не указан, он выводится.

Примеры

Просто передайте входное изображение и алгоритм функции detect_edges.

f = Canny(spatial_scale = 1.4)
img_edges = detect_edges(img, f)

Это означает «обнаружение краев (detect_edges) изображения (img) с использованием алгоритма f».

Вы также можете явным образом указать возвращаемый тип:

f = Canny(spatial_scale = 1.4)
img_edges_float32 = detect_edges(Gray{Float32}, img, f)

См. также описание detect_edges! со сведениями об обнаружении краев на месте.

# ImageEdgeDetection.EdgeDetectionAPI.detect_edges! — Function

detect_edges!([out,] img, f::AbstractEdgeDetectionAlgorithm, args...; kwargs...)

Обнаруживает края изображения (img), используя алгоритм f. Если не указано, f считается как Canny.

Вывод

Если out указан, он будет изменен на месте. В противном случае img будет изменен на месте.

Примеры

Просто передайте алгоритм функции detect_edges!:

img_edges = similar(img)
detect_edges!(img_edges, img, f)

Когда вы просто хотите изменить img на месте, необязательно вручную выделять img_edges. Достаточно воспользоваться вспомогательным методом:

detect_edges!(img, f)

См. также описание detect_edges.

# ImageEdgeDetection.EdgeDetectionAPI.detect_subpixel_edges — Function

out₁, out₂ = detect_subpixel_edges([T₁::Type, T₂::Type], img, f::AbstractEdgeDetectionAlgorithm, args...; kwargs...)

Обнаруживает края изображения (img) с точностью до субпикселя, используя алгоритм f. Если не указано, f считается как Canny.

Вывод

Целочисленные компоненты края соответствуют ненулевым записям строк и столбцов в out₁, который представляет собой Array{T₁}. Сопутствующие смещения субпикселей хранятся в двумерном массиве out₂ в виде векторов длиной 2 (Array{SVector{2, T₂}}). Для восстановления субпиксельных координат можно добавить смещения субпикселей к целочисленным компонентам.

Примеры

Просто передайте входное изображение и алгоритм функции detect_subpixel_edges.

f = Canny(spatial_scale = 1.4, thinning_algorithm = SubpixelNonmaximaSuppression())
img_edges, offsets = detect_subpixel_edges(img, f)

Это означает «обнаружение краев (detect_subpixel_edges) изображения (img) с использованием алгоритма f».

Вы также можете явным образом указать возвращаемые типы:

f = Canny(spatial_scale = 1.4, thinning_algorithm = SubpixelNonmaximaSuppression())
img_edges, offsets = detect_subpixel_edges(Gray{Float32}, Float32, img, f)

См. также описание detect_subpixel_edges! со сведениями об обнаружении краев на месте.

# ImageEdgeDetection.EdgeDetectionAPI.detect_subpixel_edges! — Function

detect_subpixel_edges!(out₁, out₂, img, f::AbstractEdgeDetectionAlgorithm, args...; kwargs...)

Вывод

Целочисленные компоненты края соответствуют ненулевым записям строк и столбцов в out₁. Сопутствующие смещения субпикселей хранятся в двумерном массиве out₂ в виде векторов длиной 2. Для восстановления субпиксельных координат можно добавить смещения субпикселей к целочисленным компонентам.

Примеры

Просто передайте алгоритм функции detect_subpixel_edges!:

f = Canny(spatial_scale = 1.4, thinning_algorithm = SubpixelNonmaximaSuppression())
img_edges = similar(img)
offsets = zeros(SVector{2,Float64}, axes(img))
detect_edges!(img_edges, offsets, img, f)

См. также описание detect_subpixel_edges.

# ImageEdgeDetection.detect_gradient_orientation — Function

detect_gradient_orientation(g₁::AbstractArray, g₂::AbstractArray, orientation_convention::OrientationConvention, args...; kwargs...)

Учитывая градиент в первом (g₁) и втором (g₂) пространственных измерениях, возвращает ориентацию градиента, где ориентация интерпретируется в соответствии с заданным OrientationConvention.

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

Вы можете указать, как должна быть представлена ориентация градиента, предоставив OrientationConvention. Если это не указано, ориентация измеряется против часовой стрелки с южного направления. Это связано с тем, что в растровой системе координат первое пространственное измерение увеличивается по мере продвижения вниз по изображению (то есть указывает на юг), а второе пространственное измерение увеличивается по мере продвижения вправо по изображению (то есть указывает на восток).

Чтобы интерпретировать ориентацию в канонических декартовых координатах, укажите восток в качестве эталонного направления компаса (compass_direction = 'E') и направление против часовой стрелки (clockwise = false).

Вывод

Возвращает двумерный массив углов. Если in_radians = true, допустимые углы находятся в диапазоне [0...2π), в противном случае — в диапазоне [0...360). Значения 2π и 360 используются в качестве контрольных для обозначения неопределенных углов (поскольку величина градиента была слишком близка к нулю). По умолчанию угол не определен, если (abs(g₁) < tol && abs(g₂) < tol), где g₁ и g₂ обозначают градиент в первом и втором пространственных измерениях, и tol = sqrt(eps(Float64)) (как определено в типе OrientationConvention).

См. также описание detect_gradient_orientation!.

# ImageEdgeDetection.detect_gradient_orientation! — Function

detect_gradient_orientation(out::AbstractArray, g₁::AbstractArray, g₂::AbstractArray, orientation_convention::OrientationConvention, args...; kwargs...)

Учитывая градиент в первом (g₁) и втором (g₂) пространственных измерениях, возвращает ориентацию градиента в out, где ориентация интерпретируется в соответствии с заданным OrientationConvention.

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

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

Вывод

Возвращает двумерный массив углов. Если in_radians = true, истинные углы находятся в диапазоне [0...2π), в противном случае — в диапазоне [0...360). Значения 2π и 360 используются в качестве контрольных для обозначения неопределенных углов (поскольку величина градиента была слишком близка к нулю). По умолчанию угол не определен, если (abs(g₁) < tol && abs(g₂) < tol), где g₁ и g₂ обозначают градиент в первом и втором пространственных измерениях, и tol = sqrt(eps(eltype(out))) (как определено в OrientationConvention).

См. также описание detect_gradient_orientation.

# ImageEdgeDetection.EdgeDetectionAPI.thin_edges — Function

thin_edges([T::Type,] mag, g₁, g₂, f::AbstractEdgeThinningAlgorithm, args...; kwargs...)

Используя алгоритм f, уточняет передачу края на основе величины края mag, градиента в первом пространственном измерении g₁ и градиента во втором пространственном измерении g₂.

Вывод

Возвращает Array{T}, представляющий уточненную передачу края.

Если T не указан, он выводится. Обратите внимание, что T должен представлять или заключать в оболочку число с плавающей запятой.

Примеры

Просто передайте входное изображение и алгоритм функции thin_edges.

using TestImages, ImageFiltering
img =  Gray.(testimage("mandril"))

# Градиент в первом и втором пространственном измерении
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# Величина градиента
mag = hypot.(g₁, g₂)

f = NonmaximaSuppression(threshold = Percentile(10))

thinned_edges = thin_edges(mag, g₁, g₂, f)

Это означает «уточнение краев (thin_edges) на основе величины передачи края пространственных градиентов с использованием алгоритма f».

Вы также можете явным образом указать возвращаемый тип:

thinned_edges_float32 = thin_edges(Gray{Float32}, mag, g₁, g₂, f)

См. также описание thin_edges! со сведениями об уточнении краев на месте.

# ImageEdgeDetection.EdgeDetectionAPI.thin_edges! — Function

thin_edges!([out,] mag, g₁, g₂, f::AbstractEdgeThinningAlgorithm, args...; kwargs...)

Изолирует локальные максимумы величины градиента mag вдоль направления локального градиента. Аргументы g₁ и g₂ представляют градиент в первом пространственном измерении (y) и градиент во втором пространственном измерении (x), соответственно.

Вывод

Если out указан, он будет изменен на месте. В противном случае mag будет изменен на месте.

Примеры

Просто передайте алгоритм функции thin_edges!:

using TestImages, ImageFiltering
img =  Gray.(testimage("mandril"))

# Градиент в первом и втором пространственном измерении
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# Величина градиента
mag = hypot.(g₁, g₂)

f = SubpixelNonmaximaSuppression(threshold = Percentile(10))

thinned_edges = zeros(eltype(mag), axes(mag))
thin_edges!(thinned_edges, mag, g₁, g₂, f)

Когда вы просто хотите изменить mag на месте, необязательно вручную выделять thinned_edges. Достаточно воспользоваться вспомогательным методом:

thin_edges!(mag, g₁, g₂, f)

См. также описание thin_edges.

# ImageEdgeDetection.EdgeDetectionAPI.thin_subpixel_edges — Function

out₁, out₂ = thin_subpixel_edges(mag, g₁, g₂, f::AbstractEdgeThinningAlgorithm, args...; kwargs...)

Вывод

Целочисленные компоненты локальных максимумов соответствуют ненулевым записям строк и столбцов в out₁. Сопутствующие смещения субпикселей хранятся в двумерном массиве out₂ в виде векторов длиной 2. Для восстановления субпиксельных координат можно добавить смещения субпикселей к целочисленным компонентам.

Примеры

Просто передайте алгоритм функции thin_subpixel_edges:

using TestImages, ImageFiltering
img =  Gray.(testimage("mandril"))

# Градиент в первом и втором пространственном измерении
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# Величина градиента
mag = hypot.(g₁, g₂)

f = SubpixelNonmaximaSuppression(threshold = Percentile(10))

thinned_edges, offsets = thin_subpixel_edges(mag, g₁, g₂, f)

См. также описание thin_subpixel_edges!.

# ImageEdgeDetection.EdgeDetectionAPI.thin_subpixel_edges! — Function

thin_subpixel_edges!(out₁, out₂, mag, g₁, g₂, f::AbstractEdgeThinningAlgorithm, args...; kwargs...)

Вывод

Примеры

Просто передайте алгоритм функции thin_subpixel_edges!:

using TestImages, ImageFiltering
img =  Gray.(testimage("mandril"))

# Градиент в первом и втором пространственном измерении
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# Величина градиента
mag = hypot.(g₁, g₂)

f = SubpixelNonmaximaSuppression(threshold = Percentile(10))

thinned_edges = zeros(eltype(mag), axes(mag))
offsets = zeros(SVector{2,Float64}, axes(mag))
thin_subpixel_edges!(thinned_edges, offsets, mag, g₁, g₂, f)

См. также описание thin_subpixel_edges.

Алгоритмы обнаружения краев

# ImageEdgeDetection.EdgeDetectionAPI.AbstractEdgeDetectionAlgorithm — Type

AbstractEdgeDetectionAlgorithm <: AbstractImageFilter

Корневой тип для пакета ImageEdgeDetection.

Любой конкретный алгоритм обнаружения краев должен выделять его подтип для поддержки API detect_edges, detect_edges!, detect_subpixel_edges и detect_subpixel_edges!.

Примеры

Все алгоритмы обнаружения краев в ImageEdgeDetection вызываются по следующей схеме:

# создание экземпляра алгоритма
f = Canny()

# передача алгоритма функции `detect_edges`
img_edges = detect_edges(img, f)

# или использование версии `detect_edges!` на месте
img_edges = similar(img)
detect_edges!(img_edges, img, f)

Дополнительные примеры см. в описании detect_edges и detect_edges! и конкретных алгоритмов.

Можно также обнаруживать края с субпиксельной точностью, указав SubpixelNonmaximaSuppression в качестве алгоритма уточнения краев и используя detect_subpixel_edges или detect_subpixel_edges!. Функция возвращает изображение края, а также сопровождающую матрицу векторов длиной 2, которые при добавлении к координатам изображения края определяют расположения края с субпиксельной точностью.

# создание экземпляра алгоритма
f = Canny(thinning_algorithm = SubpixelNonmaximaSuppression())

# передача алгоритма функции `detect_subpixel_edge`
img_edges, subpixel_offsets = detect_subpixel_edges(img, f)

# или использование версии `detect_edges!` на месте
img_edges = similar(img)
subpixel_offsets = zeros(SVector{2,Float64}, axes(img))
detect_edges!(img_edges, subpixel_offsets, img, f)

Алгоритм Кэнни (Canny)

# ImageEdgeDetection.Canny — Type

    Canny <: AbstractEdgeDetectionAlgorithm
    Canny(; spatial_scale = 1, high = Percentile(80), low = Percentile(20), thinning_algorithm = NonmaximaSuppression(threshold = low))

    detect_edges([T,] img, f::Canny)
    detect_edges!([out,] img, f::Canny)
    detect_subpixel_edges([T₁, T₂] img, f::Canny)
    detect_subpixel_edges!(out₁, out₂, img, f::Canny)

Возвращает двоичное изображение, отображающее края входного изображения.

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

TODO

Параметры

Различные варианты параметров функции detect_edges и типа Canny более подробно описываются ниже.

Варианты для изображений

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

Для цветных изображений входные данные преобразуются в оттенки серого.

Варианты для spatial_scale в Canny.

Параметр spatial_scale определяет радиус (σ) гауссова фильтра. Это должно быть положительное вещественное число.

Варианты для high и low в Canny.

Пороги гистерезиса high и low (high > low) могут быть заданы как положительные числа или как Percentiles. Если значение не указано, используется значение по умолчанию high = Percentile(80) и low = Percentile(20).

Варианты для thinning_algorithm в Canny.

Вы можете указать AbstractEdgeThinningAlgorithm. По умолчанию используется алгоритм NonmaximaSuppression, который подавляет немаксимумы с точностью на уровне пикселя. Для субпиксельной точности задайте алгоритм SubpixelNonmaximaSuppression.

Пример

using TestImages, FileIO, ImageView

img =  testimage("mandril_gray")
img_edges = detect_edges(img, Canny(spatial_scale = 1.4))

imshow(img)
imshow(img_edges)

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

J.Canny, A Computational Approach to Edge Detection, in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. PAMI-8, no. 6, pp. 679-698, Nov. 1986, doi: 10.1109/TPAMI.1986.4767851.

Алгоритмы уточнения краев

# ImageEdgeDetection.EdgeDetectionAPI.AbstractEdgeThinningAlgorithm — Type

AbstractEdgeThinningAlgorithm <: AbstractImageFilter

Корневой тип для пакета ImageEdgeDetection.

Любой конкретный алгоритм уточнения краев должен выделять его подтип для поддержки API thin_edges, thin_edges!, thin_subpixel_edges и thin_subpixel_edges!.

Примеры

Все алгоритмы обнаружения краев в ImageEdgeDetection вызываются по следующей схеме:

# создание экземпляра алгоритма
f = NonmaximaSuppression()

# определение градиентов изображения
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# определение величины градиента
mag = hypot.(g₁, g₂)

# передача алгоритма функции `thin_edges`
thinned_edges = thin_edges(mag, g₁, g₂, f)

# или использование версии `thin_edges!` на месте
thinned_edges = zeros(eltype(mag), axes(mag))
thin_edges!(thinned_edges, mag, g₁, g₂, f)

Дополнительные примеры см. в описании thin_edges и thin_edges! и конкретных алгоритмов.

Для выполнения подавления немаксимумов с субпиксельной точностью можно использовать функции thin_subpixel_edges и thin_subpixel_edges!. Функция возвращает изображение края, а также сопровождающую матрицу векторов длиной 2, которые при добавлении к координатам изображения края определяют расположения края с субпиксельной точностью.

Подавление немаксимумов

# ImageEdgeDetection.NonmaximaSuppression — Type

    NonmaximaSuppression <: AbstractEdgeThinningAlgorithm
    NonmaximaSuppression(; threshold::Union{Number, Percentile} = Percentile(20))

    f = NonmaximaSuppression()
    f(out::AbstractArray, mag::AbstractArray, g₁::AbstractArray, g₂::AbstractArray, f::NonmaximaSuppression)

Изолирует локальные максимумы величины градиента mag вдоль направления локального градиента и сохраняет результат в out. Аргументы g₁ и g₂ представляют градиент в первом пространственном измерении (y) и градиент во втором пространственном измерении (x), соответственно.

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

TODO

Пример

using TestImages, FileIO, ImageView, ImageEdgeDetection, ImageFiltering

img =  testimage("mandril_gray")

# Градиент в первом и втором пространственном измерении
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# Величина градиента
mag = hypot.(g₁, g₂)

nms = zeros(eltype(mag), axes(mag))
# Создание экземпляра функтора NonmaximaSuppression.
f = NonmaximaSuppression()

# Подавление немаксимальных величин градиента и сохранение результата в `nms`.
f(nms, mag, g₁, g₂)

imshow(img)
imshow(mag)
imshow(nms)

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

J.Canny, A Computational Approach to Edge Detection, in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. PAMI-8, no. 6, pp. 679-698, Nov. 1986, doi: 10.1109/TPAMI.1986.4767851.

Подавление немаксимумов (субпиксели)

# ImageEdgeDetection.SubpixelNonmaximaSuppression — Type

    SubpixelNonmaximaSuppression <: AbstractEdgeThinningAlgorithm
    SubpixelNonmaximaSuppression(; threshold::Union{Number, Percentile} = Percentile(20))

    f = SubpixelNonmaximaSuppression()
    f(out₁::AbstractArray, out₂::Matrix{<:AbstractArray}, mag::AbstractArray, g₁::AbstractArray, g₂::AbstractArray, f::SubpixelNonmaximaSuppression)

Изолирует локальные максимумы величины градиента mag вдоль направления локального градиента с субпиксельной точностью. Аргументы g₁ и g₂ представляют градиент в первом пространственном измерении (y) и градиент во втором пространственном измерении (x), соответственно.

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

TODO

Пример

using TestImages, FileIO, ImageView, ImageEdgeDetection, ImageFiltering

img =  testimage("mandril_gray")

# Градиент в первом и втором пространственном измерении
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# Величина градиента
mag = hypot.(g₁, g₂)

nms = zeros(eltype(mag), axes(mag))
subpixel_offsets = zeros(SVector{2,Float64}, axes(mag))

# Создание экземпляра функтора NonmaximaSuppression.
f = SubpixelNonmaximaSuppression()

# Подавление немаксимальных величин градиента и сохранение результата в `nms`.
f(nms, subpixel_offsets, mag, g₁, g₂)

imshow(img)
imshow(mag)
imshow(nms)

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

J. Canny, A Computational Approach to Edge Detection, in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. PAMI-8, no. 6, pp. 679-698, Nov. 1986, doi: 10.1109/TPAMI.1986.4767851.
F. Devernay, A non-maxima suppression method for edge detection with sub-pixel accuracy, Tech. Report RR-2724, INRIA, 1995.

Тип OrientationConvention

# ImageEdgeDetection.OrientationConvention — Type

    OrientationConvention(; compass_direction::AbstractChar = 'S', is_clockwise::Bool = false, in_radians = true, tol = sqrt(eps(Float64)))

Указывает контекст системы координат для detect_gradient_orientation, который определяет значение углов (ориентации градиента).

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

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

Если in_radians = true, допустимые углы находятся в диапазоне [0...2π), в противном случае — в диапазоне [0...360). Значения 2π и 360 используются в качестве контрольных для обозначения неопределенных углов (поскольку величина градиента была слишком близка к нулю). По умолчанию угол не определен, если (abs(g₁) < tol && abs(g₂) < tol), где g₁ и g₂ обозначают градиент в первом и втором пространственных измерениях, и tol = sqrt(eps(Float64)).

Пример

using TestImages, FileIO, ImageView, ImageEdgeDetection, ImageFiltering

img =  testimage("mandril_gray")

# Градиент в первом и втором пространственном измерении
g₁, g₂ = imgradients(img, KernelFactors.scharr)

# Интерпретация углов с учетом канонической декартовой системы координат,
# где углы измеряются против часовой стрелки от положительного направления оси x.

orientation_convention = OrientationConvention(in_radians = true,
                                               is_clockwise = false,
                                               compass_direction = 'E')
angles = detect_gradient_orientation(g₁, g₂, orientation_convention)

Вспомогательные типы

# ImageEdgeDetection.Percentile — Type

Percentile(x)

Indicate that x should be interpreted as a percentile rather than an absolute value. For example,

detect_edges(img, Canny(high = 80, low = 20)) uses absolute thresholds on the edge magnitudes
detect_edges(img, Canny(high = Percentile(80), low = Percentile(20))) uses percentiles of the edge magnitude image as threshold

ImageEdgeDetection.Canny
ImageEdgeDetection.EdgeDetectionAPI.AbstractEdgeDetectionAlgorithm
ImageEdgeDetection.EdgeDetectionAPI.AbstractEdgeThinningAlgorithm
ImageEdgeDetection.NonmaximaSuppression
ImageEdgeDetection.OrientationConvention
ImageEdgeDetection.Percentile
ImageEdgeDetection.SubpixelNonmaximaSuppression
ImageEdgeDetection.EdgeDetectionAPI.detect_edges
ImageEdgeDetection.EdgeDetectionAPI.detect_edges!
ImageEdgeDetection.EdgeDetectionAPI.detect_subpixel_edges
ImageEdgeDetection.EdgeDetectionAPI.detect_subpixel_edges!
ImageEdgeDetection.EdgeDetectionAPI.thin_edges
ImageEdgeDetection.EdgeDetectionAPI.thin_edges!
ImageEdgeDetection.EdgeDetectionAPI.thin_subpixel_edges
ImageEdgeDetection.EdgeDetectionAPI.thin_subpixel_edges!
ImageEdgeDetection.detect_gradient_orientation
ImageEdgeDetection.detect_gradient_orientation!