{-# LINE 1 "CV/Bindings/Types.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface, TypeFamilies #-}
{-# LINE 2 "CV/Bindings/Types.hsc" #-}
module CV.Bindings.Types where

import Data.Word
import Foreign.C.Types
import Foreign.Storable
import Foreign.Ptr
import Foreign.Marshal.Utils
import Foreign.Marshal.Array
import Utils.GeometryClass
import Utils.Rectangle
import qualified Data.Vector.Unboxed as U
import GHC.Float

import Foreign.Ptr (Ptr,FunPtr,plusPtr)
import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)
import Foreign.Storable
import Foreign.C.Types
import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)
import Foreign.Marshal.Alloc (alloca)
import Foreign.Marshal.Array (peekArray,pokeArray)
import Data.Int
import Data.Word

{-# LINE 16 "CV/Bindings/Types.hsc" #-}


{-# LINE 18 "CV/Bindings/Types.hsc" #-}

{-# LINE 19 "CV/Bindings/Types.hsc" #-}

c'IPL_DEPTH_1U = 1
c'IPL_DEPTH_1U :: (Num a) => a

{-# LINE 21 "CV/Bindings/Types.hsc" #-}
c'IPL_DEPTH_8U = 8
c'IPL_DEPTH_8U :: (Num a) => a

{-# LINE 22 "CV/Bindings/Types.hsc" #-}
c'IPL_DEPTH_16U = 16
c'IPL_DEPTH_16U :: (Num a) => a

{-# LINE 23 "CV/Bindings/Types.hsc" #-}
c'IPL_DEPTH_32F = 32
c'IPL_DEPTH_32F :: (Num a) => a

{-# LINE 24 "CV/Bindings/Types.hsc" #-}
c'IPL_DEPTH_8S = 2147483656
c'IPL_DEPTH_8S :: (Num a) => a

{-# LINE 25 "CV/Bindings/Types.hsc" #-}
c'IPL_DEPTH_16S = 2147483664
c'IPL_DEPTH_16S :: (Num a) => a

{-# LINE 26 "CV/Bindings/Types.hsc" #-}
c'IPL_DEPTH_32S = 2147483680
c'IPL_DEPTH_32S :: (Num a) => a

{-# LINE 27 "CV/Bindings/Types.hsc" #-}

c'IPL_BORDER_CONSTANT = 0
c'IPL_BORDER_CONSTANT :: (Num a) => a

{-# LINE 29 "CV/Bindings/Types.hsc" #-}
c'IPL_BORDER_REPLICATE = 1
c'IPL_BORDER_REPLICATE :: (Num a) => a

{-# LINE 30 "CV/Bindings/Types.hsc" #-}
c'IPL_BORDER_REFLECT = 2
c'IPL_BORDER_REFLECT :: (Num a) => a

{-# LINE 31 "CV/Bindings/Types.hsc" #-}
c'IPL_BORDER_WRAP = 3
c'IPL_BORDER_WRAP :: (Num a) => a

{-# LINE 32 "CV/Bindings/Types.hsc" #-}

data C'IplImage = C'IplImage

{-# LINE 34 "CV/Bindings/Types.hsc" #-}
data C'CvMemStorage = C'CvMemStorage

{-# LINE 35 "CV/Bindings/Types.hsc" #-}
data C'CvSeqBlock = C'CvSeqBlock

{-# LINE 36 "CV/Bindings/Types.hsc" #-}
data C'CvArr = C'CvArr

{-# LINE 37 "CV/Bindings/Types.hsc" #-}

data C'CvHistogram = C'CvHistogram

{-# LINE 39 "CV/Bindings/Types.hsc" #-}


{-# LINE 41 "CV/Bindings/Types.hsc" #-}

{-# LINE 42 "CV/Bindings/Types.hsc" #-}

{-# LINE 43 "CV/Bindings/Types.hsc" #-}

{-# LINE 44 "CV/Bindings/Types.hsc" #-}

{-# LINE 45 "CV/Bindings/Types.hsc" #-}

{-# LINE 46 "CV/Bindings/Types.hsc" #-}

{-# LINE 47 "CV/Bindings/Types.hsc" #-}

{-# LINE 48 "CV/Bindings/Types.hsc" #-}

{-# LINE 49 "CV/Bindings/Types.hsc" #-}

{-# LINE 50 "CV/Bindings/Types.hsc" #-}

{-# LINE 51 "CV/Bindings/Types.hsc" #-}

{-# LINE 52 "CV/Bindings/Types.hsc" #-}

{-# LINE 53 "CV/Bindings/Types.hsc" #-}

{-# LINE 54 "CV/Bindings/Types.hsc" #-}

{-# LINE 55 "CV/Bindings/Types.hsc" #-}

{-# LINE 56 "CV/Bindings/Types.hsc" #-}

{-# LINE 57 "CV/Bindings/Types.hsc" #-}

{-# LINE 58 "CV/Bindings/Types.hsc" #-}

{-# LINE 59 "CV/Bindings/Types.hsc" #-}
data C'CvContour = C'CvContour{
  c'CvContour'flags :: CInt,
  c'CvContour'header_size :: CInt,
  c'CvContour'h_prev :: Ptr C'CvSeq,
  c'CvContour'h_next :: Ptr C'CvSeq,
  c'CvContour'v_prev :: Ptr C'CvSeq,
  c'CvContour'v_next :: Ptr C'CvSeq,
  c'CvContour'total :: CInt,
  c'CvContour'elem_size :: CInt,
  c'CvContour'block_max :: Ptr Char,
  c'CvContour'ptr :: Ptr Char,
  c'CvContour'delta_elems :: CInt,
  c'CvContour'free_blocks :: Ptr C'CvSeqBlock,
  c'CvContour'first :: Ptr C'CvSeqBlock,
  c'CvContour'rect :: C'CvRect,
  c'CvContour'color :: CInt,
  c'CvContour'reserved_0_ :: CInt,
  c'CvContour'reserved_1_ :: CInt,
  c'CvContour'reserved_2_ :: CInt
} deriving (Eq,Show)
p'CvContour'flags p = plusPtr p 0
p'CvContour'flags :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'header_size p = plusPtr p 4
p'CvContour'header_size :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'h_prev p = plusPtr p 8
p'CvContour'h_prev :: Ptr (C'CvContour) -> Ptr (Ptr C'CvSeq)
p'CvContour'h_next p = plusPtr p 12
p'CvContour'h_next :: Ptr (C'CvContour) -> Ptr (Ptr C'CvSeq)
p'CvContour'v_prev p = plusPtr p 16
p'CvContour'v_prev :: Ptr (C'CvContour) -> Ptr (Ptr C'CvSeq)
p'CvContour'v_next p = plusPtr p 20
p'CvContour'v_next :: Ptr (C'CvContour) -> Ptr (Ptr C'CvSeq)
p'CvContour'total p = plusPtr p 24
p'CvContour'total :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'elem_size p = plusPtr p 28
p'CvContour'elem_size :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'block_max p = plusPtr p 32
p'CvContour'block_max :: Ptr (C'CvContour) -> Ptr (Ptr Char)
p'CvContour'ptr p = plusPtr p 36
p'CvContour'ptr :: Ptr (C'CvContour) -> Ptr (Ptr Char)
p'CvContour'delta_elems p = plusPtr p 40
p'CvContour'delta_elems :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'free_blocks p = plusPtr p 48
p'CvContour'free_blocks :: Ptr (C'CvContour) -> Ptr (Ptr C'CvSeqBlock)
p'CvContour'first p = plusPtr p 52
p'CvContour'first :: Ptr (C'CvContour) -> Ptr (Ptr C'CvSeqBlock)
p'CvContour'rect p = plusPtr p 56
p'CvContour'rect :: Ptr (C'CvContour) -> Ptr (C'CvRect)
p'CvContour'color p = plusPtr p 72
p'CvContour'color :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'reserved_0_ p = plusPtr p 76
p'CvContour'reserved_0_ :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'reserved_1_ p = plusPtr p 80
p'CvContour'reserved_1_ :: Ptr (C'CvContour) -> Ptr (CInt)
p'CvContour'reserved_2_ p = plusPtr p 84
p'CvContour'reserved_2_ :: Ptr (C'CvContour) -> Ptr (CInt)
instance Storable C'CvContour where
  sizeOf _ = 88
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 12
    v4 <- peekByteOff p 16
    v5 <- peekByteOff p 20
    v6 <- peekByteOff p 24
    v7 <- peekByteOff p 28
    v8 <- peekByteOff p 32
    v9 <- peekByteOff p 36
    v10 <- peekByteOff p 40
    v11 <- peekByteOff p 48
    v12 <- peekByteOff p 52
    v13 <- peekByteOff p 56
    v14 <- peekByteOff p 72
    v15 <- peekByteOff p 76
    v16 <- peekByteOff p 80
    v17 <- peekByteOff p 84
    return $ C'CvContour v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17
  poke p (C'CvContour v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 12 v3
    pokeByteOff p 16 v4
    pokeByteOff p 20 v5
    pokeByteOff p 24 v6
    pokeByteOff p 28 v7
    pokeByteOff p 32 v8
    pokeByteOff p 36 v9
    pokeByteOff p 40 v10
    pokeByteOff p 48 v11
    pokeByteOff p 52 v12
    pokeByteOff p 56 v13
    pokeByteOff p 72 v14
    pokeByteOff p 76 v15
    pokeByteOff p 80 v16
    pokeByteOff p 84 v17
    return ()

{-# LINE 60 "CV/Bindings/Types.hsc" #-}


{-# LINE 62 "CV/Bindings/Types.hsc" #-}

{-# LINE 63 "CV/Bindings/Types.hsc" #-}

{-# LINE 64 "CV/Bindings/Types.hsc" #-}

{-# LINE 65 "CV/Bindings/Types.hsc" #-}

{-# LINE 66 "CV/Bindings/Types.hsc" #-}

{-# LINE 67 "CV/Bindings/Types.hsc" #-}

{-# LINE 68 "CV/Bindings/Types.hsc" #-}

{-# LINE 69 "CV/Bindings/Types.hsc" #-}

{-# LINE 70 "CV/Bindings/Types.hsc" #-}

{-# LINE 71 "CV/Bindings/Types.hsc" #-}

{-# LINE 72 "CV/Bindings/Types.hsc" #-}

{-# LINE 73 "CV/Bindings/Types.hsc" #-}

{-# LINE 74 "CV/Bindings/Types.hsc" #-}

{-# LINE 75 "CV/Bindings/Types.hsc" #-}
data C'CvSeq = C'CvSeq{
  c'CvSeq'flags :: CInt,
  c'CvSeq'header_size :: CInt,
  c'CvSeq'h_prev :: Ptr C'CvSeq,
  c'CvSeq'h_next :: Ptr C'CvSeq,
  c'CvSeq'v_prev :: Ptr C'CvSeq,
  c'CvSeq'v_next :: Ptr C'CvSeq,
  c'CvSeq'total :: CInt,
  c'CvSeq'elem_size :: CInt,
  c'CvSeq'block_max :: Ptr Char,
  c'CvSeq'ptr :: Ptr Char,
  c'CvSeq'delta_elems :: CInt,
  c'CvSeq'free_blocks :: Ptr C'CvSeqBlock,
  c'CvSeq'first :: Ptr C'CvSeqBlock
} deriving (Eq,Show)
p'CvSeq'flags p = plusPtr p 0
p'CvSeq'flags :: Ptr (C'CvSeq) -> Ptr (CInt)
p'CvSeq'header_size p = plusPtr p 4
p'CvSeq'header_size :: Ptr (C'CvSeq) -> Ptr (CInt)
p'CvSeq'h_prev p = plusPtr p 8
p'CvSeq'h_prev :: Ptr (C'CvSeq) -> Ptr (Ptr C'CvSeq)
p'CvSeq'h_next p = plusPtr p 12
p'CvSeq'h_next :: Ptr (C'CvSeq) -> Ptr (Ptr C'CvSeq)
p'CvSeq'v_prev p = plusPtr p 16
p'CvSeq'v_prev :: Ptr (C'CvSeq) -> Ptr (Ptr C'CvSeq)
p'CvSeq'v_next p = plusPtr p 20
p'CvSeq'v_next :: Ptr (C'CvSeq) -> Ptr (Ptr C'CvSeq)
p'CvSeq'total p = plusPtr p 24
p'CvSeq'total :: Ptr (C'CvSeq) -> Ptr (CInt)
p'CvSeq'elem_size p = plusPtr p 28
p'CvSeq'elem_size :: Ptr (C'CvSeq) -> Ptr (CInt)
p'CvSeq'block_max p = plusPtr p 32
p'CvSeq'block_max :: Ptr (C'CvSeq) -> Ptr (Ptr Char)
p'CvSeq'ptr p = plusPtr p 36
p'CvSeq'ptr :: Ptr (C'CvSeq) -> Ptr (Ptr Char)
p'CvSeq'delta_elems p = plusPtr p 40
p'CvSeq'delta_elems :: Ptr (C'CvSeq) -> Ptr (CInt)
p'CvSeq'free_blocks p = plusPtr p 48
p'CvSeq'free_blocks :: Ptr (C'CvSeq) -> Ptr (Ptr C'CvSeqBlock)
p'CvSeq'first p = plusPtr p 52
p'CvSeq'first :: Ptr (C'CvSeq) -> Ptr (Ptr C'CvSeqBlock)
instance Storable C'CvSeq where
  sizeOf _ = 56
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 12
    v4 <- peekByteOff p 16
    v5 <- peekByteOff p 20
    v6 <- peekByteOff p 24
    v7 <- peekByteOff p 28
    v8 <- peekByteOff p 32
    v9 <- peekByteOff p 36
    v10 <- peekByteOff p 40
    v11 <- peekByteOff p 48
    v12 <- peekByteOff p 52
    return $ C'CvSeq v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12
  poke p (C'CvSeq v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 12 v3
    pokeByteOff p 16 v4
    pokeByteOff p 20 v5
    pokeByteOff p 24 v6
    pokeByteOff p 28 v7
    pokeByteOff p 32 v8
    pokeByteOff p 36 v9
    pokeByteOff p 40 v10
    pokeByteOff p 48 v11
    pokeByteOff p 52 v12
    return ()

{-# LINE 76 "CV/Bindings/Types.hsc" #-}

foreign import ccall "extractCVSeq" c'extractCVSeq
  :: Ptr C'CvSeq -> Ptr () -> IO ()
foreign import ccall "&extractCVSeq" p'extractCVSeq
  :: FunPtr (Ptr C'CvSeq -> Ptr () -> IO ())

{-# LINE 78 "CV/Bindings/Types.hsc" #-}
foreign import ccall "cvGetSeqElem" c'cvGetSeqElem
  :: Ptr C'CvSeq -> CInt -> IO (Ptr CChar)
foreign import ccall "&cvGetSeqElem" p'cvGetSeqElem
  :: FunPtr (Ptr C'CvSeq -> CInt -> IO (Ptr CChar))

{-# LINE 79 "CV/Bindings/Types.hsc" #-}
foreign import ccall "printSeq" c'printSeq
  :: Ptr C'CvSeq -> IO ()
foreign import ccall "&printSeq" p'printSeq
  :: FunPtr (Ptr C'CvSeq -> IO ())

{-# LINE 80 "CV/Bindings/Types.hsc" #-}

-- | Convert a CvSeq object into list of its contents. Note that
-- since CvSeq can be approximately anything, including a crazy man from the moon,
-- this is pretty unsafe and you must make sure that `a` is actually the element
-- in the seq, and the seq is something that remotely represents a sequence of elements.
cvSeqToList :: (Storable a) => Ptr C'CvSeq -> IO [a]
cvSeqToList ptrseq = do
   seq <- peek ptrseq
   dest <- mallocArray (fromIntegral $ c'CvSeq'total seq)
   c'extractCVSeq ptrseq (castPtr dest)
   peekArray (fromIntegral $ c'CvSeq'total seq) dest

-- | A version of `cvSeqToList` that returns a vector instead. All the warnings of `CvSeqToList` apply.
cvSeqToVector :: (U.Unbox a, Storable a) => Ptr C'CvSeq -> IO (U.Vector a)
cvSeqToVector ptrseq = do
   seq <- peek ptrseq
   dest <- mallocArray (fromIntegral $ c'CvSeq'total seq)
   c'extractCVSeq ptrseq (castPtr dest)
   U.generateM (fromIntegral $ c'CvSeq'total seq) (peekElemOff dest)
   -- peekArray (fromIntegral $ c'CvSeq'total seq) dest



{-# LINE 103 "CV/Bindings/Types.hsc" #-}

{-# LINE 104 "CV/Bindings/Types.hsc" #-}

{-# LINE 105 "CV/Bindings/Types.hsc" #-}

{-# LINE 106 "CV/Bindings/Types.hsc" #-}

{-# LINE 107 "CV/Bindings/Types.hsc" #-}
data C'CvRect = C'CvRect{
  c'CvRect'x :: CInt,
  c'CvRect'y :: CInt,
  c'CvRect'width :: CInt,
  c'CvRect'height :: CInt
} deriving (Eq,Show)
p'CvRect'x p = plusPtr p 0
p'CvRect'x :: Ptr (C'CvRect) -> Ptr (CInt)
p'CvRect'y p = plusPtr p 4
p'CvRect'y :: Ptr (C'CvRect) -> Ptr (CInt)
p'CvRect'width p = plusPtr p 8
p'CvRect'width :: Ptr (C'CvRect) -> Ptr (CInt)
p'CvRect'height p = plusPtr p 12
p'CvRect'height :: Ptr (C'CvRect) -> Ptr (CInt)
instance Storable C'CvRect where
  sizeOf _ = 16
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 12
    return $ C'CvRect v0 v1 v2 v3
  poke p (C'CvRect v0 v1 v2 v3) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 12 v3
    return ()

{-# LINE 108 "CV/Bindings/Types.hsc" #-}

instance BoundingBox C'CvRect where
   type ELBB C'CvRect = Int
   bounds (C'CvRect x y w h) = Rectangle (f x) (f y) (f w) (f h)
    where f = fromIntegral

instance FromBounds C'CvRect where
   type ELFB C'CvRect = Int
   fromBounds (Rectangle x y w h) = C'CvRect (f x) (f y) (f w) (f h)
    where f = fromIntegral


{-# LINE 120 "CV/Bindings/Types.hsc" #-}

{-# LINE 121 "CV/Bindings/Types.hsc" #-}

{-# LINE 122 "CV/Bindings/Types.hsc" #-}

{-# LINE 123 "CV/Bindings/Types.hsc" #-}

{-# LINE 124 "CV/Bindings/Types.hsc" #-}
data C'CvScalar = C'CvScalar{
  c'CvScalar'val_0_ :: CDouble,
  c'CvScalar'val_1_ :: CDouble,
  c'CvScalar'val_2_ :: CDouble,
  c'CvScalar'val_3_ :: CDouble
} deriving (Eq,Show)
p'CvScalar'val_0_ p = plusPtr p 0
p'CvScalar'val_0_ :: Ptr (C'CvScalar) -> Ptr (CDouble)
p'CvScalar'val_1_ p = plusPtr p 8
p'CvScalar'val_1_ :: Ptr (C'CvScalar) -> Ptr (CDouble)
p'CvScalar'val_2_ p = plusPtr p 16
p'CvScalar'val_2_ :: Ptr (C'CvScalar) -> Ptr (CDouble)
p'CvScalar'val_3_ p = plusPtr p 24
p'CvScalar'val_3_ :: Ptr (C'CvScalar) -> Ptr (CDouble)
instance Storable C'CvScalar where
  sizeOf _ = 32
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 16
    v3 <- peekByteOff p 24
    return $ C'CvScalar v0 v1 v2 v3
  poke p (C'CvScalar v0 v1 v2 v3) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 16 v2
    pokeByteOff p 24 v3
    return ()

{-# LINE 125 "CV/Bindings/Types.hsc" #-}

-- CV_INLINE CvScalar cvScalar(
--   double val0,
--   double val1 CV_DEFAULT(0),
--   double val2 CV_DEFAULT(0),
--   double val3 CV_DEFAULT(0)
-- )

-- #cinline cvScalar , CDouble -> CDouble -> CDouble -> CDouble -> IO(<CvScalar>)

-- CV_INLINE CvScalar cvRealScalar(
--   double val0
-- )

-- #cinline cvRealScalar , CDouble -> IO(<CvScalar>)

-- CV_INLINE CvScalar cvScalarAll(
--   double val0123
-- )

-- #cinline cvScalarAll , CDouble -> IO(<CvScalar>)

-- CvSize


{-# LINE 150 "CV/Bindings/Types.hsc" #-}

{-# LINE 151 "CV/Bindings/Types.hsc" #-}

{-# LINE 152 "CV/Bindings/Types.hsc" #-}
data C'CvSize = C'CvSize{
  c'CvSize'width :: CInt,
  c'CvSize'height :: CInt
} deriving (Eq,Show)
p'CvSize'width p = plusPtr p 0
p'CvSize'width :: Ptr (C'CvSize) -> Ptr (CInt)
p'CvSize'height p = plusPtr p 4
p'CvSize'height :: Ptr (C'CvSize) -> Ptr (CInt)
instance Storable C'CvSize where
  sizeOf _ = 8
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    return $ C'CvSize v0 v1
  poke p (C'CvSize v0 v1) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    return ()

{-# LINE 153 "CV/Bindings/Types.hsc" #-}

instance Sized C'CvSize where
    type Size  C'CvSize = (Int,Int)
    getSize (C'CvSize w h)  = (fromIntegral w,fromIntegral h)


{-# LINE 159 "CV/Bindings/Types.hsc" #-}

{-# LINE 160 "CV/Bindings/Types.hsc" #-}

{-# LINE 161 "CV/Bindings/Types.hsc" #-}
data C'CvSize2D32f = C'CvSize2D32f{
  c'CvSize2D32f'width :: CFloat,
  c'CvSize2D32f'height :: CFloat
} deriving (Eq,Show)
p'CvSize2D32f'width p = plusPtr p 0
p'CvSize2D32f'width :: Ptr (C'CvSize2D32f) -> Ptr (CFloat)
p'CvSize2D32f'height p = plusPtr p 4
p'CvSize2D32f'height :: Ptr (C'CvSize2D32f) -> Ptr (CFloat)
instance Storable C'CvSize2D32f where
  sizeOf _ = 8
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    return $ C'CvSize2D32f v0 v1
  poke p (C'CvSize2D32f v0 v1) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    return ()

{-# LINE 162 "CV/Bindings/Types.hsc" #-}

instance Sized C'CvSize2D32f where
    type Size  C'CvSize2D32f = (Float,Float)
    getSize (C'CvSize2D32f w h)  = (realToFrac w, realToFrac h)


{-# LINE 168 "CV/Bindings/Types.hsc" #-}

{-# LINE 169 "CV/Bindings/Types.hsc" #-}

{-# LINE 170 "CV/Bindings/Types.hsc" #-}

{-# LINE 171 "CV/Bindings/Types.hsc" #-}

{-# LINE 172 "CV/Bindings/Types.hsc" #-}
data C'CvConnectedComp = C'CvConnectedComp{
  c'CvConnectedComp'area :: CDouble,
  c'CvConnectedComp'value :: C'CvScalar,
  c'CvConnectedComp'rect :: C'CvRect,
  c'CvConnectedComp'contour :: Ptr C'CvSeq
} deriving (Eq,Show)
p'CvConnectedComp'area p = plusPtr p 0
p'CvConnectedComp'area :: Ptr (C'CvConnectedComp) -> Ptr (CDouble)
p'CvConnectedComp'value p = plusPtr p 8
p'CvConnectedComp'value :: Ptr (C'CvConnectedComp) -> Ptr (C'CvScalar)
p'CvConnectedComp'rect p = plusPtr p 40
p'CvConnectedComp'rect :: Ptr (C'CvConnectedComp) -> Ptr (C'CvRect)
p'CvConnectedComp'contour p = plusPtr p 56
p'CvConnectedComp'contour :: Ptr (C'CvConnectedComp) -> Ptr (Ptr C'CvSeq)
instance Storable C'CvConnectedComp where
  sizeOf _ = 60
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 40
    v3 <- peekByteOff p 56
    return $ C'CvConnectedComp v0 v1 v2 v3
  poke p (C'CvConnectedComp v0 v1 v2 v3) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 40 v2
    pokeByteOff p 56 v3
    return ()

{-# LINE 173 "CV/Bindings/Types.hsc" #-}


{-# LINE 175 "CV/Bindings/Types.hsc" #-}

{-# LINE 176 "CV/Bindings/Types.hsc" #-}

{-# LINE 177 "CV/Bindings/Types.hsc" #-}
data C'CvPoint = C'CvPoint{
  c'CvPoint'x :: CInt,
  c'CvPoint'y :: CInt
} deriving (Eq,Show)
p'CvPoint'x p = plusPtr p 0
p'CvPoint'x :: Ptr (C'CvPoint) -> Ptr (CInt)
p'CvPoint'y p = plusPtr p 4
p'CvPoint'y :: Ptr (C'CvPoint) -> Ptr (CInt)
instance Storable C'CvPoint where
  sizeOf _ = 8
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    return $ C'CvPoint v0 v1
  poke p (C'CvPoint v0 v1) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    return ()

{-# LINE 178 "CV/Bindings/Types.hsc" #-}

instance Point2D C'CvPoint where
   type ELP C'CvPoint = Int
   pt (C'CvPoint x y) = (fromIntegral x,fromIntegral y)
   toPt (x,y) = C'CvPoint (fromIntegral x) (fromIntegral y)


{-# LINE 185 "CV/Bindings/Types.hsc" #-}

{-# LINE 186 "CV/Bindings/Types.hsc" #-}

{-# LINE 187 "CV/Bindings/Types.hsc" #-}
data C'CvPoint2D32f = C'CvPoint2D32f{
  c'CvPoint2D32f'x :: CFloat,
  c'CvPoint2D32f'y :: CFloat
} deriving (Eq,Show)
p'CvPoint2D32f'x p = plusPtr p 0
p'CvPoint2D32f'x :: Ptr (C'CvPoint2D32f) -> Ptr (CFloat)
p'CvPoint2D32f'y p = plusPtr p 4
p'CvPoint2D32f'y :: Ptr (C'CvPoint2D32f) -> Ptr (CFloat)
instance Storable C'CvPoint2D32f where
  sizeOf _ = 8
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    return $ C'CvPoint2D32f v0 v1
  poke p (C'CvPoint2D32f v0 v1) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    return ()

{-# LINE 188 "CV/Bindings/Types.hsc" #-}

instance Point2D C'CvPoint2D32f where
   type ELP C'CvPoint2D32f = Double
   pt (C'CvPoint2D32f x y) = (realToFrac x,realToFrac y)
   toPt (x,y) = C'CvPoint2D32f (realToFrac x) (realToFrac y)

instance Sized C'CvBox2D where
    type Size  C'CvBox2D = (Float,Float)
    getSize (C'CvBox2D _ s _) = getSize s

-- // #starttype CV_32FC2
-- // #field x , Float
-- // #field y , Float
-- // #stoptype

mkCvPoint2D32F (x,y) = C'CvPoint2D32f x y


{-# LINE 206 "CV/Bindings/Types.hsc" #-}

{-# LINE 207 "CV/Bindings/Types.hsc" #-}

{-# LINE 208 "CV/Bindings/Types.hsc" #-}

{-# LINE 209 "CV/Bindings/Types.hsc" #-}
data C'CvBox2D = C'CvBox2D{
  c'CvBox2D'center :: C'CvPoint2D32f,
  c'CvBox2D'size :: C'CvSize2D32f,
  c'CvBox2D'angle :: CFloat
} deriving (Eq,Show)
p'CvBox2D'center p = plusPtr p 0
p'CvBox2D'center :: Ptr (C'CvBox2D) -> Ptr (C'CvPoint2D32f)
p'CvBox2D'size p = plusPtr p 8
p'CvBox2D'size :: Ptr (C'CvBox2D) -> Ptr (C'CvSize2D32f)
p'CvBox2D'angle p = plusPtr p 16
p'CvBox2D'angle :: Ptr (C'CvBox2D) -> Ptr (CFloat)
instance Storable C'CvBox2D where
  sizeOf _ = 20
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 16
    return $ C'CvBox2D v0 v1 v2
  poke p (C'CvBox2D v0 v1 v2) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 16 v2
    return ()

{-# LINE 210 "CV/Bindings/Types.hsc" #-}

-- #startype CvHistogram
-- #field type, Int
-- #field bins, Ptr <CvArr>
-- #array_field thresh, Ptr (Ptr Float)
-- #field thresh2, Ptr (Ptr Float)
-- #array_field mat, <CvMatND>
-- #endtype


-- | /Spatial and central moments

{-# LINE 222 "CV/Bindings/Types.hsc" #-}
-- | spatial moments

{-# LINE 224 "CV/Bindings/Types.hsc" #-}

{-# LINE 225 "CV/Bindings/Types.hsc" #-}

{-# LINE 226 "CV/Bindings/Types.hsc" #-}

{-# LINE 227 "CV/Bindings/Types.hsc" #-}

{-# LINE 228 "CV/Bindings/Types.hsc" #-}

{-# LINE 229 "CV/Bindings/Types.hsc" #-}

{-# LINE 230 "CV/Bindings/Types.hsc" #-}

{-# LINE 231 "CV/Bindings/Types.hsc" #-}

{-# LINE 232 "CV/Bindings/Types.hsc" #-}

{-# LINE 233 "CV/Bindings/Types.hsc" #-}
-- | central moments

{-# LINE 235 "CV/Bindings/Types.hsc" #-}

{-# LINE 236 "CV/Bindings/Types.hsc" #-}

{-# LINE 237 "CV/Bindings/Types.hsc" #-}

{-# LINE 238 "CV/Bindings/Types.hsc" #-}

{-# LINE 239 "CV/Bindings/Types.hsc" #-}

{-# LINE 240 "CV/Bindings/Types.hsc" #-}

{-# LINE 241 "CV/Bindings/Types.hsc" #-}
-- | @m00 != 0 ? 1/sqrt(m00) : 0@

{-# LINE 243 "CV/Bindings/Types.hsc" #-}
data C'CvMoments = C'CvMoments{
  c'CvMoments'm00 :: CDouble,
  c'CvMoments'm10 :: CDouble,
  c'CvMoments'm01 :: CDouble,
  c'CvMoments'm20 :: CDouble,
  c'CvMoments'm11 :: CDouble,
  c'CvMoments'm02 :: CDouble,
  c'CvMoments'm30 :: CDouble,
  c'CvMoments'm21 :: CDouble,
  c'CvMoments'm12 :: CDouble,
  c'CvMoments'm03 :: CDouble,
  c'CvMoments'mu20 :: CDouble,
  c'CvMoments'mu11 :: CDouble,
  c'CvMoments'mu02 :: CDouble,
  c'CvMoments'mu30 :: CDouble,
  c'CvMoments'mu21 :: CDouble,
  c'CvMoments'mu12 :: CDouble,
  c'CvMoments'mu03 :: CDouble,
  c'CvMoments'inv_sqrt_m00 :: CDouble
} deriving (Eq,Show)
p'CvMoments'm00 p = plusPtr p 0
p'CvMoments'm00 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm10 p = plusPtr p 8
p'CvMoments'm10 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm01 p = plusPtr p 16
p'CvMoments'm01 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm20 p = plusPtr p 24
p'CvMoments'm20 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm11 p = plusPtr p 32
p'CvMoments'm11 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm02 p = plusPtr p 40
p'CvMoments'm02 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm30 p = plusPtr p 48
p'CvMoments'm30 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm21 p = plusPtr p 56
p'CvMoments'm21 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm12 p = plusPtr p 64
p'CvMoments'm12 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'm03 p = plusPtr p 72
p'CvMoments'm03 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'mu20 p = plusPtr p 80
p'CvMoments'mu20 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'mu11 p = plusPtr p 88
p'CvMoments'mu11 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'mu02 p = plusPtr p 96
p'CvMoments'mu02 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'mu30 p = plusPtr p 104
p'CvMoments'mu30 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'mu21 p = plusPtr p 112
p'CvMoments'mu21 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'mu12 p = plusPtr p 120
p'CvMoments'mu12 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'mu03 p = plusPtr p 128
p'CvMoments'mu03 :: Ptr (C'CvMoments) -> Ptr (CDouble)
p'CvMoments'inv_sqrt_m00 p = plusPtr p 136
p'CvMoments'inv_sqrt_m00 :: Ptr (C'CvMoments) -> Ptr (CDouble)
instance Storable C'CvMoments where
  sizeOf _ = 144
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 16
    v3 <- peekByteOff p 24
    v4 <- peekByteOff p 32
    v5 <- peekByteOff p 40
    v6 <- peekByteOff p 48
    v7 <- peekByteOff p 56
    v8 <- peekByteOff p 64
    v9 <- peekByteOff p 72
    v10 <- peekByteOff p 80
    v11 <- peekByteOff p 88
    v12 <- peekByteOff p 96
    v13 <- peekByteOff p 104
    v14 <- peekByteOff p 112
    v15 <- peekByteOff p 120
    v16 <- peekByteOff p 128
    v17 <- peekByteOff p 136
    return $ C'CvMoments v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17
  poke p (C'CvMoments v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 16 v2
    pokeByteOff p 24 v3
    pokeByteOff p 32 v4
    pokeByteOff p 40 v5
    pokeByteOff p 48 v6
    pokeByteOff p 56 v7
    pokeByteOff p 64 v8
    pokeByteOff p 72 v9
    pokeByteOff p 80 v10
    pokeByteOff p 88 v11
    pokeByteOff p 96 v12
    pokeByteOff p 104 v13
    pokeByteOff p 112 v14
    pokeByteOff p 120 v15
    pokeByteOff p 128 v16
    pokeByteOff p 136 v17
    return ()

{-# LINE 244 "CV/Bindings/Types.hsc" #-}

-- | Hu invariants

{-# LINE 247 "CV/Bindings/Types.hsc" #-}

{-# LINE 248 "CV/Bindings/Types.hsc" #-}

{-# LINE 249 "CV/Bindings/Types.hsc" #-}

{-# LINE 250 "CV/Bindings/Types.hsc" #-}

{-# LINE 251 "CV/Bindings/Types.hsc" #-}

{-# LINE 252 "CV/Bindings/Types.hsc" #-}

{-# LINE 253 "CV/Bindings/Types.hsc" #-}

{-# LINE 254 "CV/Bindings/Types.hsc" #-}
data C'CvHuMoments = C'CvHuMoments{
  c'CvHuMoments'hu1 :: CDouble,
  c'CvHuMoments'hu2 :: CDouble,
  c'CvHuMoments'hu3 :: CDouble,
  c'CvHuMoments'hu4 :: CDouble,
  c'CvHuMoments'hu5 :: CDouble,
  c'CvHuMoments'hu6 :: CDouble,
  c'CvHuMoments'hu7 :: CDouble
} deriving (Eq,Show)
p'CvHuMoments'hu1 p = plusPtr p 0
p'CvHuMoments'hu1 :: Ptr (C'CvHuMoments) -> Ptr (CDouble)
p'CvHuMoments'hu2 p = plusPtr p 8
p'CvHuMoments'hu2 :: Ptr (C'CvHuMoments) -> Ptr (CDouble)
p'CvHuMoments'hu3 p = plusPtr p 16
p'CvHuMoments'hu3 :: Ptr (C'CvHuMoments) -> Ptr (CDouble)
p'CvHuMoments'hu4 p = plusPtr p 24
p'CvHuMoments'hu4 :: Ptr (C'CvHuMoments) -> Ptr (CDouble)
p'CvHuMoments'hu5 p = plusPtr p 32
p'CvHuMoments'hu5 :: Ptr (C'CvHuMoments) -> Ptr (CDouble)
p'CvHuMoments'hu6 p = plusPtr p 40
p'CvHuMoments'hu6 :: Ptr (C'CvHuMoments) -> Ptr (CDouble)
p'CvHuMoments'hu7 p = plusPtr p 48
p'CvHuMoments'hu7 :: Ptr (C'CvHuMoments) -> Ptr (CDouble)
instance Storable C'CvHuMoments where
  sizeOf _ = 56
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 16
    v3 <- peekByteOff p 24
    v4 <- peekByteOff p 32
    v5 <- peekByteOff p 40
    v6 <- peekByteOff p 48
    return $ C'CvHuMoments v0 v1 v2 v3 v4 v5 v6
  poke p (C'CvHuMoments v0 v1 v2 v3 v4 v5 v6) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 16 v2
    pokeByteOff p 24 v3
    pokeByteOff p 32 v4
    pokeByteOff p 40 v5
    pokeByteOff p 48 v6
    return ()

{-# LINE 255 "CV/Bindings/Types.hsc" #-}


{-# LINE 257 "CV/Bindings/Types.hsc" #-}

{-# LINE 258 "CV/Bindings/Types.hsc" #-}

{-# LINE 259 "CV/Bindings/Types.hsc" #-}

{-# LINE 260 "CV/Bindings/Types.hsc" #-}
data C'CvTermCriteria = C'CvTermCriteria{
  c'CvTermCriteria'type :: CInt,
  c'CvTermCriteria'max_iter :: CInt,
  c'CvTermCriteria'epsilon :: Double
} deriving (Eq,Show)
p'CvTermCriteria'type p = plusPtr p 0
p'CvTermCriteria'type :: Ptr (C'CvTermCriteria) -> Ptr (CInt)
p'CvTermCriteria'max_iter p = plusPtr p 4
p'CvTermCriteria'max_iter :: Ptr (C'CvTermCriteria) -> Ptr (CInt)
p'CvTermCriteria'epsilon p = plusPtr p 8
p'CvTermCriteria'epsilon :: Ptr (C'CvTermCriteria) -> Ptr (Double)
instance Storable C'CvTermCriteria where
  sizeOf _ = 16
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    return $ C'CvTermCriteria v0 v1 v2
  poke p (C'CvTermCriteria v0 v1 v2) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    return ()

{-# LINE 261 "CV/Bindings/Types.hsc" #-}

data TermCriteria = EPS Double | ITER Int deriving (Show, Eq)

toCvTCrit (EPS d) = C'CvTermCriteria c'CV_TERMCRIT_EPS 0 d
toCvTCrit (ITER i) = C'CvTermCriteria c'CV_TERMCRIT_ITER (fromIntegral i) 0

c'CV_TERMCRIT_ITER = 1
c'CV_TERMCRIT_ITER :: (Num a) => a

{-# LINE 268 "CV/Bindings/Types.hsc" #-}
c'CV_TERMCRIT_NUMBER = 1
c'CV_TERMCRIT_NUMBER :: (Num a) => a

{-# LINE 269 "CV/Bindings/Types.hsc" #-}
c'CV_TERMCRIT_EPS = 2
c'CV_TERMCRIT_EPS :: (Num a) => a

{-# LINE 270 "CV/Bindings/Types.hsc" #-}



-- Memory Storage
foreign import ccall "cvCreateMemStorage" c'cvCreateMemStorage
  :: Int -> IO (Ptr C'CvMemStorage)
foreign import ccall "&cvCreateMemStorage" p'cvCreateMemStorage
  :: FunPtr (Int -> IO (Ptr C'CvMemStorage))

{-# LINE 275 "CV/Bindings/Types.hsc" #-}
foreign import ccall "cvReleaseMemStorage" c'cvReleaseMemStorage
  :: Ptr (Ptr C'CvMemStorage) -> IO ()
foreign import ccall "&cvReleaseMemStorage" p'cvReleaseMemStorage
  :: FunPtr (Ptr (Ptr C'CvMemStorage) -> IO ())

{-# LINE 276 "CV/Bindings/Types.hsc" #-}

withNewMemory fun = do
    mem <- c'cvCreateMemStorage 0
    res <- fun mem
    with mem c'cvReleaseMemStorage
    return res


c'CV_8UC1 = 0
c'CV_8UC1 :: (Num a) => a

{-# LINE 285 "CV/Bindings/Types.hsc" #-}
c'CV_8UC2 = 8
c'CV_8UC2 :: (Num a) => a

{-# LINE 286 "CV/Bindings/Types.hsc" #-}
c'CV_8UC3 = 16
c'CV_8UC3 :: (Num a) => a

{-# LINE 287 "CV/Bindings/Types.hsc" #-}
c'CV_8UC4 = 24
c'CV_8UC4 :: (Num a) => a

{-# LINE 288 "CV/Bindings/Types.hsc" #-}

c'CV_8SC1 = 1
c'CV_8SC1 :: (Num a) => a

{-# LINE 290 "CV/Bindings/Types.hsc" #-}
c'CV_8SC2 = 9
c'CV_8SC2 :: (Num a) => a

{-# LINE 291 "CV/Bindings/Types.hsc" #-}
c'CV_8SC3 = 17
c'CV_8SC3 :: (Num a) => a

{-# LINE 292 "CV/Bindings/Types.hsc" #-}
c'CV_8SC4 = 25
c'CV_8SC4 :: (Num a) => a

{-# LINE 293 "CV/Bindings/Types.hsc" #-}

c'CV_16UC1 = 2
c'CV_16UC1 :: (Num a) => a

{-# LINE 295 "CV/Bindings/Types.hsc" #-}
c'CV_16UC2 = 10
c'CV_16UC2 :: (Num a) => a

{-# LINE 296 "CV/Bindings/Types.hsc" #-}
c'CV_16UC3 = 18
c'CV_16UC3 :: (Num a) => a

{-# LINE 297 "CV/Bindings/Types.hsc" #-}
c'CV_16UC4 = 26
c'CV_16UC4 :: (Num a) => a

{-# LINE 298 "CV/Bindings/Types.hsc" #-}

c'CV_16SC1 = 3
c'CV_16SC1 :: (Num a) => a

{-# LINE 300 "CV/Bindings/Types.hsc" #-}
c'CV_16SC2 = 11
c'CV_16SC2 :: (Num a) => a

{-# LINE 301 "CV/Bindings/Types.hsc" #-}
c'CV_16SC3 = 19
c'CV_16SC3 :: (Num a) => a

{-# LINE 302 "CV/Bindings/Types.hsc" #-}
c'CV_16SC4 = 27
c'CV_16SC4 :: (Num a) => a

{-# LINE 303 "CV/Bindings/Types.hsc" #-}

c'CV_32SC1 = 4
c'CV_32SC1 :: (Num a) => a

{-# LINE 305 "CV/Bindings/Types.hsc" #-}
c'CV_32SC2 = 12
c'CV_32SC2 :: (Num a) => a

{-# LINE 306 "CV/Bindings/Types.hsc" #-}
c'CV_32SC3 = 20
c'CV_32SC3 :: (Num a) => a

{-# LINE 307 "CV/Bindings/Types.hsc" #-}
c'CV_32SC4 = 28
c'CV_32SC4 :: (Num a) => a

{-# LINE 308 "CV/Bindings/Types.hsc" #-}

c'CV_32FC1 = 5
c'CV_32FC1 :: (Num a) => a

{-# LINE 310 "CV/Bindings/Types.hsc" #-}
c'CV_32FC2 = 13
c'CV_32FC2 :: (Num a) => a

{-# LINE 311 "CV/Bindings/Types.hsc" #-}
c'CV_32FC3 = 21
c'CV_32FC3 :: (Num a) => a

{-# LINE 312 "CV/Bindings/Types.hsc" #-}
c'CV_32FC4 = 29
c'CV_32FC4 :: (Num a) => a

{-# LINE 313 "CV/Bindings/Types.hsc" #-}

c'CV_64FC1 = 6
c'CV_64FC1 :: (Num a) => a

{-# LINE 315 "CV/Bindings/Types.hsc" #-}
c'CV_64FC2 = 14
c'CV_64FC2 :: (Num a) => a

{-# LINE 316 "CV/Bindings/Types.hsc" #-}
c'CV_64FC3 = 22
c'CV_64FC3 :: (Num a) => a

{-# LINE 317 "CV/Bindings/Types.hsc" #-}
c'CV_64FC4 = 30
c'CV_64FC4 :: (Num a) => a

{-# LINE 318 "CV/Bindings/Types.hsc" #-}

c'CV_CLOCKWISE = 1
c'CV_CLOCKWISE :: (Num a) => a

{-# LINE 320 "CV/Bindings/Types.hsc" #-}
c'CV_COUNTER_CLOCKWISE = 2
c'CV_COUNTER_CLOCKWISE :: (Num a) => a

{-# LINE 321 "CV/Bindings/Types.hsc" #-}


{-# LINE 323 "CV/Bindings/Types.hsc" #-}

{-# LINE 324 "CV/Bindings/Types.hsc" #-}

{-# LINE 325 "CV/Bindings/Types.hsc" #-}

{-# LINE 326 "CV/Bindings/Types.hsc" #-}

{-# LINE 327 "CV/Bindings/Types.hsc" #-}
data C'CvConvexityDefect = C'CvConvexityDefect{
  c'CvConvexityDefect'start :: Ptr C'CvPoint,
  c'CvConvexityDefect'end :: Ptr C'CvPoint,
  c'CvConvexityDefect'depth_point :: Ptr C'CvPoint,
  c'CvConvexityDefect'depth :: CFloat
} deriving (Eq,Show)
p'CvConvexityDefect'start p = plusPtr p 0
p'CvConvexityDefect'start :: Ptr (C'CvConvexityDefect) -> Ptr (Ptr C'CvPoint)
p'CvConvexityDefect'end p = plusPtr p 4
p'CvConvexityDefect'end :: Ptr (C'CvConvexityDefect) -> Ptr (Ptr C'CvPoint)
p'CvConvexityDefect'depth_point p = plusPtr p 8
p'CvConvexityDefect'depth_point :: Ptr (C'CvConvexityDefect) -> Ptr (Ptr C'CvPoint)
p'CvConvexityDefect'depth p = plusPtr p 12
p'CvConvexityDefect'depth :: Ptr (C'CvConvexityDefect) -> Ptr (CFloat)
instance Storable C'CvConvexityDefect where
  sizeOf _ = 16
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 12
    return $ C'CvConvexityDefect v0 v1 v2 v3
  poke p (C'CvConvexityDefect v0 v1 v2 v3) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 12 v3
    return ()

{-# LINE 328 "CV/Bindings/Types.hsc" #-}


{-# LINE 330 "CV/Bindings/Types.hsc" #-}

{-# LINE 331 "CV/Bindings/Types.hsc" #-}

{-# LINE 332 "CV/Bindings/Types.hsc" #-}

{-# LINE 333 "CV/Bindings/Types.hsc" #-}

{-# LINE 334 "CV/Bindings/Types.hsc" #-}

{-# LINE 335 "CV/Bindings/Types.hsc" #-}
data C'CvSURFPoint = C'CvSURFPoint{
  c'CvSURFPoint'pt :: C'CvPoint2D32f,
  c'CvSURFPoint'laplacian :: CInt,
  c'CvSURFPoint'size :: CInt,
  c'CvSURFPoint'dir :: CFloat,
  c'CvSURFPoint'hessian :: CFloat
} deriving (Eq,Show)
p'CvSURFPoint'pt p = plusPtr p 0
p'CvSURFPoint'pt :: Ptr (C'CvSURFPoint) -> Ptr (C'CvPoint2D32f)
p'CvSURFPoint'laplacian p = plusPtr p 8
p'CvSURFPoint'laplacian :: Ptr (C'CvSURFPoint) -> Ptr (CInt)
p'CvSURFPoint'size p = plusPtr p 12
p'CvSURFPoint'size :: Ptr (C'CvSURFPoint) -> Ptr (CInt)
p'CvSURFPoint'dir p = plusPtr p 16
p'CvSURFPoint'dir :: Ptr (C'CvSURFPoint) -> Ptr (CFloat)
p'CvSURFPoint'hessian p = plusPtr p 20
p'CvSURFPoint'hessian :: Ptr (C'CvSURFPoint) -> Ptr (CFloat)
instance Storable C'CvSURFPoint where
  sizeOf _ = 24
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 12
    v3 <- peekByteOff p 16
    v4 <- peekByteOff p 20
    return $ C'CvSURFPoint v0 v1 v2 v3 v4
  poke p (C'CvSURFPoint v0 v1 v2 v3 v4) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 12 v2
    pokeByteOff p 16 v3
    pokeByteOff p 20 v4
    return ()

{-# LINE 336 "CV/Bindings/Types.hsc" #-}

instance Point2D C'CvSURFPoint where
   type ELP C'CvSURFPoint = Float
   pt (C'CvSURFPoint (C'CvPoint2D32f x y) _ _ _ _) = (realToFrac x,realToFrac y)
   toPt (x,y) = C'CvSURFPoint (C'CvPoint2D32f (realToFrac x) (realToFrac y)) 0 0 0 0