{-# 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" #-}

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 15 "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 16 "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 17 "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 18 "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 19 "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 20 "CV/Bindings/Core.hsc" #-}

-- Clears all the array elements (sets them to 0)
foreign import ccall "cvSetZero" c'cvSetZero
  :: Ptr BareImage -> IO ()
foreign import ccall "&cvSetZero" p'cvSetZero
  :: FunPtr (Ptr BareImage -> IO ())

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

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

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

foreign import ccall "cvMerge" c'cvMerge
  :: Ptr BareImage -> Ptr BareImage -> Ptr BareImage -> Ptr BareImage -> Ptr BareImage -> IO ()
foreign import ccall "&cvMerge" p'cvMerge
  :: FunPtr (Ptr BareImage -> Ptr BareImage -> Ptr BareImage -> Ptr BareImage -> Ptr BareImage -> IO ())

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

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

{-# LINE 29 "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 42 "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 54 "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 64 "CV/Bindings/Core.hsc" #-}

-- types of array norm

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# LINE 81 "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 BareImage -> Ptr BareImage -> CDouble -> CDouble -> CInt -> Ptr BareImage -> IO ()
foreign import ccall "&cvNormalize" p'cvNormalize
  :: FunPtr (Ptr BareImage -> Ptr BareImage -> CDouble -> CDouble -> CInt -> Ptr BareImage -> IO ())

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

-- stuff related to DFT

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

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

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

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

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

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

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

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

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

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

{-# LINE 105 "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 BareImage -> Ptr BareImage -> CInt -> CInt -> IO ()
foreign import ccall "&cvDFT" p'cvDFT
  :: FunPtr (Ptr BareImage -> Ptr BareImage -> CInt -> CInt -> IO ())

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

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

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

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

{-# LINE 130 "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 139 "CV/Bindings/Core.hsc" #-}

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

-- Discrete Cosine Transform

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

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

-- TODO: This might be expanded:
data C'CvSeq = C'CvSeq

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