{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE ViewPatterns        #-}
--------------------------------------------------------------------------------
-- |
-- Module      : ArrayFire.Vision
-- Copyright   : David Johnson (c) 2019-2026
-- License     : BSD 3
-- Maintainer  : David Johnson <code@dmj.io>
-- Stability   : Experimental
-- Portability : GHC
--
-- Functions pertaining to Computer Vision.
--
--------------------------------------------------------------------------------
module ArrayFire.Vision where

import Control.Exception           hiding (TypeError)
import Data.Typeable
import Foreign.ForeignPtr
import Foreign.Marshal
import Foreign.Storable
import System.IO.Unsafe

import Data.Word (Word32)

import ArrayFire.Exception
import ArrayFire.FFI
import ArrayFire.Internal.Features
import ArrayFire.Internal.Vision
import ArrayFire.Internal.Types

-- | FAST feature detectors
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__fast.htm)
--
-- A circle of radius 3 pixels, translating into a total of 16 pixels, is checked for sequential segments of pixels much brighter or much darker than the central one.
-- For a pixel p to be considered a feature, there must exist a sequential segment of arc_length pixels in the circle around it such that all are greather than (p + thr) or smaller than (p - thr).
-- After all features in the image are detected, if nonmax is true, the non-maximal suppression is applied, checking all detected features and the features detected in its 8-neighborhood and discard it if its score is non maximal.
fast
  :: Array a
  -- ^ Array containing a grayscale image (color images are not supported)
  -> Float
  -- ^ FAST threshold for which a pixel of the circle around the central pixel is considered to be greater or smaller
  -> Int
  -- ^ Length of arc (or sequential segment) to be tested, must be within range [9-16]
  -> Bool
  -- ^ Performs non-maximal suppression if true
  -> Float
  -- ^ Maximum ratio of features to detect, the maximum number of features is calculated by feature_ratio * in.elements(). The maximum number of features is not based on the score, instead, features detected after the limit is reached are discarded
  -> Int
  -- ^ Is the length of the edges in the image to be discarded by FAST (minimum is 3, as the radius of the circle)
  -> Features
  -- ^ Struct containing arrays for x and y coordinates and score, while array orientation is set to 0 as FAST does not compute orientation, and size is set to 1 as FAST does not compute multiple scales
{-# NOINLINE fast #-}
fast :: forall a.
Array a -> Float -> Int -> Bool -> Float -> Int -> Features
fast (Array ForeignPtr ()
fptr) Float
thr (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
arc) (Int -> CBool
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CBool) -> (Bool -> Int) -> Bool -> CBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum -> CBool
non) Float
ratio (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
edge)
  = IO Features -> Features
forall a. IO a -> a
unsafePerformIO (IO Features -> Features)
-> ((AFFeatures -> IO Features) -> IO Features)
-> (AFFeatures -> IO Features)
-> Features
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO Features -> IO Features
forall a. IO a -> IO a
mask_ (IO Features -> IO Features)
-> ((AFFeatures -> IO Features) -> IO Features)
-> (AFFeatures -> IO Features)
-> IO Features
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr () -> (AFFeatures -> IO Features) -> IO Features
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFFeatures -> IO Features) -> Features)
-> (AFFeatures -> IO Features) -> Features
forall a b. (a -> b) -> a -> b
$ \AFFeatures
aptr ->
      do feat <- (Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures)
