/*******************************************************

* Copyright (c) 2018, ArrayFire

* All rights reserved.

*

* This file is distributed under 3-clause BSD license.

* The complete license agreement can be obtained at:

* http://arrayfire.com/licenses/BSD-3-Clause

********************************************************/

#include <af/array.h>

#include <af/defines.h>

#include <af/image.h>

#include "symbol_manager.hpp"

af_err af_gradient(af_array *dx, af_array *dy, const af_array in) {

CHECK_ARRAYS(in);

CALL(af_gradient, dx, dy, in);

}

af_err af_load_image(af_array *out, const char *filename, const bool isColor) {

CALL(af_load_image, out, filename, isColor);

}

af_err af_save_image(const char *filename, const af_array in) {

CHECK_ARRAYS(in);

CALL(af_save_image, filename, in);

}

af_err af_load_image_memory(af_array *out, const void *ptr) {

CALL(af_load_image_memory, out, ptr);

}

af_err af_save_image_memory(void **ptr, const af_array in,

const af_image_format format) {

CHECK_ARRAYS(in);

CALL(af_save_image_memory, ptr, in, format);

}

af_err af_delete_image_memory(void *ptr) { CALL(af_delete_image_memory, ptr); }

af_err af_load_image_native(af_array *out, const char *filename) {

CALL(af_load_image_native, out, filename);

}

af_err af_save_image_native(const char *filename, const af_array in) {

CHECK_ARRAYS(in);

CALL(af_save_image_native, filename, in);

}

af_err af_is_image_io_available(bool *out) {

CALL(af_is_image_io_available, out);

}

af_err af_resize(af_array *out, const af_array in, const dim_t odim0,

const dim_t odim1, const af_interp_type method) {

CHECK_ARRAYS(in);

CALL(af_resize, out, in, odim0, odim1, method);

}

af_err af_transform(af_array *out, const af_array in, const af_array transform,

const dim_t odim0, const dim_t odim1,

const af_interp_type method, const bool inverse) {

CHECK_ARRAYS(in, transform);

CALL(af_transform, out, in, transform, odim0, odim1, method, inverse);

}

af_err af_transform_v2(af_array *out, const af_array in,

const af_array transform, const dim_t odim0,

const dim_t odim1, const af_interp_type method,

const bool inverse) {

CHECK_ARRAYS(out, in, transform);

CALL(af_transform_v2, out, in, transform, odim0, odim1, method, inverse);

}

af_err af_transform_coordinates(af_array *out, const af_array tf,

const float d0, const float d1) {

CHECK_ARRAYS(tf);

CALL(af_transform_coordinates, out, tf, d0, d1);

}

af_err af_rotate(af_array *out, const af_array in, const float theta,

const bool crop, const af_interp_type method) {

CHECK_ARRAYS(in);

CALL(af_rotate, out, in, theta, crop, method);

}

af_err af_translate(af_array *out, const af_array in, const float trans0,

const float trans1, const dim_t odim0, const dim_t odim1,

const af_interp_type method) {

CHECK_ARRAYS(in);

CALL(af_translate, out, in, trans0, trans1, odim0, odim1, method);

}

af_err af_scale(af_array *out, const af_array in, const float scale0,

const float scale1, const dim_t odim0, const dim_t odim1,

const af_interp_type method) {

CHECK_ARRAYS(in);

CALL(af_scale, out, in, scale0, scale1, odim0, odim1, method);

}

af_err af_skew(af_array *out, const af_array in, const float skew0,

const float skew1, const dim_t odim0, const dim_t odim1,

const af_interp_type method, const bool inverse) {

CHECK_ARRAYS(in);

CALL(af_skew, out, in, skew0, skew1, odim0, odim1, method, inverse);

}

af_err af_histogram(af_array *out, const af_array in, const unsigned nbins,

const double minval, const double maxval) {

CHECK_ARRAYS(in);

CALL(af_histogram, out, in, nbins, minval, maxval);

}

af_err af_dilate(af_array *out, const af_array in, const af_array mask) {

CHECK_ARRAYS(in, mask);

CALL(af_dilate, out, in, mask);

}

af_err af_dilate3(af_array *out, const af_array in, const af_array mask) {

CHECK_ARRAYS(in, mask);

CALL(af_dilate3, out, in, mask);

}

af_err af_erode(af_array *out, const af_array in, const af_array mask) {

CHECK_ARRAYS(in, mask);

CALL(af_erode, out, in, mask);

}

af_err af_erode3(af_array *out, const af_array in, const af_array mask) {

CHECK_ARRAYS(in, mask);

CALL(af_erode3, out, in, mask);

}

af_err af_bilateral(af_array *out, const af_array in, const float spatial_sigma,

const float chromatic_sigma, const bool isColor) {

CHECK_ARRAYS(in);

CALL(af_bilateral, out, in, spatial_sigma, chromatic_sigma, isColor);

}

af_err af_mean_shift(af_array *out, const af_array in,

const float spatial_sigma, const float chromatic_sigma,

const unsigned iter, const bool is_color) {

CHECK_ARRAYS(in);

CALL(af_mean_shift, out, in, spatial_sigma, chromatic_sigma, iter,

is_color);

}

af_err af_minfilt(af_array *out, const af_array in, const dim_t wind_length,

const dim_t wind_width, const af_border_type edge_pad) {

CHECK_ARRAYS(in);

CALL(af_minfilt, out, in, wind_length, wind_width, edge_pad);

}

