{-# 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 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 15 "CV/Bindings/Types.hsc" #-}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data C'IplImage = C'IplImage

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

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

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

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

data C'CvHistogram = C'CvHistogram

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


{-# LINE 40 "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" #-}
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 = sizeOf
  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 59 "CV/Bindings/Types.hsc" #-}


{-# LINE 61 "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" #-}
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 = sizeOf
  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 75 "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 77 "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 78 "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 79 "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



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

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

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

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

{-# LINE 97 "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 = sizeOf
  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 98 "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 110 "CV/Bindings/Types.hsc" #-}

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

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

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

{-# LINE 114 "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 = sizeOf
  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 115 "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 140 "CV/Bindings/Types.hsc" #-}

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

{-# LINE 142 "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 = sizeOf
  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 143 "CV/Bindings/Types.hsc" #-}


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

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

{-# LINE 147 "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 = sizeOf
  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 148 "CV/Bindings/Types.hsc" #-}


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

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

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

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

{-# LINE 154 "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 = sizeOf
  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 155 "CV/Bindings/Types.hsc" #-}


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

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

{-# LINE 159 "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 = sizeOf
  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 160 "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 167 "CV/Bindings/Types.hsc" #-}

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

{-# LINE 169 "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 = sizeOf
  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 170 "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)

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

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


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

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

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

{-# LINE 187 "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 = sizeOf
  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 188 "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 200 "CV/Bindings/Types.hsc" #-}
-- | spatial moments

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# LINE 221 "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 = sizeOf
  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 222 "CV/Bindings/Types.hsc" #-}

-- | Hu invariants

{-# 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" #-}
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 = sizeOf
  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 233 "CV/Bindings/Types.hsc" #-}


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

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

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

{-# LINE 238 "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 = sizeOf
  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 239 "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 246 "CV/Bindings/Types.hsc" #-}
c'CV_TERMCRIT_NUMBER = 1
c'CV_TERMCRIT_NUMBER :: (Num a) => a

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

{-# LINE 248 "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 252 "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 253 "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 262 "CV/Bindings/Types.hsc" #-}
c'CV_8UC2 = 8
c'CV_8UC2 :: (Num a) => a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

{-# LINE 304 "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 = sizeOf
  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 305 "CV/Bindings/Types.hsc" #-}


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

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

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

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

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

{-# LINE 312 "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 = sizeOf
  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 313 "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