-> (Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
ptr -> do
           AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFFeatures
-> AFFeatures
-> Float
-> CUInt
-> CBool
-> Float
-> CUInt
-> IO AFErr
af_fast Ptr AFFeatures
ptr AFFeatures
aptr Float
thr CUInt
arc CBool
non Float
ratio CUInt
edge
           Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
ptr
         Features <$>
           newForeignPtr af_release_features feat

-- | Harris corner detection
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__harris.htm)
--
-- Harris corner detector.
--
harris
  :: Array a
  -- ^ array containing a grayscale image (color images are not supported)
  -> Int
  -- ^ maximum number of corners to keep, only retains those with highest Harris responses
  -> Float
  -- ^ minimum response in order for a corner to be retained, only used if max_corners = 0
  -> Float
  -- ^ the standard deviation of a circular window (its dimensions will be calculated according to the standard deviation), the covariation matrix will be calculated to a circular neighborhood of this standard deviation (only used when block_size == 0, must be >= 0.5f and <= 5.0f)
  -> Int
  -- ^ square window size, the covariation matrix will be calculated to a square neighborhood of this size (must be >= 3 and <= 31)
  -> Float
  -- ^ Harris constant k, the sensitivity factor used in the corner response formula (usually 0.04)
  -> Features
  -- ^ struct containing arrays for x and y coordinates and score (Harris response), while arrays orientation and size are set to 0 and 1, respectively, because Harris does not compute that information
{-# NOINLINE harris #-}
harris :: forall a.
Array a -> Int -> Float -> Float -> Int -> Float -> Features
harris (Array ForeignPtr ()
fptr) (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
maxc) Float
minresp Float
sigma (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
bs) Float
thr
  = IO Features -> Features
forall a. IO a -> a
unsafePerformIO (IO Features -> Features)
-> ((AFFeatures -> IO Features) -> IO Features)
-> (AFFeatures -> IO Features)
-> Features
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO Features -> IO Features
forall a. IO a -> IO a
mask_ (IO Features -> IO Features)
-> ((AFFeatures -> IO Features) -> IO Features)
-> (AFFeatures -> IO Features)
-> IO Features
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr () -> (AFFeatures -> IO Features) -> IO Features
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFFeatures -> IO Features) -> Features)
-> (AFFeatures -> IO Features) -> Features
forall a b. (a -> b) -> a -> b
$ \AFFeatures
aptr ->
      do feat <- (Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures)
-> (Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
ptr -> do
           AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFFeatures
-> AFFeatures
-> CUInt
-> Float
-> Float
-> CUInt
-> Float
-> IO AFErr
af_harris Ptr AFFeatures
ptr AFFeatures
aptr CUInt
maxc Float
minresp Float
sigma CUInt
bs Float
thr
           Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
ptr
         Features <$>
           newForeignPtr af_release_features feat

-- | ORB Feature descriptor
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__orb.htm)
--
-- Extract ORB descriptors from FAST features that hold higher Harris responses. FAST does not compute orientation, thus, orientation of features is calculated using the intensity centroid. As FAST is also not multi-scale enabled, a multi-scale pyramid is calculated by downsampling the input image multiple times followed by FAST feature detection on each scale.
-- 
orb
  :: Array a
  -- ^ 'Array' containing a grayscale image (color images are not supported)
  -> Float
  -- ^ FAST threshold for which a pixel of the circle around the central pixel is considered to be brighter or darker
  -> Int
  -- ^ maximum number of features to hold (will only keep the max_feat features with higher Harris responses)
  -> Float
  -- ^ factor to downsample the input image, meaning that each level will hold prior level dimensions divided by scl_fctr
  -> Int
  -- ^ number of levels to be computed for the image pyramid
  -> Bool
  -- ^ blur image with a Gaussian filter with sigma=2 before computing descriptors to increase robustness against noise if true
  -> (Features, Array a)
  -- ^ 'Features' struct composed of arrays for x and y coordinates, score, orientation and size of selected features
{-# NOINLINE orb #-}
orb :: forall a.
Array a
-> Float -> Int -> Float -> Int -> Bool -> (Features, Array a)
orb (Array ForeignPtr ()
fptr) Float
thr (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
feat) Float
scl (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
levels) (Int -> CBool
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CBool) -> (Bool -> Int) -> Bool -> CBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum -> CBool
blur)
  = IO (Features, Array a) -> (Features, Array a)
forall a. IO a -> a
unsafePerformIO (IO (Features, Array a) -> (Features, Array a))
-> ((AFFeatures -> IO (Features, Array a))
    -> IO (Features, Array a))
-> (AFFeatures -> IO (Features, Array a))
-> (Features, Array a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Features, Array a) -> IO (Features, Array a)
forall a. IO a -> IO a
mask_ (IO (Features, Array a) -> IO (Features, Array a))
-> ((AFFeatures -> IO (Features, Array a))
    -> IO (Features, Array a))
