Added isopen, open! and close! methods for Camera.

* Renamed AbstractAcquiredImage - was AcquiredImage.
* Renamed AcquiredImage - was SimulatedAcquiredImage.
* Moved Camera and methods to a separate file.
* Fixed constructors of SimulatedCamera (omitted init of current_id).
* Implemented Base.show for AcquiredImage, and SimulatedCamera.

Author: stemann

src/Cameras.jl

@@ -2,7 +2,7 @@ module Cameras
 
 using ResourcePools
 
-import Base: take!
+import Base: isopen, take!
 
 import ResourcePools:
     ref_count,
@@ -11,56 +11,23 @@ import ResourcePools:
     retain!
 
 export Camera,
+    open!,
+    close!,
+    isopen,
     isrunning,
-    ref_count,
-    release!,
-    resource,
-    retain!,
     start!,
     stop!,
     take!,
     trigger!
+include("camera.jl")
 
-abstract type Camera end
-
-"""
-    isrunning(camera::Camera)
-
-Return if the camera is running.
-"""
-isrunning(camera::Camera) = error("No implementation for $(typeof(camera))")
-
-"""
-    start!(camera::Camera)
-
-Start camera, i.e. start image acquisition.
-"""
-start!(camera::Camera) = error("No implementation for $(typeof(camera))")
-
-"""
-    stop!(camera::Camera)
-
-Stop camera, i.e. stop image acquisition.
-"""
-stop!(camera::Camera) = error("No implementation for $(typeof(camera))")
-
-"""
-    take!(camera::Camera)
-
-Take an image, i.e. an [`AcquiredImage`](@ref). Blocks until an image is available.
-"""
-take!(camera::Camera)::AcquiredImage = error("No implementation for $(typeof(camera))")
-
-"""
-    trigger!(camera::Camera)
-
-Trigger image acquisition.
-"""
-trigger!(camera::Camera) = error("No implementation for $(typeof(camera))")
-
-export AcquiredImage,
+export AbstractAcquiredImage,
     id,
-    timestamp
+    timestamp,
+    ref_count,
+    release!,
+    resource,
+    retain!
 include("acquired_image.jl")
 
 import Base: iterate, IteratorSize
@@ -69,7 +36,7 @@ export iterate,
 include("iteration.jl")
 
 export SimulatedCamera,
-    SimulatedAcquiredImage
+    AcquiredImage
 include("simulated_camera.jl")
 
 end # module

src/acquired_image.jl

@@ -1,16 +1,40 @@
-abstract type AcquiredImage{T,N} <: AbstractPooledDenseArray{T,N}
+abstract type AbstractAcquiredImage{T,N} <: AbstractPooledDenseArray{T,N}
 end
 
 """
     id(image::AcquiredImage)
 
 Return image ID.
 """
-id(image::AcquiredImage) = error("No implementation for $(typeof(image))")
+id(image::AbstractAcquiredImage) = error("No implementation for $(typeof(image))")
 
 """
     timestamp(image::AcquiredImage)
 
 Return image timestamp.
 """
-timestamp(image::AcquiredImage) = error("No implementation for $(typeof(image))")
+timestamp(image::AbstractAcquiredImage) = error("No implementation for $(typeof(image))")
+
+
+mutable struct AcquiredImage{T,N} <: AbstractAcquiredImage{T,N}
+    # Inherits behaviour of AbstractPooledDenseArray, by having the same fields
+    array::Array{T,N}
+    ref_count::Int
+    dispose::Function
+
+    id::Int
+    timestamp::Int
+    function AcquiredImage(a::Array{T,N}, id, timestamp) where {T,N}
+        function dispose(img)
+            @debug "Disposing $img"
+        end
+        new{T,N}(a, 1, dispose, id, timestamp)
+    end
+end
+
+id(img::AcquiredImage) = img.id
+timestamp(img::AcquiredImage) = img.timestamp
+
+function Base.show(io::IO, image::AcquiredImage)
+    write(io, "$(nameof(AcquiredImage))(id:$(image.id), timestamp:$(image.timestamp), ref_count:$(image.ref_count), array:$(image.array))")
+end

src/camera.jl

@@ -0,0 +1,57 @@
+abstract type Camera end
+
+"""
+    open!(camera::Camera)
+
+Open camera.
+"""
+open!(camera::Camera) = error("No implementation for $(typeof(camera))")
+
+"""
+    close!(camera::Camera)
+
+Close camera.
+"""
+close!(camera::Camera) = error("No implementation for $(typeof(camera))")
+
+"""
+    isopen(camera::Camera)
+
+Return if the camera is open.
+"""
+isopen(camera::Camera) = error("No implementation for $(typeof(camera))")
+
+"""
+    isrunning(camera::Camera)
+
+Return if the camera is running.
+"""
+isrunning(camera::Camera) = error("No implementation for $(typeof(camera))")
+
+"""
+    start!(camera::Camera)
+
+Start camera, i.e. start image acquisition.
+"""
+start!(camera::Camera) = error("No implementation for $(typeof(camera))")
+
+"""
+    stop!(camera::Camera)
+
+Stop camera, i.e. stop image acquisition.
+"""
+stop!(camera::Camera) = error("No implementation for $(typeof(camera))")
+
+"""
+    take!(camera::Camera)
+
+Take an image, i.e. an [`AbstractAcquiredImage`](@ref). Blocks until an image is available.
+"""
+take!(camera::Camera)::AbstractAcquiredImage = error("No implementation for $(typeof(camera))")
+
+"""
+    trigger!(camera::Camera)
+
+Trigger image acquisition.
+"""
+trigger!(camera::Camera) = error("No implementation for $(typeof(camera))")

