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

import Foreign.C.Types
import CV.Bindings.Types
import CV.Image(BareImage)

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 9 "CV/Bindings/Core.hsc" #-}


{-# LINE 11 "CV/Bindings/Core.hsc" #-}

{-# LINE 12 "CV/Bindings/Core.hsc" #-}

{-# LINE 13 "CV/Bindings/Core.hsc" #-}

-- CVAPI(IplImage*) cvCreateImage(
--   CvSize size,
--   int depth,
--   int channels
-- );

-- Creates IPL image (header and data)

-- need to use wrapper functions since passing struct by value.

-- #ccall wrapCreateImage , CInt -> CInt -> CInt -> CInt -> IO (Ptr IplImage)

-- Releases IPL image header and data
-- CVAPI(void) cvReleaseImage(
--   IplImage** image
-- );

-- Allocates and initializes CvMat header and allocates data
-- CVAPI(CvMat*) cvCreateMat(
--  int rows,
--  int cols,
--  int type
-- );

-- Releases CvMat header and deallocates matrix data
-- (reference counting is used for data)
-- CVAPI(void) cvReleaseMat(
--   CvMat** mat
-- );

-- CVAPI(void) cvSet(
--   CvArr* arr,
--   CvScalar value,
--   const CvArr* mask CV_DEFAULT(NULL)
-- );

-- Sets all or "masked" elements of input array
-- to the same value

-- need to use wrapper functions since passing struct by value.

foreign import ccall "wrapSet" c'wrapSet
  :: Ptr C'CvArr -> Ptr C'CvScalar -> Ptr C'CvArr -> IO ()
foreign import ccall "&wrapSet" p'wrapSet
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvScalar -> Ptr C'CvArr -> IO ())

{-# LINE 56 "CV/Bindings/Core.hsc" #-}
foreign import ccall "wrapSetAll" c'wrapSetAll
  :: Ptr C'CvArr -> CDouble -> Ptr C'CvArr -> IO ()
foreign import ccall "&wrapSetAll" p'wrapSetAll
  :: FunPtr (Ptr C'CvArr -> CDouble -> Ptr C'CvArr -> IO ())

{-# LINE 57 "CV/Bindings/Core.hsc" #-}
foreign import ccall "wrapSet1" c'wrapSet1
  :: Ptr C'CvArr -> CDouble -> Ptr C'CvArr -> IO ()
foreign import ccall "&wrapSet1" p'wrapSet1
  :: FunPtr (Ptr C'CvArr -> CDouble -> Ptr C'CvArr -> IO ())

{-# LINE 58 "CV/Bindings/Core.hsc" #-}
foreign import ccall "wrapSet2" c'wrapSet2
  :: Ptr C'CvArr -> CDouble -> CDouble -> Ptr C'CvArr -> IO ()
foreign import ccall "&wrapSet2" p'wrapSet2
  :: FunPtr (Ptr C'CvArr -> CDouble -> CDouble -> Ptr C'CvArr -> IO ())

{-# LINE 59 "CV/Bindings/Core.hsc" #-}
foreign import ccall "wrapSet3" c'wrapSet3
  :: Ptr C'CvArr -> CDouble -> CDouble -> CDouble -> Ptr C'CvArr -> IO ()
foreign import ccall "&wrapSet3" p'wrapSet3
  :: FunPtr (Ptr C'CvArr -> CDouble -> CDouble -> CDouble -> Ptr C'CvArr -> IO ())

{-# LINE 60 "CV/Bindings/Core.hsc" #-}
foreign import ccall "wrapSet4" c'wrapSet4
  :: Ptr C'CvArr -> CDouble -> CDouble -> CDouble -> CDouble -> Ptr C'CvArr -> IO ()
foreign import ccall "&wrapSet4" p'wrapSet4
  :: FunPtr (Ptr C'CvArr -> CDouble -> CDouble -> CDouble -> CDouble -> Ptr C'CvArr -> IO ())

{-# LINE 61 "CV/Bindings/Core.hsc" #-}

-- CVAPI(void) cvSetZero(
--   CvArr* arr
-- );

-- Clears all the array elements (sets them to 0)

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

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

-- CVAPI(void) cvSplit(
--   const CvArr* src,
--   CvArr* dst0,
--   CvArr* dst1,
--   CvArr* dst2,
--   CvArr* dst3
-- );

-- Splits a multi-channel array into the set of single-channel arrays or
-- extracts particular [color] plane

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

{-# LINE 82 "CV/Bindings/Core.hsc" #-}

-- |CVAPI(void) cvMerge(
-- |  const CvArr* src0,
-- |  const CvArr* src1,
-- |  const CvArr* src2,
-- |  const CvArr* src3,
-- |  CvArr* dst
-- |);
-- |Merges a set of single-channel arrays into the single multi-channel array
-- |or inserts one particular [color] plane to the array
foreign import ccall "cvMerge" c'cvMerge
  :: Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> IO ()
foreign import ccall "&cvMerge" p'cvMerge
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> IO ())

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

-- CVAPI(void) cvCartToPolar(
--   const CvArr* x,
--   const CvArr* y,
--   CvArr* magnitude,
--   CvArr* angle CV_DEFAULT(NULL),
--   int angle_in_degrees CV_DEFAULT(0)
-- );

-- Does cartesian->polar coordinates conversion.
-- Either of output components (magnitude or angle) is optional

foreign import ccall "cvCartToPolar" c'cvCartToPolar
  :: Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ()
foreign import ccall "&cvCartToPolar" p'cvCartToPolar
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ())

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

-- | CVAPI(void) cvPolarToCart(
-- |   const CvArr* magnitude,
-- |   const CvArr* angle,
-- |   CvArr* x,
-- |   CvArr* y,
-- |   int angle_in_degrees CV_DEFAULT(0)
-- | );

-- | Does polar->cartesian coordinates conversion.
--   Either of output components (magnitude or angle) is optional.
--   If magnitude is missing it is assumed to be all 1's
foreign import ccall "cvPolarToCart" c'cvPolarToCart
  :: Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ()
foreign import ccall "&cvPolarToCart" p'cvPolarToCart
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ())

{-# LINE 119 "CV/Bindings/Core.hsc" #-}

-- | CVAPI(void) cvMinMaxLoc(
-- |   const CvArr* arr,
-- |   double* min_val,
-- |   double* max_val,
-- |   CvPoint* min_loc CV_DEFAULT(NULL),
-- |   CvPoint* max_loc CV_DEFAULT(NULL),
-- |   const CvArr* mask CV_DEFAULT(NULL)
-- | );

-- | Finds global minimum, maximum and their positions
foreign import ccall "cvMinMaxLoc" c'cvMinMaxLoc
  :: Ptr C'CvArr -> Ptr CDouble -> Ptr CDouble -> Ptr C'CvPoint -> Ptr C'CvPoint -> Ptr C'CvArr -> IO ()
foreign import ccall "&cvMinMaxLoc" p'cvMinMaxLoc
  :: FunPtr (Ptr C'CvArr -> Ptr CDouble -> Ptr CDouble -> Ptr C'CvPoint -> Ptr C'CvPoint -> Ptr C'CvArr -> IO ())

{-# LINE 131 "CV/Bindings/Core.hsc" #-}

-- | CVAPI(void) cvAvgSdv(
-- |   const CvArr* arr,
-- |   CvScalar* mean,
-- |   CvScalar* std_dev,
-- |   const CvArr* mask CV_DEFAULT(NULL)
-- | );

-- | Calculates mean and standard deviation of pixel values.
foreign import ccall "cvAvgSdv" c'cvAvgSdv
  :: Ptr BareImage -> Ptr C'CvScalar -> Ptr C'CvScalar -> Ptr C'CvArr -> IO ()
foreign import ccall "&cvAvgSdv" p'cvAvgSdv
  :: FunPtr (Ptr BareImage -> Ptr C'CvScalar -> Ptr C'CvScalar -> Ptr C'CvArr -> IO ())

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

-- types of array norm

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

{-# LINE 145 "CV/Bindings/Core.hsc" #-}
c'CV_L1 = 2
c'CV_L1 :: (Num a) => a

{-# LINE 146 "CV/Bindings/Core.hsc" #-}
c'CV_L2 = 4
c'CV_L2 :: (Num a) => a

{-# LINE 147 "CV/Bindings/Core.hsc" #-}
c'CV_NORM_MASK = 7
c'CV_NORM_MASK :: (Num a) => a

{-# LINE 148 "CV/Bindings/Core.hsc" #-}
c'CV_RELATIVE = 8
c'CV_RELATIVE :: (Num a) => a

{-# LINE 149 "CV/Bindings/Core.hsc" #-}
c'CV_DIFF = 16
c'CV_DIFF :: (Num a) => a

{-# LINE 150 "CV/Bindings/Core.hsc" #-}
c'CV_MINMAX = 32
c'CV_MINMAX :: (Num a) => a

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

c'CV_DIFF_C = 17
c'CV_DIFF_C :: (Num a) => a

{-# LINE 153 "CV/Bindings/Core.hsc" #-}
c'CV_DIFF_L1 = 18
c'CV_DIFF_L1 :: (Num a) => a

{-# LINE 154 "CV/Bindings/Core.hsc" #-}
c'CV_DIFF_L2 = 20
c'CV_DIFF_L2 :: (Num a) => a

{-# LINE 155 "CV/Bindings/Core.hsc" #-}
c'CV_RELATIVE_C = 9
c'CV_RELATIVE_C :: (Num a) => a

{-# LINE 156 "CV/Bindings/Core.hsc" #-}
c'CV_RELATIVE_L1 = 10
c'CV_RELATIVE_L1 :: (Num a) => a

{-# LINE 157 "CV/Bindings/Core.hsc" #-}
c'CV_RELATIVE_L2 = 12
c'CV_RELATIVE_L2 :: (Num a) => a

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

-- CVAPI(void) cvNormalize(
--   const CvArr* src,
--   CvArr* dst,
--   double a CV_DEFAULT(1.),
--   double b CV_DEFAULT(0.),
--   int norm_type CV_DEFAULT(CV_L2),
--   const CvArr* mask CV_DEFAULT(NULL)
-- );

foreign import ccall "cvNormalize" c'cvNormalize
  :: Ptr C'CvArr -> Ptr C'CvArr -> CDouble -> CDouble -> CInt -> Ptr C'CvArr -> IO ()
foreign import ccall "&cvNormalize" p'cvNormalize
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvArr -> CDouble -> CDouble -> CInt -> Ptr C'CvArr -> IO ())

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

-- stuff related to DFT

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

{-# LINE 173 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_INVERSE = 1
c'CV_DXT_INVERSE :: (Num a) => a

{-# LINE 174 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_SCALE = 2
c'CV_DXT_SCALE :: (Num a) => a

{-# LINE 175 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_INV_SCALE = 3
c'CV_DXT_INV_SCALE :: (Num a) => a

{-# LINE 176 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_ROWS = 4
c'CV_DXT_ROWS :: (Num a) => a

{-# LINE 177 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_MUL_CONJ = 8
c'CV_DXT_MUL_CONJ :: (Num a) => a

{-# LINE 178 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_COMPLEX_OUTPUT = 16
c'CV_DXT_COMPLEX_OUTPUT :: (Num a) => a

{-# LINE 179 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_REAL_OUTPUT = 32
c'CV_DXT_REAL_OUTPUT :: (Num a) => a

{-# LINE 180 "CV/Bindings/Core.hsc" #-}
c'CV_DXT_INV_REAL = 33
c'CV_DXT_INV_REAL :: (Num a) => a

{-# LINE 181 "CV/Bindings/Core.hsc" #-}

-- CVAPI(void) cvDFT(
--   const CvArr* src,
--   CvArr* dst,
--   int flags,
--   int nonzero_rows CV_DEFAULT(0)
-- );

-- Discrete Fourier Transform:
--   complex->complex,
--   real->ccs (forward),
--   ccs->real (inverse)

foreign import ccall "cvDFT" c'cvDFT
  :: Ptr C'CvArr -> Ptr C'CvArr -> CInt -> CInt -> IO ()
foreign import ccall "&cvDFT" p'cvDFT
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvArr -> CInt -> CInt -> IO ())

{-# LINE 195 "CV/Bindings/Core.hsc" #-}

-- #ccall cvWrapDFT , Ptr <CvArr> -> Ptr <CvArr> -> IO ()

-- #ccall cvWrapIDFT , Ptr <CvArr> -> Ptr <CvArr> -> IO ()

-- CVAPI(void) cvMulSpectrums(
--   const CvArr* src1,
--   const CvArr* src2,
--   CvArr* dst,
--   int flags
-- );

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

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

-- Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y))

foreign import ccall "cvMulSpectrums" c'cvMulSpectrums
  :: Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ()
foreign import ccall "&cvMulSpectrums" p'cvMulSpectrums
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ())

{-# LINE 212 "CV/Bindings/Core.hsc" #-}

-- CVAPI(int) cvGetOptimalDFTSize(
--   int size0
-- );

-- Finds optimal DFT vector size >= size0
-- Note: this function has no side effects, thus not called in IO monad.

foreign import ccall "cvGetOptimalDFTSize" c'cvGetOptimalDFTSize
  :: CInt -> CInt
foreign import ccall "&cvGetOptimalDFTSize" p'cvGetOptimalDFTSize
  :: FunPtr (CInt -> CInt)

{-# LINE 221 "CV/Bindings/Core.hsc" #-}

-- CVAPI(void) cvDCT(
--   const CvArr* src
--   CvArr* dst,
--   int flags
-- );

-- Discrete Cosine Transform

foreign import ccall "cvDCT" c'cvDCT
  :: Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ()
foreign import ccall "&cvDCT" p'cvDCT
  :: FunPtr (Ptr C'CvArr -> Ptr C'CvArr -> CInt -> IO ())

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