-> (AFFeatures -> IO (Features, Array a))
-> IO (Features, Array a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr ()
-> (AFFeatures -> IO (Features, Array a)) -> IO (Features, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFFeatures -> IO (Features, Array a)) -> (Features, Array a))
-> (AFFeatures -> IO (Features, Array a)) -> (Features, Array a)
forall a b. (a -> b) -> a -> b
$ \AFFeatures
inptr ->
      do (feature, arr) <-
           (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
 -> IO (AFFeatures, AFFeatures))
-> (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
aptr -> do
             (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
 -> IO (AFFeatures, AFFeatures))
-> (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
bptr -> do
               AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFFeatures
-> Ptr AFFeatures
-> AFFeatures
-> Float
-> CUInt
-> Float
-> CUInt
-> CBool
-> IO AFErr
af_orb Ptr AFFeatures
aptr Ptr AFFeatures
bptr AFFeatures
inptr Float
thr CUInt
feat Float
scl CUInt
levels CBool
blur
               (,) (AFFeatures -> AFFeatures -> (AFFeatures, AFFeatures))
-> IO AFFeatures -> IO (AFFeatures -> (AFFeatures, AFFeatures))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
aptr IO (AFFeatures -> (AFFeatures, AFFeatures))
-> IO AFFeatures -> IO (AFFeatures, AFFeatures)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
bptr
         feats <- Features <$> newForeignPtr af_release_features feature
         array <- Array <$> newForeignPtr af_release_array_finalizer arr
         pure (feats, array)

-- | SIFT feature detector and descriptor extractor.
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__sift.htm)
--
-- C Interface for SIFT feature detector and descriptor.
-- 
sift
  :: Array a
  -- ^ Array containing a grayscale image (color images are not supported)
  -> Int
  -- ^ number of layers per octave, the number of octaves is computed automatically according to the input image dimensions, the original SIFT paper suggests 3
  -> Float
  -- ^ threshold used to filter out features that have low contrast, the original SIFT paper suggests 0.04
  -> Float
  -- ^ threshold used to filter out features that are too edge-like, the original SIFT paper suggests 10.0
  -> Float
  -- ^ the sigma value used to filter the input image at the first octave, the original SIFT paper suggests 1.6
  -> Bool
  -- ^ if true, the input image dimensions will be doubled and the doubled image will be used for the first octave
  -> Float
  -- ^ the inverse of the difference between the minimum and maximum grayscale intensity value, e.g.: if the ranges are 0-256, the proper intensity_scale value is 1/256, if the ranges are 0-1, the proper intensity-scale value is 1/1
  -> Float
  -- ^ maximum ratio of features to detect, the maximum number of features is calculated by feature_ratio * in.elements(). The maximum number of features is not based on the score, instead, features detected after the limit is reached are discarded
  -> (Features, Array a)
  -- ^ Features object composed of arrays for x and y coordinates, score, orientation and size of selected features
  -- Nx128 array containing extracted descriptors, where N is the number of features found by SIFT
{-# NOINLINE sift #-}
sift :: forall a.
Array a
-> Int
-> Float
-> Float
-> Float
-> Bool
-> Float
-> Float
-> (Features, Array a)
sift (Array ForeignPtr ()
fptr) (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
a) Float
b Float
c Float
d (Int -> CBool
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CBool) -> (Bool -> Int) -> Bool -> CBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum -> CBool
e) Float
f Float
g
  = IO (Features, Array a) -> (Features, Array a)
forall a. IO a -> a
unsafePerformIO (IO (Features, Array a) -> (Features, Array a))
-> ((AFFeatures -> IO (Features, Array a))
    -> IO (Features, Array a))
-> (AFFeatures -> IO (Features, Array a))
-> (Features, Array a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Features, Array a) -> IO (Features, Array a)
forall a. IO a -> IO a
mask_ (IO (Features, Array a) -> IO (Features, Array a))
-> ((AFFeatures -> IO (Features, Array a))
    -> IO (Features, Array a))
-> (AFFeatures -> IO (Features, Array a))
-> IO (Features, Array a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr ()
-> (AFFeatures -> IO (Features, Array a)) -> IO (Features, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFFeatures -> IO (Features, Array a)) -> (Features, Array a))
-> (AFFeatures -> IO (Features, Array a)) -> (Features, Array a)
forall a b. (a -> b) -> a -> b
$ \AFFeatures
inptr ->
      do (feat, arr) <-
           (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
 -> IO (AFFeatures, AFFeatures))
-> (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
aptr -> do
             (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
 -> IO (AFFeatures, AFFeatures))
-> (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
bptr -> do
               AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFFeatures
-> Ptr AFFeatures
-> AFFeatures
-> CUInt
-> Float
-> Float
-> Float
-> CBool
-> Float
-> Float
-> IO AFErr
af_sift Ptr AFFeatures
aptr Ptr AFFeatures
bptr AFFeatures
inptr CUInt
a Float
b Float
c Float
d CBool
e Float
f Float
g
               (,) (AFFeatures -> AFFeatures -> (AFFeatures, AFFeatures))
-> IO AFFeatures -> IO (AFFeatures -> (AFFeatures, AFFeatures))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
aptr IO (AFFeatures -> (AFFeatures, AFFeatures))
-> IO AFFeatures -> IO (AFFeatures, AFFeatures)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
bptr
         feats <- Features <$> newForeignPtr af_release_features feat
         array <- Array <$> newForeignPtr af_release_array_finalizer arr
         pure (feats, array)

-- | SIFT feature detector and descriptor extractor.
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__gloh.htm)
--
-- C Interface for SIFT feature detector and descriptor.
-- 
gloh
  :: Array a
  -- ^ 'Array' containing a grayscale image (color images are not supported)
  -> Int
  -- ^ number of layers per octave, the number of octaves is computed automatically according to the input image dimensions, the original SIFT paper suggests 3
  -> Float
  -- ^ threshold used to filter out features that have low contrast, the original SIFT paper suggests 0.04
  -> Float
  -- ^ threshold used to filter out features that are too edge-like, the original SIFT paper suggests 10.0
  -> Float
  -- ^ the sigma value used to filter the input image at the first octave, the original SIFT paper suggests 1.6
  -> Bool
  -- ^ if true, the input image dimensions will be doubled and the doubled image will be used for the first octave
  -> Float
  -- ^ the inverse of the difference between the minimum and maximum grayscale intensity value, e.g.: if the ranges are 0-256, the proper intensity_scale value is 1/256, if the ranges are 0-1, the proper intensity-scale value is 1/1
  -> Float
  -- ^ maximum ratio of features to detect, the maximum number of features is calculated by feature_ratio * in.elements(). The maximum number of features is not based on the score, instead, features detected after the limit is reached are discarded
  -> (Features, Array a)
  -- ^ 'Features' object composed of arrays for x and y coordinates, score, orientation and size of selected features
  -- ^ Nx272 array containing extracted GLOH descriptors, where N is the number of features found by SIFT
{-# NOINLINE gloh #-}
gloh :: forall a.
Array a
-> Int
-> Float
-> Float
-> Float
-> Bool
-> Float
-> Float
-> (Features, Array a)
gloh (Array ForeignPtr ()
fptr) (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
a) Float
b Float
c Float
d (Int -> CBool
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CBool) -> (Bool -> Int) -> Bool -> CBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum -> CBool
e) Float
f Float
g
  = IO (Features, Array a) -> (Features, Array a)
forall a. IO a -> a
unsafePerformIO (IO (Features, Array a) -> (Features, Array a))
-> ((AFFeatures -> IO (Features, Array a))
    -> IO (Features, Array a))
-> (AFFeatures -> IO (Features, Array a))
-> (Features, Array a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Features, Array a) -> IO (Features, Array a)
forall a. IO a -> IO a
mask_ (IO (Features, Array a) -> IO (Features, Array a))
-> ((AFFeatures -> IO (Features, Array a))
    -> IO (Features, Array a))
-> (AFFeatures -> IO (Features, Array a))
-> IO (Features, Array a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr ()
-> (AFFeatures -> IO (Features, Array a)) -> IO (Features, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFFeatures -> IO (Features, Array a)) -> (Features, Array a))
-> (AFFeatures -> IO (Features, Array a)) -> (Features, Array a)
forall a b. (a -> b) -> a -> b
$ \AFFeatures
inptr ->
      do (feat, arr) <-
           (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
 -> IO (AFFeatures, AFFeatures))
-> (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
aptr -> do
             (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
 -> IO (AFFeatures, AFFeatures))
-> (Ptr AFFeatures -> IO (AFFeatures, AFFeatures))
-> IO (AFFeatures, AFFeatures)
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
bptr -> do
               AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFFeatures
-> Ptr AFFeatures
-> AFFeatures
-> CUInt
-> Float
-> Float
-> Float
-> CBool
-> Float
-> Float
-> IO AFErr
af_gloh Ptr AFFeatures
aptr Ptr AFFeatures
bptr AFFeatures
inptr CUInt
a Float
b Float
c Float
d CBool
e Float
f Float
g
               (,) (AFFeatures -> AFFeatures -> (AFFeatures, AFFeatures))
-> IO AFFeatures -> IO (AFFeatures -> (AFFeatures, AFFeatures))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
aptr IO (AFFeatures -> (AFFeatures, AFFeatures))
-> IO AFFeatures -> IO (AFFeatures, AFFeatures)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
bptr
         feats <- Features <$> newForeignPtr af_release_features feat
         array <- Array <$> newForeignPtr af_release_array_finalizer arr
         pure (feats, array)

-- | Hamming Matcher
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__hamming__matcher.htm)
--
-- Calculates Hamming distances between two 2-dimensional arrays containing features, one of the arrays containing the training data and the other the query data. One of the dimensions of the both arrays must be equal among them, identifying the length of each feature. The other dimension indicates the total number of features in each of the training and query arrays. Two 1-dimensional arrays are created as results, one containg the smallest N distances of the query array and another containing the indices of these distances in the training array. The resulting 1-dimensional arrays have length equal to the number of features contained in the query array.
-- 
hammingMatcher
 :: Array a
 -- ^ is the 'Array' containing the data to be queried
 -> Array a
 -- ^ is the 'Array' containing the data used as training data
 -> Int
 -- ^ indicates the dimension to analyze for distance (the dimension indicated here must be of equal length for both query and train arrays)
 -> Int
 -- ^ is the number of smallest distances to return (currently, only 1 is supported)
 -> (Array Word32, Array a)
 -- ^ first component: an array of MxN size, where M is equal to the number of query features and N is equal to n_dist. The value at position IxJ indicates the index (@u32@) of the Jth smallest distance to the Ith query value in the train data array.
 -- second component: an array of MxN size, where M is equal to the number of query features and N is equal to n_dist. The value at position IxJ indicates the Hamming distance of the Jth smallest distance to the Ith query value in the train data array.
hammingMatcher :: forall a.
Array a -> Array a -> Int -> Int -> (Array Word32, Array a)
hammingMatcher Array a
a Array a
b (Int -> DimT
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> DimT
x) (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
y)
  = Array a
-> Array a
-> (Ptr AFFeatures
    -> Ptr AFFeatures -> AFFeatures -> AFFeatures -> IO AFErr)
-> (Array Word32, Array a)
forall a b c d.
Array a
-> Array b
-> (Ptr AFFeatures
    -> Ptr AFFeatures -> AFFeatures -> AFFeatures -> IO AFErr)
-> (Array c, Array d)
op2p2 Array a
a Array a
b (\Ptr AFFeatures
p Ptr AFFeatures
c AFFeatures
d AFFeatures
e -> Ptr AFFeatures
-> Ptr AFFeatures
-> AFFeatures
-> AFFeatures
-> DimT
-> CUInt
-> IO AFErr
af_hamming_matcher Ptr AFFeatures
p Ptr AFFeatures
c AFFeatures
d AFFeatures
e DimT
x CUInt
y)

-- | Nearest Neighbor
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__nearest__neighbour.htm)
--
-- Calculates nearest distances between two 2-dimensional arrays containing features based on the type of distance computation chosen. Currently, AF_SAD (sum of absolute differences), AF_SSD (sum of squared differences) and AF_SHD (hamming distance) are supported. One of the arrays containing the training data and the other the query data. One of the dimensions of the both arrays must be equal among them, identifying the length of each feature. The other dimension indicates the total number of features in each of the training and query arrays. Two 1-dimensional arrays are created as results, one containg the smallest N distances of the query array and another containing the indices of these distances in the training array. The resulting 1-dimensional arrays have length equal to the number of features contained in the query array.
-- 
nearestNeighbor
 :: Array a
 -- ^ is the array containing the data to be queried
 -> Array a
 -- ^ is the array containing the data used as training data
 -> Int
 -- ^ indicates the dimension to analyze for distance (the dimension indicated here must be of equal length for both query and train arrays)
 -> Int
 -- ^ is the number of smallest distances to return (currently, only values <= 256 are supported)
 -> MatchType
 -- ^ is the distance computation type. Currently AF_SAD (sum of absolute differences), AF_SSD (sum of squared differences), and AF_SHD (hamming distances) are supported.
 -> (Array Word32, Array a)
 -- ^ first component: an array of MxN size, where M is equal to the number of query features and N is equal to n_dist. The value at position IxJ indicates the index (@u32@) of the Jth smallest distance to the Ith query value in the train data array.
 -- second component: an array of MxN size, where M is equal to the number of query features and N is equal to n_dist. The value at position IxJ indicates the distance of the Jth smallest distance to the Ith query value in the train data array based on the dist_type chosen.
nearestNeighbor :: forall a.
Array a
-> Array a -> Int -> Int -> MatchType -> (Array Word32, Array a)
nearestNeighbor Array a
a Array a
b (Int -> DimT
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> DimT
x) (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
y) (MatchType -> AFMatchType
fromMatchType -> AFMatchType
match)
  = Array a
-> Array a
-> (Ptr AFFeatures
    -> Ptr AFFeatures -> AFFeatures -> AFFeatures -> IO AFErr)
-> (Array Word32, Array a)
forall a b c d.
Array a
-> Array b
-> (Ptr AFFeatures
    -> Ptr AFFeatures -> AFFeatures -> AFFeatures -> IO AFErr)
-> (Array c, Array d)
op2p2 Array a
a Array a
b (\Ptr AFFeatures
p Ptr AFFeatures
c AFFeatures
d AFFeatures
e -> Ptr AFFeatures
-> Ptr AFFeatures
-> AFFeatures
-> AFFeatures
-> DimT
-> CUInt
-> AFMatchType
-> IO AFErr
af_nearest_neighbour Ptr AFFeatures
p Ptr AFFeatures
c AFFeatures
d AFFeatures
e DimT
x CUInt
y AFMatchType
match)

-- | Nearest Neighbor
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__match__template.htm)
--
-- C Interface for image template matching.
-- 
matchTemplate
 :: Array a
 -- ^ is an 'Array' with image data
 -> Array a
 -- ^ is the template we are looking for in the image
 -> MatchType
 -- ^ is metric that should be used to calculate the disparity between window in the image and the template image. It can be one of the values defined by the enum af_match_type
 -> Array a
 -- ^ will have disparity values for the window starting at corresponding pixel position