src/simulated_camera.jl

@@ -1,60 +1,44 @@
 mutable struct SimulatedCamera <: Camera
-    isrunning::Bool
-    trigger_source::Channel
+    trigger_source::Channel{UInt64}
     image_source::Channel
-    next_id::Int
-    SimulatedCamera(image_source::Channel) = new(false, Channel(Inf), image_source)
-    SimulatedCamera(trigger_source::Channel, image_source::Channel) = new(false, trigger_source, image_source)
+    isopen::Bool
+    isrunning::Bool
+    current_id::Int
+    SimulatedCamera(image_source::Channel) = new(Channel{UInt64}(Inf), image_source, false, false, 0)
+    SimulatedCamera(trigger_source::Channel{UInt64}, image_source::Channel) = new(trigger_source, image_source, false, false, 0)
     function SimulatedCamera(trigger_period::Real, image_source::Channel)
-        function produce_triggers!(trigger_source::Channel)
+        function produce_triggers!(trigger_source::Channel{UInt64})
             while true
                 sleep(trigger_period)
                 put!(trigger_source, time_ns())
             end
         end
-        trigger_source = Channel(produce_triggers!)
-        new(false, trigger_source, image_source, 0)
-    end
-end
-
-mutable struct SimulatedAcquiredImage{T,N} <: AcquiredImage{T,N}
-    # Inherits behaviour of AbstractPooledDenseArray, by having the same fields
-    array::Array{T,N}
-    ref_count::Int
-    dispose::Function
-
-    is_disposed::Bool
-    id::Int
-    timestamp::Int
-    function SimulatedAcquiredImage(a::Array{T,N}, id, timestamp) where {T,N}
-        function dispose(img)
-            @debug "Disposing $img"
-            img.is_disposed = true
-        end
-        new{T,N}(a, 1, dispose, false, id, timestamp)
+        trigger_source = Channel(produce_triggers!; ctype = UInt64)
+        new(trigger_source, image_source, false, false, 0)
     end
 end
 
-id(img::SimulatedAcquiredImage) = img.id
-timestamp(img::SimulatedAcquiredImage) = img.timestamp
+isopen(camera::SimulatedCamera) = camera.isopen
+open!(camera::SimulatedCamera) = camera.isopen = true
+close!(camera::SimulatedCamera) = camera.isopen = false
 
 isrunning(camera::SimulatedCamera) = camera.isrunning
-
-function start!(camera::SimulatedCamera)
-    camera.isrunning = true
-end
-
-function stop!(camera::SimulatedCamera)
-    camera.isrunning = false
-end
+start!(camera::SimulatedCamera) = camera.isrunning = true
+stop!(camera::SimulatedCamera) = camera.isrunning = false
 
 function take!(camera::SimulatedCamera)
+    @debug "Taking image from $(camera.image_source)"
     image = take!(camera.image_source)
-    id = camera.next_id += 1
+    id = camera.current_id += 1
+    @debug "Taking trigger from $(camera.trigger_source)"
     timestamp = take!(camera.trigger_source)
-    return SimulatedAcquiredImage(image, id, timestamp)
+    return AcquiredImage(image, id, timestamp)
 end
 
 function trigger!(camera::SimulatedCamera)
     put!(camera.trigger_source, time_ns())
 end
+
+function Base.show(io::IO, camera::SimulatedCamera)
+    write(io, "$(nameof(SimulatedCamera))(trigger_source:$(camera.trigger_source), image_source:$(camera.image_source), current_id:$(camera.current_id))")
+end

test/acquired_image.jl

@@ -16,7 +16,7 @@ using Test
     t_1 = time_ns()
     trigger!(camera)
     img = take!(camera)
-    @test typeof(img) <: AcquiredImage
+    @test typeof(img) <: AbstractAcquiredImage
     @assert size(img) == image_size
 
     @test ref_count(img) == 1
@@ -27,10 +27,6 @@ using Test
     release!(img)
     @test ref_count(img) == 1
 
-    @assert !img.is_disposed
-    release!(img)
-    @test img.is_disposed
-
     @test id(img) == 1
     @test timestamp(img) >= t_1
 

test/acquisition.jl

@@ -14,6 +14,10 @@ using Test
     @testset "Manually triggered" begin
         camera = SimulatedCamera(image_source)
 
+        @test !isopen(camera)
+        open!(camera)
+        @test isopen(camera)
+
         @test !isrunning(camera)
         start!(camera)
         @test isrunning(camera)
@@ -33,18 +37,26 @@ using Test
                 @test size(img) == image_size
             end
         end
+
+        @assert isrunning(camera)
+        stop!(camera)
+        @test !isrunning(camera)
+
+        @assert isopen(camera)
+        close!(camera)
+        @test !isopen(camera)
     end
 
     @testset "Continuously triggered" begin
         period = 0.04 # seconds
 
-        function produce_triggers!(trigger_source::Channel)
+        function produce_triggers!(trigger_source::Channel{UInt64})
             while true
                 put!(trigger_source, time_ns())
                 sleep(period)
             end
         end
-        trigger_source = Channel(produce_triggers!)
+        trigger_source = Channel(produce_triggers!; ctype = UInt64)
 
         continuous_camera = SimulatedCamera(trigger_source, image_source)