image.h (2014-04-30 15:38:09 -0400, (build fd32605))

Go to the documentation of this file.

//-----------------------------------------------------------------------//
//   Copyright (c) AccelerEyes LLC. All rights reserved.                 //
//   See http://www.accelereyes.com/eula for details.                    //
//   This software is distributed WITHOUT ANY WARRANTY; without even     //
//   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
//   PURPOSE.  See the above copyright notices for more information.     //
//-----------------------------------------------------------------------//

#pragma once

#include "defines.h"
#include <string>

    typedef enum {
        af_rgb = 0, 
        af_hsv,     
        af_gray,    
        af_ycrcb    
    } af_cspace_t;

namespace af {

    class array;
    AFAPI array gaussiankernel(int rows, int cols, double sigma_r = 0, double sigma_c = 0);

    AFAPI array filter(const array& image, const array& kernel);

    AFAPI array medfilt(const array& image, const unsigned height=3, const unsigned width=3);

    AFAPI array minfilt(const array& image, const unsigned height=3, const unsigned width=3);

    AFAPI array maxfilt(const array& image, const unsigned height=3, const unsigned width=3);

    AFAPI array erode(const array& image, const array& mask);

    AFAPI array dilate(const array& image, const array& mask);

    AFAPI array resize(const float scale, const array& image, const char method='L');

    AFAPI array resize(const float scale_x,
                       const float scale_y,
                       const array& image,
                       const char method='L');

    AFAPI array resize(const unsigned height,
                       const unsigned width,
                       const array& image,
                       const char method='L');

    AFAPI array transform(const array& image, const array& transform,
                          const unsigned oh=0, const unsigned ow=0, const bool inverse = true);
    AFAPI array rotate(const array& image, const float theta = 0,
                       const bool iscrop = true, const bool recenter = true);
    AFAPI array translate(const array& image, const float trans_x, const float trans_y,
                          const unsigned oh=0, const unsigned ow=0);
    AFAPI array scale(const array& image, const float scale_x, const float scale_y,
                      const unsigned oh=0, const unsigned ow=0);
    AFAPI array skew(const array& image, const float skew_x, const float skew_y,
                     const unsigned oh=0, const unsigned ow=0, const bool inverse = false);
    AFAPI array transform_coord(const array& vertices, const array& transform);
    AFAPI array rotate_coord(const array& vertices, const unsigned axis, const float theta);
    AFAPI array bilateral(const array& image, const float space, const float color);

    AFAPI array meanshift(const array& image, const float space, const float color, const int iter=5);

    AFAPI array colorspace(const array& image, const af_cspace_t to, const af_cspace_t from);

    AFAPI array histogram(const array& data, unsigned nbins);

    AFAPI array histogram(const array& data, unsigned nbins, float min, float max);

    AFAPI array histequal(const array& data, const array& histogram);

    AFAPI array regions(const array& image, const unsigned connectivity=8);

    AFAPI array areas(const array& regions);

    AFAPI array centroids(const array& regions);

    AFAPI array loadimage(const char* filename, bool iscolor = false);

    AFAPI void saveimage(const char* filename, const af::array& img);

} // namespace af