matchTemplate :: forall a. Array a -> Array a -> MatchType -> Array a
matchTemplate Array a
a Array a
b (MatchType -> AFMatchType
fromMatchType -> AFMatchType
match)
  = Array a
-> Array a
-> (Ptr AFFeatures -> AFFeatures -> AFFeatures -> IO AFErr)
-> Array a
forall b a c.
Array b
-> Array a
-> (Ptr AFFeatures -> AFFeatures -> AFFeatures -> IO AFErr)
-> Array c
op2 Array a
a Array a
b (\Ptr AFFeatures
p AFFeatures
c AFFeatures
d -> Ptr AFFeatures
-> AFFeatures -> AFFeatures -> AFMatchType -> IO AFErr
af_match_template Ptr AFFeatures
p AFFeatures
c AFFeatures
d AFMatchType
match)

-- | SUSAN corner detector.
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__susan.htm)
--
-- SUSAN is an acronym standing for Smallest Univalue Segment Assimilating Nucleus. This method places a circular disc over the pixel to be tested (a.k.a nucleus) to compute the corner measure of that corresponding pixel. The region covered by the circular disc is M, and a pixel in this region is represented by m   M where m  0 is the nucleus. Every pixel in the region is compared to the nucleus using the following comparison function:
--
susan
  :: Array a
  -- ^ is input grayscale/intensity image
  -> Int
  -- ^ nucleus radius for each pixel neighborhood
  -> Float
  -- ^ intensity difference threshold a.k.a t from equations in description
  -> Float
  -- ^ geometric threshold
  -> Float
  -- ^ is maximum number of features that will be returned by the function
  -> Int
  -- ^ indicates how many pixels width area should be skipped for corner detection
  -> Features
{-# NOINLINE susan #-}
susan :: forall a.
Array a -> Int -> Float -> Float -> Float -> Int -> Features
susan (Array ForeignPtr ()
fptr) (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
a) Float
b Float
c Float
d (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
e)
  = IO Features -> Features
forall a. IO a -> a
unsafePerformIO (IO Features -> Features)
-> ((AFFeatures -> IO Features) -> IO Features)
-> (AFFeatures -> IO Features)
-> Features
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO Features -> IO Features
forall a. IO a -> IO a
mask_ (IO Features -> IO Features)
-> ((AFFeatures -> IO Features) -> IO Features)
-> (AFFeatures -> IO Features)
-> IO Features
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr () -> (AFFeatures -> IO Features) -> IO Features
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFFeatures -> IO Features) -> Features)
-> (AFFeatures -> IO Features) -> Features
forall a b. (a -> b) -> a -> b
$ \AFFeatures
inptr ->
      do feat <-
           (Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures)