af_err af_maxfilt(af_array *out, const af_array in, const dim_t wind_length,

const dim_t wind_width, const af_border_type edge_pad) {

CHECK_ARRAYS(in);

CALL(af_maxfilt, out, in, wind_length, wind_width, edge_pad);

}

af_err af_regions(af_array *out, const af_array in,

const af_connectivity connectivity, const af_dtype ty) {

CHECK_ARRAYS(in);

CALL(af_regions, out, in, connectivity, ty);

}

af_err af_sobel_operator(af_array *dx, af_array *dy, const af_array img,

const unsigned ker_size) {

CHECK_ARRAYS(img);

CALL(af_sobel_operator, dx, dy, img, ker_size);

}

af_err af_rgb2gray(af_array *out, const af_array in, const float rPercent,

const float gPercent, const float bPercent) {

CHECK_ARRAYS(in);

CALL(af_rgb2gray, out, in, rPercent, gPercent, bPercent);

}

af_err af_gray2rgb(af_array *out, const af_array in, const float rFactor,

const float gFactor, const float bFactor) {

CHECK_ARRAYS(in);

CALL(af_gray2rgb, out, in, rFactor, gFactor, bFactor);

}

af_err af_hist_equal(af_array *out, const af_array in, const af_array hist) {

CHECK_ARRAYS(in, hist);

CALL(af_hist_equal, out, in, hist);

}

af_err af_gaussian_kernel(af_array *out, const int rows, const int cols,

const double sigma_r, const double sigma_c) {

CALL(af_gaussian_kernel, out, rows, cols, sigma_r, sigma_c);

}

af_err af_hsv2rgb(af_array *out, const af_array in) {

CHECK_ARRAYS(in);

CALL(af_hsv2rgb, out, in);

}

af_err af_rgb2hsv(af_array *out, const af_array in) {

CHECK_ARRAYS(in);

CALL(af_rgb2hsv, out, in);

}

af_err af_color_space(af_array *out, const af_array image, const af_cspace_t to,

const af_cspace_t from) {

CHECK_ARRAYS(image);

CALL(af_color_space, out, image, to, from);

}

af_err af_unwrap(af_array *out, const af_array in, const dim_t wx,

const dim_t wy, const dim_t sx, const dim_t sy, const dim_t px,

const dim_t py, const bool is_column) {

CHECK_ARRAYS(in);

CALL(af_unwrap, out, in, wx, wy, sx, sy, px, py, is_column);

}

af_err af_wrap(af_array *out, const af_array in, const dim_t ox, const dim_t oy,

const dim_t wx, const dim_t wy, const dim_t sx, const dim_t sy,

const dim_t px, const dim_t py, const bool is_column) {

CHECK_ARRAYS(in);

CALL(af_wrap, out, in, ox, oy, wx, wy, sx, sy, px, py, is_column);

}

af_err af_wrap_v2(af_array *out, const af_array in, const dim_t ox,

const dim_t oy, const dim_t wx, const dim_t wy,

const dim_t sx, const dim_t sy, const dim_t px,

const dim_t py, const bool is_column) {

CHECK_ARRAYS(out, in);

CALL(af_wrap_v2, out, in, ox, oy, wx, wy, sx, sy, px, py, is_column);

}

af_err af_sat(af_array *out, const af_array in) {

CHECK_ARRAYS(in);

CALL(af_sat, out, in);

}

af_err af_ycbcr2rgb(af_array *out, const af_array in,

const af_ycc_std standard) {

CHECK_ARRAYS(in);

CALL(af_ycbcr2rgb, out, in, standard);

}

af_err af_rgb2ycbcr(af_array *out, const af_array in,

const af_ycc_std standard) {

CHECK_ARRAYS(in);

CALL(af_rgb2ycbcr, out, in, standard);

}

af_err af_canny(af_array *out, const af_array in, const af_canny_threshold ct,

const float t1, const float t2, const unsigned sw,

const bool isf) {

CHECK_ARRAYS(in);

CALL(af_canny, out, in, ct, t1, t2, sw, isf);

}

af_err af_anisotropic_diffusion(af_array *out, const af_array in,

const float dt, const float K,

const unsigned iterations,

const af_flux_function fftype,

const af_diffusion_eq eq) {

CHECK_ARRAYS(in);

CALL(af_anisotropic_diffusion, out, in, dt, K, iterations, fftype, eq);

}

af_err af_iterative_deconv(af_array *out, const af_array in, const af_array ker,

const unsigned iterations, const float relax_factor,

const af_iterative_deconv_algo algo) {

CHECK_ARRAYS(in, ker);

CALL(af_iterative_deconv, out, in, ker, iterations, relax_factor, algo);

}

af_err af_inverse_deconv(af_array *out, const af_array in, const af_array psf,

const float gamma, const af_inverse_deconv_algo algo) {

CHECK_ARRAYS(in, psf);

CALL(af_inverse_deconv, out, in, psf, gamma, algo);

}

af_err af_confidence_cc(af_array *out, const af_array in, const af_array seedx,

const af_array seedy, const unsigned radius,

const unsigned multiplier, const int iter,

const double segmented_value) {

CHECK_ARRAYS(in, seedx, seedy);

CALL(af_confidence_cc, out, in, seedx, seedy, radius, multiplier, iter,

segmented_value);

}