#ifdef __cplusplus
extern "C" {
#endif

    AFAPI afError af_rotate_S(float* d_out,
                              unsigned xo, unsigned yo,
                              const float* d_in,
                              unsigned xi, unsigned yi,
                              float theta, unsigned batch);
    AFAPI afError af_resize_S(const unsigned mO, const unsigned nO,
                              float* d_out,
                              const unsigned mI, const unsigned nI,
                              const float* d_in,
                              const unsigned channels, const int type=1);
    AFAPI afError af_resize_D(const unsigned mO, const unsigned nO,
                              double* d_out,
                              const unsigned mI, const unsigned nI,
                              const double* d_in,
                              const unsigned channels, const int type=1);

    AFAPI afError af_erode_B(bool *d_out,
                             unsigned in_ndims,    const unsigned *in_dims,    const bool *d_in,
                             unsigned nhood_ndims, const unsigned *nhood_dims, const bool *h_nhood,
                             unsigned batch);

    AFAPI afError af_erode_S(float *d_out,
                             unsigned in_ndims,    const unsigned *in_dims,    const float *d_in,
                             unsigned nhood_ndims, const unsigned *nhood_dims, const float *h_nhood,
                             unsigned batch);


    AFAPI afError af_erode_D(double *d_out,
                             unsigned in_ndims,    const unsigned *in_dims,    const double *d_in,
                             unsigned nhood_ndims, const unsigned *nhood_dims, const double *h_nhood,
                             unsigned batch);

    AFAPI afError af_dilate_B(bool *d_out,
                              unsigned in_ndims,    const unsigned *in_dims,    const bool *d_in,
                              unsigned nhood_ndims, const unsigned *nhood_dims, const bool *d_nhood,
                              unsigned batch);

    AFAPI afError af_dilate_S(float *d_out,
                              unsigned in_ndims,    const unsigned *in_dims,    const float *d_in,
                              unsigned nhood_ndims, const unsigned *nhood_dims, const float *d_nhood,
                              unsigned batch);

    AFAPI afError af_dilate_D(double *d_out,
                              unsigned in_ndims,    const unsigned *in_dims,    const double *d_in,
                              unsigned nhood_ndims, const unsigned *nhood_dims, const double *d_nhood,
                              unsigned batch);
    //Single Precision, Affine Coordinate Transform
    AFAPI  afError af_transform_coord_S(float* d_dst,
                                        const float* d_src, const unsigned* dims,
                                        const float* d_tf,  const unsigned* hdims,
                                        unsigned batch);

    //Double Precision, Affine Coordinate Transform
    AFAPI  afError af_transform_coord_D(double* d_dst,
                                        const double* d_src, const unsigned* dims,
                                        const double* d_tf,  const unsigned* hdims,
                                        unsigned batch);
    AFAPI afError af_transform_S(float* d_out,
                                 const float* d_in, const unsigned* idims,
                                 const float* d_tf, const unsigned* odims,
                                 unsigned nimages, unsigned ntranforms,
                                 const bool inverse);

    AFAPI afError af_transform_D(double* d_out,
                                 const double* d_in, const unsigned* idims,
                                 const float*  d_tf, const unsigned* odims,
                                 unsigned nimages, unsigned ntranforms,
                                 const bool inverse);

    AFAPI afError af_transform_I(int* d_out,
                                 const int*   d_in, const unsigned* idims,
                                 const float* d_tf, const unsigned* odims,
                                 unsigned nimages, unsigned ntranforms,
                                 const bool inverse);

    AFAPI afError af_transform_U(unsigned* d_out,
                                 const unsigned* d_in, const unsigned* idims,
                                 const float*    d_tf, const unsigned* odims,
                                 unsigned nimages, unsigned ntranforms,
                                 const bool inverse);

    AFAPI afError af_transform_B(bool* d_out,
                                 const bool*  d_in, const unsigned* idims,
                                 const float* d_tf, const unsigned* odims,
                                 unsigned nimages, unsigned ntranforms,
                                 const bool inverse);
    AFAPI afError af_bilateral_S(float* d_out,
                                 const float* d_in,
                                 unsigned mI, unsigned nI,
                                 const float space,
                                 const float color,
                                 int channels);
    AFAPI afError af_meanshift_S(float* d_out,
                                 const float* d_in,
                                 unsigned mI, unsigned nI,
                                 const float space,
                                 const float color,
                                 const int iter,
                                 int channels);
    AFAPI afError af_histogram_S(float* d_hist,
                                 unsigned length, const float* d_data,
                                 unsigned nbins , const float* h_bins,
                                 unsigned nsets, unsigned ngfor);

    AFAPI afError af_histminmax_S(float* d_hist,
                                  unsigned len, const float* d_data,
                                  unsigned bins, const float* h_data,
                                  unsigned nsets, unsigned ngfor,
                                  float min, float max);
    AFAPI afError af_histequalize_S(float* d_out,
                                    unsigned length, const float* d_data,
                                    unsigned nbins , const float* d_bins);
    AFAPI afError af_regions_B(float *d_out,
                               const unsigned nx,
                               const unsigned ny,
                               const bool *d_in,
                               unsigned conn);
    AFAPI afError af_medfilt_B(char* d_out,
                               unsigned m, unsigned n, const char* d_in,
                               const unsigned* h_W);
    AFAPI afError af_medfilt_c(unsigned char* d_out,
                               unsigned m, unsigned n, const unsigned char* d_in,
                               const unsigned* h_W);
    AFAPI afError af_medfilt_I(int* d_out,
                               unsigned m, unsigned n, const int* d_in,
                               const unsigned* h_W);
    AFAPI afError af_medfilt_U(unsigned* d_out,
                               unsigned m, unsigned n, const unsigned* d_in,
                               const unsigned* h_W);
    AFAPI afError af_medfilt_S(float* d_out,
                               unsigned m, unsigned n, const float* d_in,
                               const unsigned* h_W);
    AFAPI afError af_medfilt_D(double* d_out,
                               unsigned m, unsigned n, const double* d_in,
                               const unsigned* h_W);
#ifdef __cplusplus
}
#endif