-> (Ptr AFFeatures -> IO AFFeatures) -> IO AFFeatures
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
aptr -> do
             AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFFeatures
-> AFFeatures
-> CUInt
-> Float
-> Float
-> Float
-> CUInt
-> IO AFErr
af_susan Ptr AFFeatures
aptr AFFeatures
inptr CUInt
a Float
b Float
c Float
d CUInt
e
             Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
aptr
         Features <$> newForeignPtr af_release_features feat

-- | Difference of Gaussians.
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__dog.htm)
--
-- Given an image, this function computes two different versions of smoothed input image using the difference smoothing parameters and subtracts one from the other and returns the result.
--
dog
 :: Array a
 -- ^ is input image
 -> Int
 -- ^ is the radius of first gaussian kernel
 -> Int
 -- ^ is the radius of second gaussian kernel
 -> Array a
 -- ^ is difference of smoothed inputs
dog :: forall a. Array a -> Int -> Int -> Array a
dog Array a
a (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CInt
x) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CInt
y) =
  Array a -> (Ptr AFFeatures -> AFFeatures -> IO AFErr) -> Array a
forall a b.
Array a -> (Ptr AFFeatures -> AFFeatures -> IO AFErr) -> Array b
op1 Array a
a (\Ptr AFFeatures
p AFFeatures
c -> Ptr AFFeatures -> AFFeatures -> CInt -> CInt -> IO AFErr
af_dog Ptr AFFeatures
p AFFeatures
c CInt
x CInt
y)

