Merge pull request #93 from JuliaImages/vs/cleanup-and-coverage

Cleanup (depth table, OpenCVError, split overrides) + coverage 50%→80%

Author: ViralBShah

Project.toml

@@ -1,7 +1,7 @@
 name = "OpenCV"
 uuid = "f878e3a2-a245-4720-8660-60795d644f2a"
 authors = ["Archit Rungta <architrungta120@gmail.com>"]
-version = "4.9.1"
+version = "4.10.0"
 
 [deps]
 CxxWrap = "1f15a43c-97ca-5a2a-ae31-89f07a497df4"

README.md

@@ -34,7 +34,7 @@ using OpenCV
 
 Once imported, you can call OpenCV functions and use its data structures. Here's a simple example that loads an image and applies a Gaussian blur:
 
-List of wrapped methods is available here: [wrapped methods](https://github.com/opencv/opencv_contrib/blob/4.x/modules/julia/gen/funclist.csv)
+List of wrapped methods is available here: [wrapped methods](https://github.com/JuliaImages/OpenCV.jl/blob/master/gen/funclist.csv)
 ```julia
 using ImageCore, OpenCV, TestImages, MosaicViews, ImageView
 

codecov.yml

@@ -6,3 +6,10 @@ coverage:
     patch:
       default:
         informational: true
+
+# The CxxWrap bindings under src/generated/ are machine-generated from OpenCV
+# headers (see gen/, reproducibility enforced by Regenerate.yml), not
+# hand-maintained, so exclude them from coverage. Only the hand-written glue in
+# src/ is reported.
+ignore:
+  - "src/generated/**"

src/cv_cxx.jl

@@ -18,6 +18,7 @@ function __init__()
 end
 const Scalar = Union{Tuple{}, Tuple{Number}, Tuple{Number, Number}, Tuple{Number, Number, Number}, NTuple{4, Number}}
 
+include("errors.jl")
 include("Mat.jl")
 
 const InputArray = Union{AbstractArray{T, 3} where {T <: dtypes}, CxxMat}
@@ -55,4 +56,7 @@ julia_to_cpp(c::Char) = Cchar(c)
 
 include("generated/cv_cxx_wrap.jl")
 
-include("cv_manual_wrap.jl")
+# Hand-written overrides of the generated wrappers, grouped by concern.
+include("overrides/defaults.jl")     # default-argument convenience constructors
+include("overrides/covariance.jl")   # AbstractVector{<:InputArray} covariant overloads
+include("overrides/convenience.jl")  # GUI callbacks, CascadeClassifier, VideoWriter_fourcc

src/cv_manual_wrap.jl

@@ -0,0 +1,17 @@
+"""
+    OpenCVError(msg) <: Exception
+
+Error raised by OpenCV.jl's binding layer — e.g. an unsupported array element type
+when converting to or from a `cv::Mat`.
+
+!!! note
+    Errors thrown by OpenCV's own C++ code (`cv::Exception`, assertion failures)
+    currently surface as `ErrorException`s carrying the C++ message. Re-wrapping those
+    as `OpenCVError` would require the generated wrappers to emit `try`/`catch` and is
+    not yet done.
+"""
+struct OpenCVError <: Exception
+    msg::String
+end
+
+Base.showerror(io::IO, e::OpenCVError) = print(io, "OpenCVError: ", e.msg)

src/errors.jl

@@ -32,14 +32,17 @@ function load(f::File{T}, flags::Int64) where {T<:_IMAGE_DATA_FORMATS}
 end
 
 function load(s::Stream{T}) where {T<:_IMAGE_DATA_FORMATS}
-    data = read(stream(s))
-    img = imdecode(reshape(data, 1, 1, :))
+    # `Base.read`, not the generated cv::read wrappers that shadow `read` here.
+    # The byte buffer is decoded via the `imdecode(::AbstractVector{UInt8})`
+    # convenience method (issue #58).
+    data = Base.read(stream(s))
+    img = imdecode(data)
     return img
 end
 
 function load(s::Stream{T}, flags::Int64) where {T<:_IMAGE_DATA_FORMATS}
-    data = read(stream(s))
-    img = imdecode(reshape(data, 1, 1, :), flags)
+    data = Base.read(stream(s))
+    img = imdecode(data, flags)
     return img
 end
 

src/fileio.jl

@@ -16,25 +16,40 @@ 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
 
+# Bijective map between Julia element types and OpenCV depth constants. The two
+# conversion directions below both look this up rather than repeating a 7-branch
+# `if`/`elseif` ladder; adding a supported dtype is a single entry here.
+const _CV_DEPTH = (
+    (UInt8,   CV_8U),
+    (Int8,    CV_8S),
+    (UInt16,  CV_16U),
+    (Int16,   CV_16S),
+    (Int32,   CV_32S),
+    (Float32, CV_32F),
+    (Float64, CV_64F),
+)
+
+# OpenCV depth constant for a Julia element type (throws on unsupported types).
+function _cv_depth(::Type{T}) where {T}
+    for (jt, depth) in _CV_DEPTH
+        jt === T && return depth
+    end
+    throw(OpenCVError("unsupported array element type $T for cv::Mat; expected one " *
+                      "of UInt8, Int8, UInt16, Int16, Int32, Float32, Float64"))
+end
+
+# Julia element type for an OpenCV type flag + channel count (throws on unknown flag).
+function _julia_eltype(cvtype, channels)
+    for (jt, depth) in _CV_DEPTH
+        cvtype == CV_MAKE_TYPE(depth, channels) && return jt
+    end
+    throw(OpenCVError("unsupported cv::Mat type returned from OpenCV " *
+                      "(type flag $cvtype, $channels channel(s))"))
+end
+
 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
+    dtype = _julia_eltype(rets[2], rets[3])
     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
@@ -83,21 +98,8 @@ function julia_to_cpp(img::InputArray)
 
         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
+        cvtype = CV_MAKE_TYPE(_cv_depth(eltype(img)), size(img)[1])
+        return CxxMat(2, pointer(ndims_a), cvtype, Ptr{Nothing}(pointer(img)), pointer(steps_a))
     else
         # Copy array, invalid config
         return julia_to_cpp(img[:, :, :])

src/mat_conversion.jl

@@ -0,0 +1,47 @@
+# Hand-written convenience wrappers: GUI callbacks (which need closures GC-protected),
+# CascadeClassifier helpers, and the string form of VideoWriter_fourcc.
+
+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 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
+
+## Convenience: mirror Python's `cv.VideoWriter_fourcc(*"h264")`. Issue #31.
+function VideoWriter_fourcc(s::AbstractString)
+    length(s) == 4 ||
+        throw(ArgumentError("VideoWriter_fourcc expects a 4-character codec tag, got $(repr(s))"))
+    VideoWriter_fourcc(s[1], s[2], s[3], s[4])
+end