Updated wrapper to be compliant with ArrayFire 3.2.0

Fixes #31

This change includes the following modifications:

* Update ArrayFire version to 3.2.0 in Cargo file
* Update for ArrayFire submodule
* Refactor of enum AfBackend to Backend
* Added following new functions:
    - load_image_native
    - save_image_native
    - homography
    - Window::draw_plot3
    - Window::draw_surface

Author: 9prady9

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name          = "arrayfire"
 description   = "ArrayFire is a high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA, OpenCL and native CPU) make it platform independent and highly portable. A few lines of code in ArrayFire can replace dozens of lines of parallel computing code, saving you valuable time and lowering development costs. This crate provides Rust bindings for ArrayFire library."
-version       = "3.1.3"
+version       = "3.2.0"
 documentation = "http://arrayfire.github.io/arrayfire-rust/arrayfire/index.html"
 homepage      = "https://github.com/arrayfire/arrayfire"
 repository    = "https://github.com/arrayfire/arrayfire-rust"

arrayfire

@@ -24,29 +24,29 @@ fn main() {
   println!("There are {:?} available backends", get_backend_count().unwrap());
   let available = get_available_backends().unwrap();
 
-  if available.contains(&AfBackend::AF_BACKEND_CPU){
+  if available.contains(&Backend::AF_BACKEND_CPU){
     println!("Evaluating CPU Backend...");
-    let err = set_backend(AfBackend::AF_BACKEND_CPU);
+    let err = set_backend(Backend::AF_BACKEND_CPU);
     println!("There are {} CPU compute devices", device_count().unwrap());
       match err {
         Ok(_)  => test_backend(),
         Err(e) => println!("CPU backend error: {}", e),
     };
   }
 
-  if available.contains(&AfBackend::AF_BACKEND_CUDA){
+  if available.contains(&Backend::AF_BACKEND_CUDA){
     println!("Evaluating CUDA Backend...");
-    let err = set_backend(AfBackend::AF_BACKEND_CUDA);
+    let err = set_backend(Backend::AF_BACKEND_CUDA);
     println!("There are {} CUDA compute devices", device_count().unwrap());
       match err {
         Ok(_)  => test_backend(),
         Err(e) => println!("CUDA backend error: {}", e),
     };
   }
 
-  if available.contains(&AfBackend::AF_BACKEND_OPENCL){
+  if available.contains(&Backend::AF_BACKEND_OPENCL){
     println!("Evaluating OpenCL Backend...");
-    let err = set_backend(AfBackend::AF_BACKEND_OPENCL);
+    let err = set_backend(Backend::AF_BACKEND_OPENCL);
     println!("There are {} OpenCL compute devices", device_count().unwrap());
       match err {
         Ok(_)  => test_backend(),

examples/unified.rs

@@ -1,8 +1,7 @@
 extern crate libc;
 
 use dim4::Dim4;
-use defines::AfError;
-use defines::Aftype;
+use defines::{AfError, Aftype, Backend};
 use self::libc::{uint8_t, c_void, c_int, c_uint, c_longlong};
 
 type MutAfArray = *mut self::libc::c_longlong;
@@ -11,6 +10,13 @@ type MutUint    = *mut self::libc::c_uint;
 type AfArray    = self::libc::c_longlong;
 type DimT       = self::libc::c_longlong;
 
+// Some unused functions from array.h in C-API of ArrayFire
+// af_create_handle
+// af_copy_array
+// af_write_array
+// af_get_data_ptr
+// af_get_data_ref_count
+
 #[allow(dead_code)]
 extern {
     fn af_create_array(out: MutAfArray, data: *const c_void,
@@ -64,6 +70,8 @@ extern {
     fn af_print_array(arr: AfArray) -> c_int;
 
     fn af_cast(out: MutAfArray, arr: AfArray, aftype: uint8_t) -> c_int;
+
+    fn af_get_backend_id(backend: *mut c_int, input: AfArray) -> c_int;
 }
 
 /// A multidimensional data container
@@ -114,6 +122,25 @@ impl Array {
         }
     }
 
+    /// Returns the backend of the Array
+    ///
+    /// # Return Values
+    ///
+    /// Returns an value of type `Backend` which indicates which backend
+    /// was active when Array was created.
+    pub fn get_backend(&self) -> Backend {
+        unsafe {
+            let mut ret_val: i32 = 0;
+            af_get_backend_id(&mut ret_val as *mut c_int, self.handle as AfArray);
+            match ret_val {
+                1 => Backend::AF_BACKEND_CPU,
+                2 => Backend::AF_BACKEND_CUDA,
+                3 => Backend::AF_BACKEND_OPENCL,
+                _ => Backend::AF_BACKEND_DEFAULT,
+            }
+        }
+    }
+
     /// Returns the number of elements in the Array
     pub fn elements(&self) -> Result<i64, AfError> {
         unsafe {

src/array.rs

@@ -0,0 +1,58 @@
+extern crate libc;
+
+use defines::{AfError, Backend};
+use self::libc::{c_int, c_uint, uint8_t};
+
+extern {
+    fn af_set_backend(bknd: uint8_t) -> c_int;
+    fn af_get_backend_count(num_backends: *mut c_uint) -> c_int;
+    fn af_get_available_backends(backends: *mut c_int) -> c_int;
+}
+
+/// Toggle backends between cuda, opencl or cpu
+///
+/// # Parameters
+///
+/// - `backend` to which to switch to
+pub fn set_backend(backend: Backend) -> Result<(), AfError> {
+    unsafe {
+        let err_val = af_set_backend(backend as uint8_t);
+        match err_val {
+            0 => Ok(()),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
+
+/// Get the available backend count
+#[allow(unused_mut)]
+pub fn get_backend_count() -> Result<u32, AfError> {
+    unsafe {
+        let mut temp: u32 = 0;
+        let err_val = af_get_backend_count(&mut temp as *mut c_uint);
+        match err_val {
+            0 => Ok(temp),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
+
+
+/// Get the available backends
+#[allow(unused_mut)]
+pub fn get_available_backends() -> Result<Vec<Backend>, AfError> {
+    unsafe {
+        let mut temp: i32 = 0;
+        let err_val = af_get_available_backends(&mut temp as *mut c_int);
+        match err_val {
+            0 => {
+                let mut b = Vec::new();
+                if temp & 0b0100 == 0b0100 { b.push(Backend::AF_BACKEND_OPENCL); }
+                if temp & 0b0010 == 0b0010 { b.push(Backend::AF_BACKEND_CUDA); }
+                if temp & 0b0001 == 0b0001 { b.push(Backend::AF_BACKEND_CPU); }
+                Ok(b)
+            },
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}

src/backend.rs

@@ -49,7 +49,7 @@ pub enum AfError {
 
 #[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub enum AfBackend {
+pub enum Backend {
     /// Default backend order: OpenCL -> CUDA -> CPU
     AF_BACKEND_DEFAULT = 0,
     /// CPU a.k.a sequential algorithms
@@ -60,13 +60,13 @@ pub enum AfBackend {
     AF_BACKEND_OPENCL  = 4
 }
 
-impl Display for AfBackend {
+impl Display for Backend {
     fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
         let text = match *self {
-            AfBackend::AF_BACKEND_OPENCL  => "OpenCL",
-            AfBackend::AF_BACKEND_CUDA    => "Cuda",
-            AfBackend::AF_BACKEND_CPU     => "CPU",
-            AfBackend::AF_BACKEND_DEFAULT => "Default",
+            Backend::AF_BACKEND_OPENCL  => "OpenCL",
+            Backend::AF_BACKEND_CUDA    => "Cuda",
+            Backend::AF_BACKEND_CPU     => "CPU",
+            Backend::AF_BACKEND_DEFAULT => "Default",
         };
         write!(f, "{}", text)
     }
@@ -124,6 +124,10 @@ pub enum Aftype {
     S64 = 8,
     /// 64 bit unsigned integer
     U64 = 9,
+    /// 16 bit signed integer
+    S16 = 10,
+    /// 16 bit unsigned integer
+    U16 = 11,
 }
 
 /// Dictates the interpolation method to be used by a function
@@ -291,3 +295,13 @@ pub enum YCCStd {
     /// ITU-R BT.2020 standard
     YCC_2020 = 2020,
 }
+
+/// Homography type
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub enum HomographyType {
+    /// RANdom SAmple Consensus algorithm
+    RANSAC = 0,
+    /// Least Median of Squares
+    LMEDS  = 1,
+}

src/defines.rs

@@ -1,18 +1,14 @@
 extern crate libc;
 
-use defines::{AfError, AfBackend};
-use self::libc::{c_int, c_uint, uint8_t};
-
+use defines::AfError;
+use self::libc::c_int;
 
 extern {
     fn af_get_version(major: *mut c_int, minor: *mut c_int, patch: *mut c_int) -> c_int;
     fn af_info() -> c_int;
     fn af_get_device_count(nDevices: *mut c_int) -> c_int;
     fn af_get_dbl_support(available: *mut c_int, device: c_int) -> c_int;
     fn af_set_device(device: c_int) -> c_int;
-    fn af_set_backend(bknd: uint8_t) -> c_int;
-    fn af_get_backend_count(num_backends: *mut c_uint) -> c_int;
-    fn af_get_available_backends(backends: *mut c_int) -> c_int;
     fn af_get_device(device: *mut c_int) -> c_int;
     fn af_sync(device: c_int) -> c_int;
 }
@@ -133,51 +129,3 @@ pub fn sync(device: i32) -> Result<(), AfError> {
         }
     }
 }
-
-/// Toggle backends between cuda, opencl or cpu
-///
-/// # Parameters
-///
-/// - `backend` to which to switch to
-pub fn set_backend(backend: AfBackend) -> Result<(), AfError> {
-    unsafe {
-        let err_val = af_set_backend(backend as uint8_t);
-        match err_val {
-            0 => Ok(()),
-            _ => Err(AfError::from(err_val)),
-        }
-    }
-}
-
-/// Get the available backend count
-#[allow(unused_mut)]
-pub fn get_backend_count() -> Result<u32, AfError> {
-    unsafe {
-        let mut temp: u32 = 0;
-        let err_val = af_get_backend_count(&mut temp as *mut c_uint);
-        match err_val {
-            0 => Ok(temp),
-            _ => Err(AfError::from(err_val)),
-        }
-    }
-}
-
-
-/// Get the available backends
-#[allow(unused_mut)]
-pub fn get_available_backends() -> Result<Vec<AfBackend>, AfError> {
-    unsafe {
-        let mut temp: i32 = 0;
-        let err_val = af_get_available_backends(&mut temp as *mut c_int);
-        match err_val {
-            0 => {
-                let mut b = Vec::new();
-                if temp & 0b0100 == 0b0100 { b.push(AfBackend::AF_BACKEND_OPENCL); }
-                if temp & 0b0010 == 0b0010 { b.push(AfBackend::AF_BACKEND_CUDA); }
-                if temp & 0b0001 == 0b0001 { b.push(AfBackend::AF_BACKEND_CPU); }
-                Ok(b)
-            },
-            _ => Err(AfError::from(err_val)),
-        }
-    }
-}

src/device/mod.rs

@@ -16,14 +16,18 @@ extern {
     fn af_create_window(out: MutWndHandle, w: c_int, h: c_int, title: *const c_char) -> c_int;
     fn af_set_position(wnd: WndHandle, x: c_uint, y: c_uint) -> c_int;
     fn af_set_title(wnd: WndHandle, title: *const c_char) -> c_int;
+    fn af_set_size(wnd: WndHandle, w: c_uint, h: c_uint) -> c_int;
     fn af_draw_image(wnd: WndHandle, arr: AfArray, props: CellPtr) -> c_int;
     fn af_draw_plot(wnd: WndHandle, x: AfArray, y: AfArray, props: CellPtr) -> c_int;
+    fn af_draw_plot3(wnd: WndHandle, P: AfArray, props: CellPtr) -> c_int;
+    fn af_draw_hist(wnd: WndHandle, x: AfArray,
+                    minval: c_double, maxval: c_double, props: CellPtr) -> c_int;
+    fn af_draw_surface(wnd: WndHandle, xvals: AfArray, yvals: AfArray, S: AfArray,
+                       props: CellPtr) -> c_int;
     fn af_grid(wnd: WndHandle, rows: c_int, cols: c_int) -> c_int;
     fn af_show(wnd: WndHandle) -> c_int;
     fn af_is_window_closed(out: *mut c_int, wnd: WndHandle) -> c_int;
     fn af_destroy_window(wnd: WndHandle) -> c_int;
-    fn af_draw_hist(wnd: WndHandle, x: AfArray,
-                    minval: c_double, maxval: c_double, props: CellPtr) -> c_int;
 }
 
 /// Represents a sub-view of Window
@@ -147,6 +151,22 @@ impl Window {
         }
     }
 
+    /// Set window size
+    ///
+    /// # Parameters
+    ///
+    /// - `w` is the target width of window
+    /// - `h` is the target height of window
+    pub fn set_size(&self, w: u32, h: u32) -> Result<(), AfError> {
+        unsafe {
+            let err_val = af_set_size(self.handle as WndHandle, w as c_uint, h as c_uint);
+            match err_val {
+                0 => Ok(()),
+                _ => Err(AfError::from(err_val)),
+            }
+        }
+    }
+
     /// Set color map to be used for rendering image, it can take one of the values of enum
     /// [ColorMap](./enum.ColorMap.html)
     pub fn set_colormap(&mut self, cmap: ColorMap) {
@@ -228,7 +248,24 @@ impl Window {
                                        cprops as *const Cell as CellPtr);
             match err_val {
                 0 => (),
-                _ => panic!("Rendering the image failed: {}", err_val),
+                _ => panic!("Rendering 2d line plot failed: {}", err_val),
+            }
+        }
+    }
+
+    /// Render give Arrays of points as a 3d line plot
+    pub fn draw_plot3(&self, points: &Array, title: Option<String>) {
+        let tstr = match title {
+            Some(s) => s,
+            None => format!("Cell({},{}))", self.col, self.row)
+        };
+        let cprops = &Cell {row: self.row, col: self.col, title: tstr.clone(), cmap: self.cmap};
+        unsafe {
+            let err_val = af_draw_plot3(self.handle as WndHandle, points.get() as AfArray,
+                                        cprops as *const Cell as CellPtr);
+            match err_val {
+                0 => (),
+                _ => panic!("Rendering 3d line plot failed: {}", err_val),
             }
         }
     }
@@ -246,7 +283,27 @@ impl Window {
                                        cprops as *const Cell as CellPtr);
             match err_val {
                 0 => (),
-                _ => panic!("Rendering the image failed: {}", err_val),
+                _ => panic!("Rendering histogram failed: {}", err_val),
+            }
+        }
+    }
+
+    /// Render give Arrays as 3d surface
+    pub fn draw_surface(&self, xvals: &Array, yvals: &Array, zvals: &Array, title: Option<String>) {
+        let tstr = match title {
+            Some(s) => s,
+            None => format!("Cell({},{}))", self.col, self.row)
+        };
+        let cprops = &Cell {row: self.row, col: self.col, title: tstr.clone(), cmap: self.cmap};
+        unsafe {
+            let err_val = af_draw_surface(self.handle as WndHandle,
+                                          xvals.get() as AfArray,
+                                          yvals.get() as AfArray,
+                                          zvals.get() as AfArray,
+                                          cprops as *const Cell as CellPtr);
+            match err_val {
+                0 => (),
+                _ => panic!("Rendering surface failed: {}", err_val),
             }
         }
     }