-- | Homography Estimation.
--
-- [ArrayFire Docs](http://arrayfire.org/docs/group__cv__func__homography.htm)
--
-- Homography estimation find a perspective transform between two sets of 2D points.
--
homography
 :: forall a . AFType a
 => Array a
 -- ^ x coordinates of the source points.
 -> Array a
 -- ^ y coordinates of the source points.
 -> Array a
 -- ^ x coordinates of the destination points.
 -> Array a
 -- ^ y coordinates of the destination points.
 -> HomographyType
 -- ^ htype, can be AF_HOMOGRAPHY_RANSAC, for which a
 -- RANdom SAmple Consensus will be used to evaluate
 -- the homography quality (e.g., number of inliers),
 -- or AF_HOMOGRAPHY_LMEDS, which will use
 -- Least Median of Squares method to evaluate homography quality.
 -> Float
  -- ^ If htype is AF_HOMOGRAPHY_RANSAC, this parameter will five the maximum L2-distance for a point to be considered an inlier.
 -> Int
  -- ^ maximum number of iterations when htype is AF_HOMOGRAPHY_RANSAC and backend is CPU, if backend is CUDA or OpenCL, iterations is the total number of iterations, an iteration is a selection of 4 random points for which the homography is estimated and evaluated for number of inliers.
 -> (Int, Array a)
 -- ^ is a 3x3 array containing the estimated homography.
 -- is the number of inliers that the homography was estimated to comprise, in the case that htype is AF_HOMOGRAPHY_RANSAC, a higher inlier_thr value will increase the estimated inliers. Note that if the number of inliers is too low, it is likely that a bad homography will be returned.
{-# NOINLINE homography #-}
homography :: forall a.
AFType a =>
Array a
-> Array a
-> Array a
-> Array a
-> HomographyType
-> Float
-> Int
-> (Int, Array a)
homography
  (Array ForeignPtr ()
a)
  (Array ForeignPtr ()
b)
  (Array ForeignPtr ()
c)
  (Array ForeignPtr ()
d)
  (HomographyType -> AFHomographyType
fromHomographyType -> AFHomographyType
homo)
  Float
inlier
  (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CUInt
iterations) = do
    IO (Int, Array a) -> (Int, Array a)
forall a. IO a -> a
unsafePerformIO (IO (Int, Array a) -> (Int, Array a))
-> (IO (Int, Array a) -> IO (Int, Array a))
-> IO (Int, Array a)
-> (Int, Array a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Int, Array a) -> IO (Int, Array a)
forall a. IO a -> IO a
mask_ (IO (Int, Array a) -> (Int, Array a))
-> IO (Int, Array a) -> (Int, Array a)
forall a b. (a -> b) -> a -> b
$ do
      ForeignPtr ()
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
a ((AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a))
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. (a -> b) -> a -> b
$ \AFFeatures
aptr ->
        ForeignPtr ()
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
b ((AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a))
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. (a -> b) -> a -> b
$ \AFFeatures
bptr ->
          ForeignPtr ()
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
c ((AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a))
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. (a -> b) -> a -> b
$ \AFFeatures
cptr ->
            ForeignPtr ()
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
d ((AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a))
-> (AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. (a -> b) -> a -> b
$ \AFFeatures
dptr -> do
              (Ptr AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a))
-> (Ptr AFFeatures -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. (a -> b) -> a -> b
$ \Ptr AFFeatures
outPtrA ->
                (Ptr CInt -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO (Int, Array a)) -> IO (Int, Array a))
-> (Ptr CInt -> IO (Int, Array a)) -> IO (Int, Array a)
forall a b. (a -> b) -> a -> b
$ \Ptr CInt
outPtrI -> do
                  AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                    Ptr AFFeatures
-> Ptr CInt
-> AFFeatures
-> AFFeatures
-> AFFeatures
-> AFFeatures
-> AFHomographyType
-> Float
-> CUInt
-> AFDtype
-> IO AFErr
af_homography
                      Ptr AFFeatures
outPtrA
                      Ptr CInt
outPtrI
                      AFFeatures
aptr
                      AFFeatures
bptr
                      AFFeatures
cptr
                      AFFeatures
dptr
                      AFHomographyType
homo
                      Float
inlier
                      CUInt
iterations
                      AFDtype
dtype
                  arrayPtr <- Ptr AFFeatures -> IO AFFeatures
forall a. Storable a => Ptr a -> IO a
peek Ptr AFFeatures
outPtrA
                  (,) <$> do fromIntegral <$> peek outPtrI
                      <*> do Array <$> newForeignPtr af_release_array_finalizer arrayPtr
    where
      dtype :: AFDtype
dtype = Proxy a -> AFDtype
forall a. AFType a => Proxy a -> AFDtype
afType (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @a)