vendor: OpenCV 5.0.0 snapshot at 755e50675d97db9b7d449d8bd6b09888646f6c6e
This commit is contained in:
Gitea Mirror Bot
@@ -0,0 +1,49 @@
|
||||
#Adapted from IndirectArray
|
||||
|
||||
struct Mat{T <: dtypes} <: AbstractArray{T,3}
|
||||
mat
|
||||
data_raw
|
||||
data
|
||||
|
||||
@inline function Mat{T}(mat, data_raw::AbstractArray{T,3}) where {T <: dtypes}
|
||||
data = reinterpret(T, data_raw)
|
||||
new{T}(mat, data_raw, data)
|
||||
end
|
||||
|
||||
@inline function Mat(data_raw::AbstractArray{T, 3}) where {T <: dtypes}
|
||||
data = reinterpret(T, data_raw)
|
||||
mat = nothing
|
||||
new{T}(mat, data_raw, data)
|
||||
end
|
||||
end
|
||||
|
||||
function Base.deepcopy_internal(x::Mat{T}, y::IdDict) where {T}
|
||||
if haskey(y, x)
|
||||
return y[x]
|
||||
end
|
||||
ret = Base.copy(x)
|
||||
y[x] = ret
|
||||
return ret
|
||||
end
|
||||
|
||||
Base.size(A::Mat) = size(A.data)
|
||||
Base.axes(A::Mat) = axes(A.data)
|
||||
Base.IndexStyle(::Type{Mat{T}}) where {T} = IndexCartesian()
|
||||
|
||||
Base.strides(A::Mat{T}) where {T} = strides(A.data)
|
||||
Base.copy(A::Mat{T}) where {T} = Mat(copy(A.data_raw))
|
||||
Base.pointer(A::Mat) = Base.pointer(A.data)
|
||||
|
||||
Base.unsafe_convert(::Type{Ptr{T}}, A::Mat{S}) where {T, S} = Base.unsafe_convert(Ptr{T}, A.data)
|
||||
|
||||
@inline function Base.getindex(A::Mat{T}, I::Vararg{Int,3}) where {T}
|
||||
@boundscheck checkbounds(A.data, I...)
|
||||
@inbounds ret = A.data[I...]
|
||||
ret
|
||||
end
|
||||
|
||||
@inline function Base.setindex!(A::Mat, x, I::Vararg{Int,3})
|
||||
@boundscheck checkbounds(A.data, I...)
|
||||
A.data[I...] = x
|
||||
return A
|
||||
end
|
||||
@@ -0,0 +1,11 @@
|
||||
|
||||
module OpenCV
|
||||
|
||||
import Base.size
|
||||
|
||||
include("cv_cxx.jl")
|
||||
|
||||
|
||||
include("cv_wrap.jl")
|
||||
|
||||
end
|
||||
@@ -0,0 +1,50 @@
|
||||
#Adapted from IndirectArray
|
||||
|
||||
struct Vec{T, N} <: AbstractArray{T,1}
|
||||
cpp_object
|
||||
data::AbstractArray{T, 1}
|
||||
cpp_allocated::Bool
|
||||
@inline function Vec{T, N}(obj) where {T, N}
|
||||
|
||||
new{T, N}(obj, Base.unsafe_wrap(Array{T, 1}, Ptr{T}(obj.cpp_object), N), true)
|
||||
end
|
||||
|
||||
@inline function Vec{T, N}(data_raw::AbstractArray{T, 1}) where {T, N}
|
||||
if size(data_raw, 1) != N
|
||||
throw("Array is improper Size for Vec declared")
|
||||
end
|
||||
new{T, N}(nothing, data_raw, false)
|
||||
end
|
||||
end
|
||||
|
||||
function Base.deepcopy_internal(x::Vec{T,N}, y::IdDict) where {T, N}
|
||||
if haskey(y, x)
|
||||
return y[x]
|
||||
end
|
||||
ret = Base.copy(x)
|
||||
y[x] = ret
|
||||
return ret
|
||||
end
|
||||
|
||||
Base.size(A::Vec) = Base.size(A.data)
|
||||
Base.axes(A::Vec) = Base.axes(A.data)
|
||||
Base.IndexStyle(::Type{Vec{T,N}}) where {T, N} = IndexLinear()
|
||||
|
||||
Base.strides(A::Vec{T,N}) where {T, N} = (1)
|
||||
function Base.copy(A::Vec{T,N}) where {T, N}
|
||||
return Vec{T, N}(copy(A.data))
|
||||
end
|
||||
Base.pointer(A::Vec) = Base.pointer(A.data)
|
||||
|
||||
Base.unsafe_convert(::Type{Ptr{T}}, A::Vec{S, N}) where {T, S, N} = Base.unsafe_convert(Ptr{T}, A.data)
|
||||
|
||||
@inline function Base.getindex(A::Vec{T,N}, I::Int) where {T, N}
|
||||
@boundscheck checkbounds(A.data, I)
|
||||
return A.data[I]
|
||||
end
|
||||
|
||||
@inline function Base.setindex!(A::Vec, x, I::Int)
|
||||
@boundscheck checkbounds(A.data, I)
|
||||
A.data[I] = x
|
||||
return A
|
||||
end
|
||||
@@ -0,0 +1,52 @@
|
||||
# using StaticArrays
|
||||
|
||||
include("typestructs.jl")
|
||||
include("Vec.jl")
|
||||
const dtypes = Union{UInt8, Int8, UInt16, Int16, Int32, Float32, Float64}
|
||||
size_t = UInt64
|
||||
|
||||
using CxxWrap
|
||||
@wrapmodule(joinpath(@__DIR__,"lib","libopencv_julia"), :cv_wrap)
|
||||
function __init__()
|
||||
@initcxx
|
||||
|
||||
if jlopencv_core_get_sizet()==4
|
||||
size_t = UInt32
|
||||
end
|
||||
end
|
||||
const Scalar = Union{Tuple{}, Tuple{Number}, Tuple{Number, Number}, Tuple{Number, Number, Number}, NTuple{4, Number}}
|
||||
|
||||
include("Mat.jl")
|
||||
|
||||
const InputArray = Union{AbstractArray{T, 3} where {T <: dtypes}, CxxMat}
|
||||
|
||||
include("mat_conversion.jl")
|
||||
include("types_conversion.jl")
|
||||
|
||||
function cpp_to_julia(var)
|
||||
return var
|
||||
end
|
||||
function julia_to_cpp(var)
|
||||
return var
|
||||
end
|
||||
|
||||
function cpp_to_julia(var::Tuple)
|
||||
ret_arr = Array{Any, 1}()
|
||||
for it in var
|
||||
push!(ret_arr, cpp_to_julia(it))
|
||||
end
|
||||
return tuple(ret_arr...)
|
||||
end
|
||||
|
||||
function cpp_to_julia(var::CxxBool)
|
||||
return Bool(var)
|
||||
end
|
||||
|
||||
function julia_to_cpp(var::Bool)
|
||||
return CxxBool(var)
|
||||
end
|
||||
|
||||
|
||||
include("cv_cxx_wrap.jl")
|
||||
|
||||
include("cv_manual_wrap.jl")
|
||||
@@ -0,0 +1,49 @@
|
||||
|
||||
function createButton(bar_name::String, on_change, userdata, type::Int32 = 0, initial_button_state::Bool = false)
|
||||
func = (x)->on_change(x, userdata)
|
||||
CxxWrap.gcprotect(userdata)
|
||||
CxxWrap.gcprotect(func)
|
||||
CxxWrap.gcprotect(on_change)
|
||||
return jl_cpp_cv2.createButton(bar_name,func, type, initial_button_state)
|
||||
end
|
||||
|
||||
function setMouseCallback(winname::String, onMouse, userdata)
|
||||
func = (event, x, y, flags)->onMouse(event, x, y, flags, userdata)
|
||||
CxxWrap.gcprotect(userdata)
|
||||
CxxWrap.gcprotect(func)
|
||||
CxxWrap.gcprotect(onMouse)
|
||||
return jl_cpp_cv2.setMouseCallback(winname,func)
|
||||
end
|
||||
|
||||
function createTrackbar(trackbarname::String, winname::String, value::Ref{Int32}, count::Int32, onChange, userdata)
|
||||
func = (x)->onChange(x, userdata)
|
||||
CxxWrap.gcprotect(userdata)
|
||||
CxxWrap.gcprotect(func)
|
||||
CxxWrap.gcprotect(onChange)
|
||||
return jl_cpp_cv2.createTrackbar(trackbarname, winname, value, count, func)
|
||||
end
|
||||
|
||||
function CascadeClassifier(filename::String)
|
||||
return cpp_to_julia(jlopencv_cv_cv_CascadeClassifier_cv_CascadeClassifier_CascadeClassifier(julia_to_cpp(filename)))
|
||||
end
|
||||
|
||||
|
||||
function detect(cobj::cv_Ptr{T}, image::InputArray, mask::InputArray) where {T <: Feature2D}
|
||||
return cpp_to_julia(jlopencv_cv_cv_Feature2D_cv_Feature2D_detect(julia_to_cpp(cobj),julia_to_cpp(image),julia_to_cpp(mask)))
|
||||
end
|
||||
detect(cobj::cv_Ptr{T}, image::InputArray; mask::InputArray = (CxxMat())) where {T <: Feature2D} = detect(cobj, image, mask)
|
||||
|
||||
|
||||
function detectMultiScale(cobj::CascadeClassifier, image::InputArray, scaleFactor::Float64, minNeighbors::Int32, flags::Int32, minSize::Size{Int32}, maxSize::Size{Int32})
|
||||
return cpp_to_julia(jlopencv_cv_cv_CascadeClassifier_cv_CascadeClassifier_detectMultiScale(julia_to_cpp(cobj),julia_to_cpp(image),julia_to_cpp(scaleFactor),julia_to_cpp(minNeighbors),julia_to_cpp(flags),julia_to_cpp(minSize),julia_to_cpp(maxSize)))
|
||||
end
|
||||
detectMultiScale(cobj::CascadeClassifier, image::InputArray; scaleFactor::Float64 = Float64(1.1), minNeighbors::Int32 = Int32(3), flags::Int32 = Int32(0), minSize::Size{Int32} = (Size{Int32}(0,0)), maxSize::Size{Int32} = (Size{Int32}(0,0))) = detectMultiScale(cobj, image, scaleFactor, minNeighbors, flags, minSize, maxSize)
|
||||
|
||||
function empty(cobj::CascadeClassifier)
|
||||
return cpp_to_julia(jlopencv_cv_cv_CascadeClassifier_cv_CascadeClassifier_empty(julia_to_cpp(cobj)))
|
||||
end
|
||||
|
||||
function SimpleBlobDetector_create(parameters::SimpleBlobDetector_Params)
|
||||
return cpp_to_julia(jlopencv_cv_cv_SimpleBlobDetector_create(julia_to_cpp(parameters)))
|
||||
end
|
||||
SimpleBlobDetector_create(; parameters::SimpleBlobDetector_Params = (SimpleBlobDetector_Params())) = SimpleBlobDetector_create(parameters)
|
||||
@@ -0,0 +1,106 @@
|
||||
const CV_CN_MAX = 512
|
||||
const CV_CN_SHIFT = 3
|
||||
const CV_DEPTH_MAX = (1 << CV_CN_SHIFT)
|
||||
|
||||
const CV_8U = 0
|
||||
const CV_8S = 1
|
||||
const CV_16U = 2
|
||||
const CV_16S = 3
|
||||
const CV_32S = 4
|
||||
const CV_32F = 5
|
||||
const CV_64F = 6
|
||||
|
||||
const CV_MAT_DEPTH_MASK = (CV_DEPTH_MAX - 1)
|
||||
CV_MAT_DEPTH(flags) = ((flags) & CV_MAT_DEPTH_MASK)
|
||||
|
||||
CV_MAKETYPE(depth,cn) = (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
|
||||
CV_MAKE_TYPE = CV_MAKETYPE
|
||||
|
||||
function cpp_to_julia(mat::CxxMat)
|
||||
rets = jlopencv_core_Mat_mutable_data(mat)
|
||||
if rets[2] == CV_MAKE_TYPE(CV_8U, rets[3])
|
||||
dtype = UInt8
|
||||
elseif rets[2]==CV_MAKE_TYPE(CV_8S, rets[3])
|
||||
dtype = Int8
|
||||
elseif rets[2]==CV_MAKE_TYPE(CV_16U, rets[3])
|
||||
dtype = UInt16
|
||||
elseif rets[2]==CV_MAKE_TYPE(CV_16S, rets[3])
|
||||
dtype = Int16
|
||||
elseif rets[2]==CV_MAKE_TYPE(CV_32S, rets[3])
|
||||
dtype = Int32
|
||||
elseif rets[2]==CV_MAKE_TYPE(CV_32F, rets[3])
|
||||
dtype = Float32
|
||||
elseif rets[2]==CV_MAKE_TYPE(CV_64F, rets[3])
|
||||
dtype = Float64
|
||||
else
|
||||
error("Bad type returned from OpenCV")
|
||||
end
|
||||
steps = [rets[6]/sizeof(dtype), rets[7]/sizeof(dtype)]
|
||||
# println(steps[1]/rets[3], steps[2]/rets[3]/rets[4])
|
||||
#TODO: Implement views when steps do not result in continous memory
|
||||
arr = Base.unsafe_wrap(Array{dtype, 3}, Ptr{dtype}(rets[1].cpp_object), (rets[3], rets[4], rets[5]))
|
||||
|
||||
#Preserve Mat so that array allocated by C++ isn't deallocated
|
||||
return Mat{dtype}(mat, arr)
|
||||
end
|
||||
|
||||
function julia_to_cpp(img::InputArray)
|
||||
if typeof(img) <: CxxMat
|
||||
return img
|
||||
end
|
||||
steps = 0
|
||||
try
|
||||
steps = strides(img)
|
||||
catch
|
||||
# Copy array since array is not strided
|
||||
img = img[:, :, :]
|
||||
steps = strides(img)
|
||||
end
|
||||
|
||||
if steps[1] <= steps[2] <= steps[3] && steps[1]==1
|
||||
steps_a = Array{size_t, 1}()
|
||||
ndims_a = Array{Int32, 1}()
|
||||
sz = sizeof(eltype(img))
|
||||
push!(steps_a, UInt64(steps[3]*sz))
|
||||
push!(steps_a, UInt64(steps[2]*sz))
|
||||
push!(steps_a, UInt64(steps[1]*sz))
|
||||
|
||||
push!(ndims_a, Int32(size(img)[3]))
|
||||
push!(ndims_a, Int32(size(img)[2]))
|
||||
if eltype(img) == UInt8
|
||||
return CxxMat(2, pointer(ndims_a), CV_MAKE_TYPE(CV_8U, size(img)[1]), Ptr{Nothing}(pointer(img)), pointer(steps_a))
|
||||
elseif eltype(img) == UInt16
|
||||
return CxxMat(2, pointer(ndims_a), CV_MAKE_TYPE(CV_16U, size(img)[1]), Ptr{Nothing}(pointer(img)), pointer(steps_a))
|
||||
elseif eltype(img) == Int8
|
||||
return CxxMat(2, pointer(ndims_a), CV_MAKE_TYPE(CV_8S, size(img)[1]), Ptr{Nothing}(pointer(img)), pointer(steps_a))
|
||||
elseif eltype(img) == Int16
|
||||
return CxxMat(2, pointer(ndims_a), CV_MAKE_TYPE(CV_16S, size(img)[1]), Ptr{Nothing}(pointer(img)), pointer(steps_a))
|
||||
elseif eltype(img) == Int32
|
||||
return CxxMat(2, pointer(ndims_a), CV_MAKE_TYPE(CV_32S, size(img)[1]), Ptr{Nothing}(pointer(img)), pointer(steps_a))
|
||||
elseif eltype(img) == Float32
|
||||
return CxxMat(2, pointer(ndims_a), CV_MAKE_TYPE(CV_32F, size(img)[1]), Ptr{Nothing}(pointer(img)), pointer(steps_a))
|
||||
elseif eltype(img) == Float64
|
||||
return CxxMat(2, pointer(ndims_a), CV_MAKE_TYPE(CV_64F, size(img)[1]), Ptr{Nothing}(pointer(img)), pointer(steps_a))
|
||||
end
|
||||
else
|
||||
# Copy array, invalid config
|
||||
return julia_to_cpp(img[:, :, :])
|
||||
end
|
||||
end
|
||||
|
||||
function julia_to_cpp(var::Array{T, 1}) where {T <: InputArray}
|
||||
ret = CxxWrap.StdVector{CxxMat}()
|
||||
for x in var
|
||||
push!(ret, julia_to_cpp(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
|
||||
function cpp_to_julia(var::CxxWrap.StdVector{T}) where {T <: CxxMat}
|
||||
ret = Array{Mat, 1}()
|
||||
for x in var
|
||||
push!(ret, cpp_to_julia(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
@@ -0,0 +1,79 @@
|
||||
function cpp_to_julia(var::CxxScalar{T}) where {T}
|
||||
var = Vec{T, 4}(var)
|
||||
return (var[1], var[2], var[3], var[4])
|
||||
end
|
||||
|
||||
function cpp_to_julia(var::CxxVec{T, N}) where {T, N}
|
||||
return Vec{T, N}(var)
|
||||
end
|
||||
|
||||
function julia_to_cpp(sc::Scalar)
|
||||
if size(sc,1)==0
|
||||
return CxxScalar{Float64}(0,0,0,0)
|
||||
elseif size(sc, 1) == 1
|
||||
return CxxScalar{Float64}(Float64(sc[1]), 0, 0, 0)
|
||||
elseif size(sc,1) == 2
|
||||
return CxxScalar{Float64}(Float64(sc[1]), Float64(sc[2]), 0, 0)
|
||||
elseif size(sc,1) == 3
|
||||
return CxxScalar{Float64}(Float64(sc[1]), Float64(sc[2]), Float64(sc[3]), 0)
|
||||
end
|
||||
return CxxScalar{Float64}(Float64(sc[1]), Float64(sc[2]), Float64(sc[3]), Float64(sc[4]))
|
||||
end
|
||||
|
||||
function julia_to_cpp(vec::Vec{T, N}) where {T, N}
|
||||
return CxxVec{T, N}(Base.pointer(vec))
|
||||
end
|
||||
|
||||
function julia_to_cpp(var::Array{T, 1}) where {T <: Scalar}
|
||||
ret = CxxWrap.StdVector{CxxScalar}()
|
||||
for x in var
|
||||
push!(ret, julia_to_cpp(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
function julia_to_cpp(var::Array{Vec{T, N}, 1}) where {T, N}
|
||||
ret = CxxWrap.StdVector{CxxVec{T, N}}()
|
||||
for x in var
|
||||
push!(ret, julia_to_cpp(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
function julia_to_cpp(var::Array{T, 1}) where {T}
|
||||
if size(var, 1) == 0
|
||||
return CxxWrap.StdVector{T}()
|
||||
end
|
||||
ret = CxxWrap.StdVector{typeof(julia_to_cpp(var[1]))}()
|
||||
for x in var
|
||||
push!(ret, julia_to_cpp(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
function cpp_to_julia(var::CxxWrap.StdVector{T}) where {T <: CxxScalar}
|
||||
ret = Array{Scalar, 1}()
|
||||
for x in var
|
||||
push!(ret, cpp_to_julia(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
function cpp_to_julia(var::CxxWrap.StdVector{CxxVec{T, N}}) where {T, N}
|
||||
ret = Array{Vec{T, N}, 1}()
|
||||
for x in var
|
||||
push!(ret, cpp_to_julia(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
function cpp_to_julia(var::CxxWrap.StdVector{T}) where {T}
|
||||
if size(var, 1) == 0
|
||||
return Array{T, 1}()
|
||||
end
|
||||
ret = Array{typeof(cpp_to_julia(var[1])), 1}()
|
||||
for x in var
|
||||
push!(ret, cpp_to_julia(x))
|
||||
end
|
||||
return ret
|
||||
end
|
||||
@@ -0,0 +1,47 @@
|
||||
|
||||
struct Point{T}
|
||||
x::T
|
||||
y::T
|
||||
end
|
||||
|
||||
struct Point3{T}
|
||||
x::T
|
||||
y::T
|
||||
z::T
|
||||
end
|
||||
|
||||
|
||||
struct Size{T}
|
||||
width::T
|
||||
height::T
|
||||
end
|
||||
|
||||
|
||||
struct Rect{T}
|
||||
x::T
|
||||
y::T
|
||||
width::T
|
||||
height::T
|
||||
end
|
||||
|
||||
struct RotatedRect
|
||||
center::Point{Float32}
|
||||
size::Size{Float32}
|
||||
angle::Float32
|
||||
end
|
||||
|
||||
struct Range
|
||||
start::Int32
|
||||
end_::Int32
|
||||
end
|
||||
|
||||
struct TermCriteria
|
||||
type::Int32
|
||||
maxCount::Int32
|
||||
epsilon::Float64
|
||||
end
|
||||
|
||||
struct cvComplex{T}
|
||||
re::T
|
||||
im::T
|
||||
end
|
||||
Reference in New Issue
Block a user