-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Functional Combinators for Computer Vision
--
-- Initial version; using HOpenCV as a backend
@package cv-combinators
@version 0.1
-- | Framework for expressing monadic actions that require initialization
-- and finalizers. This module provides a *functional* interface for
-- defining and chaining a series of processors.
--
-- Motivating example: bindings to C libraries that use functions such
-- as: f(foo *src, foo *dst), where the pointer dst must be
-- pre-allocated. In this case we normally do:
--
-- foo *dst = allocateFoo(); ... while (something) { f(src, dst); ... }
-- releaseFoo(dst);
--
-- You can use the runUntil function below to emulate that loop.
--
-- Processor is an instance of Category, Functor, Applicative and Arrow.
module AI.CV.Processor
-- | The type of Processors
--
-- The semantic model is:
--
--
-- [[ Processor m o a b ]] = a -> b
--
--
-- The idea is that the monad m is usually IO, and that a and b are
-- usually pointers. It is meant for functions that require a
-- pre-allocated output pointer to operate.
--
--
-- - a, b = the input and output types of the processor (think a ->
-- b)
-- - m = monad in which the processor operates
-- - x = type of internal state
--
--
-- The arguments to the constructor are:
--
--
-- - Processing function: Takes input and internal state, and returns
-- new internal state.
-- - Allocator for internal state (this is run only once): Takes
-- (usually the first) input, and returns initial internal state.
-- - Convertor from state x to output b: Takes internal state and
-- returns the output.
-- - Releaser for internal state (finalizer, run once): Run after
-- processor is done being used, to release the internal state.
--
data Processor m a b
Processor :: (a -> x -> m x) -> (a -> m x) -> (x -> m b) -> (x -> m ()) -> Processor m a b
processor :: (Monad m) => (a -> x -> m x) -> (a -> m x) -> (x -> m b) -> (x -> m ()) -> Processor m a b
-- | Chains two processors serially, so one feeds the next.
chain :: (Monad m) => Processor m a b' -> Processor m b' b -> Processor m a b
-- | A processor that represents two sub-processors in parallel (although
-- the current implementation runs them sequentially, but that may change
-- in the future)
parallel :: (Monad m) => Processor m a b -> Processor m c d -> Processor m (a, c) (b, d)
-- | Constructs a processor that: given two processors, gives source as
-- input to both processors and runs them independently, and after both
-- have have finished, outputs their combined outputs.
--
-- Semantic meaning, using Arrow's (&&&) operator: [[
-- forkJoin ]] = &&& Or, considering the Monad instance of
-- functions (which are the semantic meanings of a processor): [[
-- forkJoin ]] = liftM2 (,) Alternative implementation to consider: f
-- &&& g = (,) & f * g
forkJoin :: (Monad m) => Processor m a b -> Processor m a b' -> Processor m a (b, b')
-- | The identity processor: output = input. Semantically, [[ empty ]] = id
empty :: (Monad m) => Processor m a a
-- | Splits (duplicates) the output of a functor, or on this case a
-- processor.
split :: (Functor f) => f a -> f (a, a)
-- | 'f --< g' means: split f and feed it into g. Useful for feeding
-- parallelized (***'d) processors. For example, a --< (b
-- &&& c)
(--<) :: (Functor (cat a), Category cat) => cat a a1 -> cat (a1, a1) c -> cat a c
-- | Runs the processor once: allocates, processes, converts to output, and
-- deallocates.
run :: (Monad m) => Processor m a b -> a -> m b
-- | Keeps running the processing function in a loop until a predicate on
-- the output is true. Useful for processors whose main function is after
-- the allocation and before deallocation.
runUntil :: (Monad m) => Processor m a b -> a -> (b -> m Bool) -> m b
-- | Runs the processor once, but passes the processing + conversion action
-- to the given function.
runWith :: (Monad m) => (m b -> m b') -> Processor m a b -> a -> m b'
instance (Monad m) => Arrow (Processor m)
instance (Monad m) => Applicative (Processor m a)
instance (Monad m) => Functor (Processor m a)
instance (Monad m) => Category (Processor m)
-- | ImageProcessors is a functional (Processor-based) interface to
-- computer vision using OpenCV.
--
-- The Processor interface allows the primitives in this library to take
-- care of all the allocation / deallocation of resources and other
-- setup/teardown requirements, and to appropriately nest them when
-- combining primitives.
--
-- Simple example:
--
--
-- win = window 0 -- The number is essentially a label for the window
-- cam = camera 0 -- Autodetect camera
-- edge = canny 30 190 3 -- Edge detecting processor using canny operator
--
-- test = win . edge . cam -- A processor that captures frames from camera and displays edge-detected version in the window.
--
module AI.CV.ImageProcessors
type ImageSink = Processor IO (Ptr IplImage) ()
type ImageSource = Processor IO () (Ptr IplImage)
type ImageProcessor = Processor IO (Ptr IplImage) (Ptr IplImage)
-- | Some general utility functions for use with Processors and OpenCV
--
-- Predicate for pressed keys
keyPressed :: (Show a) => a -> IO Bool
-- | Runs the processor until a predicate is true, for predicates, and
-- processors that take () as input (such as chains that start with a
-- camera).
runTill :: (Monad m) => Processor m () b -> (b -> m Bool) -> m b
-- | Name (and type) says it all.
runTillKeyPressed :: (Show a) => Processor IO () a -> IO ()
-- | A capture device, using OpenCV's HighGui lib's cvCreateCameraCapture
-- should work with most webcames. See OpenCV's docs for information.
-- This processor outputs the latest image from the camera at each
-- invocation.
camera :: Int -> ImageSource
-- | A window that displays images. Note: windows with the same index will
-- be the same window....is this ok?
window :: Int -> ImageSink
-- | A convenience function for constructing a common type of processors
-- that work exclusively on images
imageProcessor :: (Ptr IplImage -> Ptr IplImage -> IO (Ptr IplImage)) -> (Ptr IplImage -> IO (Ptr IplImage)) -> ImageProcessor
-- | OpenCV's cvResize
resize :: Int -> Int -> InterpolationMethod -> ImageProcessor
-- | OpenCV's cvDilate
dilate :: Int -> ImageProcessor
-- | OpenCV's cvCanny
canny :: Int -> Int -> Int -> ImageProcessor
-- | Wrapper for OpenCV's cvHaarDetectObjects and the surrounding required
-- things (mem storage, cascade loading, etc).
haarDetect :: String -> Double -> Int -> HaarDetectFlag -> CvSize -> Processor IO (Ptr IplImage) [CvRect]
-- | OpenCV's cvRectangle, currently without width, color or line type
-- control
drawRects :: Processor IO (Ptr IplImage, [CvRect]) (Ptr IplImage)