[python-arrayfire] 30/250: FEAT/TEST: Porting all functions from image.h
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Mon Mar 28 22:59:27 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch debian/master
in repository python-arrayfire.
commit 35ff853fc6f7525e68a8c5b51f9082a1cbab072f
Author: Pavan Yalamanchili <pavan at arrayfire.com>
Date: Wed Jul 15 17:03:19 2015 -0400
FEAT/TEST: Porting all functions from image.h
---
arrayfire/__init__.py | 1 +
arrayfire/image.py | 218 ++++++++++++++++++++++++++++++++++++++++++++++++++
tests/simple_image.py | 60 ++++++++++++++
3 files changed, 279 insertions(+)
diff --git a/arrayfire/__init__.py b/arrayfire/__init__.py
index 0df736e..2051544 100644
--- a/arrayfire/__init__.py
+++ b/arrayfire/__init__.py
@@ -17,3 +17,4 @@ from .arith import *
from .statistics import *
from .lapack import *
from .signal import *
+from .image import *
diff --git a/arrayfire/image.py b/arrayfire/image.py
new file mode 100644
index 0000000..934d3df
--- /dev/null
+++ b/arrayfire/image.py
@@ -0,0 +1,218 @@
+#######################################################
+# Copyright (c) 2014, 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
+########################################################
+
+from .library import *
+from .array import *
+from .data import constant
+
+def gradient(image):
+ dx = array()
+ dy = array()
+ safe_call(clib.af_gradient(pointer(dx.arr), pointer(dy.arr), image.arr))
+ return dx, dy
+
+def load_image(file_name, is_color=False):
+ assert(isinstance(file_name, str))
+ image = array()
+ safe_call(clib.af_load_image(pointer(image.arr), c_char_p(file_name.encode('ascii')), is_color))
+ return image
+
+def save_image(image, file_name):
+ assert(isinstance(file_name, str))
+ safe_call(clib.af_load_image(c_char_p(file_name.encode('ascii')), image.arr))
+ return image
+
+def resize(image, scale=None, odim0=None, odim1=None, method=AF_INTERP_NEAREST):
+
+ if (scale is None):
+ assert(odim0 is not None)
+ assert(odim1 is not None)
+ else:
+ idims = image.dims()
+ odim0 = int(scale * idims[0])
+ odim1 = int(scale * idims[1])
+
+ output = array()
+ safe_call(clib.af_resize(pointer(output.arr),\
+ image.arr, c_longlong(odim0), c_longlong(odim1), method))
+
+ return output
+
+def transform(image, transform, odim0 = 0, odim1 = 0, method=AF_INTERP_NEAREST, is_inverse=True):
+ output = array()
+ safe_call(clib.af_transform(pointer(output.arr),\
+ image.arr, transform.arr,\
+ c_longlong(odim0), c_longlong(odim1), method, is_inverse))
+ return output
+
+def rotate(image, theta, is_crop = True, method = AF_INTERP_NEAREST):
+ output = array()
+ safe_call(clib.af_rotate(pointer(output.arr), image.arr, c_double(theta), is_crop, method))
+ return output
+
+def translate(image, trans0, trans1, odim0 = 0, odim1 = 0, method = AF_INTERP_NEAREST):
+ output = array()
+ safe_call(clib.af_translate(pointer(output.arr), \
+ image.arr, trans0, trans1, c_longlong(odim0), c_longlong(odim1), method))
+ return output
+
+def scale(image, scale0, scale1, odim0 = 0, odim1 = 0, method = AF_INTERP_NEAREST):
+ output = array()
+ safe_call(clib.af_scale(pointer(output.arr),\
+ image.arr, c_double(scale0), c_double(scale1),\
+ c_longlong(odim0), c_longlong(odim1), method))
+ return output
+
+def skew(image, skew0, skew1, odim0 = 0, odim1 = 0, method = AF_INTERP_NEAREST, is_inverse=True):
+ output = array()
+ safe_call(clib.af_skew(pointer(output.arr),\
+ image.arr, c_double(skew0), c_double(skew1), \
+ c_longlong(odim0), c_longlong(odim1), method, is_inverse))
+
+ return output
+
+def histogram(image, nbins, min_val = None, max_val = None):
+ from .algorithm import min as af_min
+ from .algorithm import max as af_max
+
+ if min_val is None:
+ min_val = af_min(image)
+
+ if max_val is None:
+ max_val = af_max(image)
+
+ output = array()
+ safe_call(clib.af_histogram(pointer(output.arr),\
+ image.arr, c_uint(nbins), c_double(min_val), c_double(max_val)))
+ return output
+
+def hist_equal(image, hist):
+ output = array()
+ safe_call(clib.af_hist_equal(pointer(output.arr), image.arr, hist.arr))
+ return output
+
+def dilate(image, mask = None):
+
+ if mask is None:
+ mask = constant(1, 3, 3, dtype=f32)
+
+ output = array()
+ safe_call(clib.af_dilate(pointer(output.arr), image.arr, mask.arr))
+
+ return output
+
+def dilate3(image, mask = None):
+
+ if mask is None:
+ mask = constant(1, 3, 3, 3, dtype=f32)
+
+ output = array()
+ safe_call(clib.af_dilate3(pointer(output.arr), image.arr, mask.arr))
+
+ return output
+
+def erode(image, mask = None):
+
+ if mask is None:
+ mask = constant(1, 3, 3, dtype=f32)
+
+ output = array()
+ safe_call(clib.af_erode(pointer(output.arr), image.arr, mask.arr))
+
+ return output
+
+def erode3(image, mask = None):
+
+ if mask is None:
+ mask = constant(1, 3, 3, 3, dtype=f32)
+
+ output = array()
+ safe_call(clib.af_erode3(pointer(output.arr), image.arr, mask.arr))
+
+ return output
+
+def bilateral(image, s_sigma, c_sigma, is_color = False):
+ output = array()
+ safe_call(clib.af_bilateral(pointer(output.arr),\
+ image.arr, c_double(s_sigma), c_double(c_sigma), is_color))
+ return output
+
+def mean_shift(image, s_sigma, c_sigma, n_iter, is_color = False):
+ output = array()
+ safe_call(clib.af_mean_shift(pointer(output.arr),\
+ image.arr, c_double(s_sigma), c_double(c_sigma),\
+ c_uint(n_iter), is_color))
+ return output
+
+def medfilt(image, w_len = 3, w_wid = 3, edge_pad = AF_PAD_ZERO):
+ output = array()
+ safe_call(clib.af_medfilt(pointer(output.arr), \
+ image.arr, c_longlong(w_len), c_longlong(w_wid), edge_pad))
+ return output
+
+def minfilt(image, w_len = 3, w_wid = 3, edge_pad = AF_PAD_ZERO):
+ output = array()
+ safe_call(clib.af_minfilt(pointer(output.arr), \
+ image.arr, c_longlong(w_len), c_longlong(w_wid), edge_pad))
+ return output
+
+def maxfilt(image, w_len = 3, w_wid = 3, edge_pad = AF_PAD_ZERO):
+ output = array()
+ safe_call(clib.af_maxfilt(pointer(output.arr), \
+ image.arr, c_longlong(w_len), c_longlong(w_wid), edge_pad))
+ return output
+
+def regions(image, connectivity = AF_CONNECTIVITY_4, out_type = f32):
+ output = array()
+ safe_call(clib.af_regions(pointer(output.arr), image.arr, connectivity, out_type))
+ return output
+
+def sobel_derivatives(image, w_len=3):
+ dx = array()
+ dy = array()
+ safe_call(clib.af_sobel_operator(pointer(dx.arr), pointer(dy.arr),\
+ image.arr, c_uint(w_len)))
+ return dx,dy
+
+def sobel_filter(image, w_len = 3, is_fast = False):
+ from .arith import abs as af_abs
+ from .arith import hypot as af_hypot
+
+ dx,dy = sobel_derivatives(image, w_len)
+ if (is_fast):
+ return af_abs(dx) + af_abs(dy)
+ else:
+ return af_hypot(dx, dy)
+
+def rgb2gray(image, r_factor = 0.2126, g_factor = 0.7152, b_factor = 0.0722):
+ output=array()
+ safe_call(clib.af_rgb2gray(pointer(output.arr), \
+ image.arr, c_float(r_factor), c_float(g_factor), c_float(b_factor)))
+ return output
+
+def gray2rgb(image, r_factor = 1.0, g_factor = 1.0, b_factor = 1.0):
+ output=array()
+ safe_call(clib.af_gray2rgb(pointer(output.arr), \
+ image.arr, c_float(r_factor), c_float(g_factor), c_float(b_factor)))
+ return output
+
+def hsv2rgb(image):
+ output = array()
+ safe_call(clib.af_hsv2rgb(pointer(output.arr), image.arr))
+ return output
+
+def rgb2hsv(image):
+ output = array()
+ safe_call(clib.af_rgb2hsv(pointer(output.arr), image.arr))
+ return output
+
+def color_space(image, to_type, from_type):
+ output = array()
+ safe_call(clib.af_color_space(pointer(output.arr), image.arr, to_type, from_type))
+ return output
diff --git a/tests/simple_image.py b/tests/simple_image.py
new file mode 100755
index 0000000..3b436d4
--- /dev/null
+++ b/tests/simple_image.py
@@ -0,0 +1,60 @@
+#!/usr/bin/python
+#######################################################
+# Copyright (c) 2014, 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
+########################################################
+
+import arrayfire as af
+
+a = 10 * af.randu(6, 6)
+a3 = 10 * af.randu(5,5,3)
+
+dx,dy = af.gradient(a)
+af.print_array(dx)
+af.print_array(dy)
+
+af.print_array(af.resize(a, scale=0.5))
+af.print_array(af.resize(a, odim0=8, odim1=8))
+
+t = af.randu(3,2)
+af.print_array(af.transform(a, t))
+af.print_array(af.rotate(a, 3.14))
+af.print_array(af.translate(a, 1, 1))
+af.print_array(af.scale(a, 1.2, 1.2, 7, 7))
+af.print_array(af.skew(a, 0.02, 0.02))
+h = af.histogram(a, 3)
+af.print_array(h)
+af.print_array(af.hist_equal(a, h))
+
+af.print_array(af.dilate(a))
+af.print_array(af.erode(a))
+
+af.print_array(af.dilate3(a3))
+af.print_array(af.erode3(a3))
+
+af.print_array(af.bilateral(a, 1, 2))
+af.print_array(af.mean_shift(a, 1, 2, 3))
+
+af.print_array(af.medfilt(a))
+af.print_array(af.minfilt(a))
+af.print_array(af.maxfilt(a))
+
+af.print_array(af.regions(af.round(a) > 3))
+
+dx,dy = af.sobel_derivatives(a)
+af.print_array(dx)
+af.print_array(dy)
+af.print_array(af.sobel_filter(a))
+
+ac = af.gray2rgb(a)
+af.print_array(ac)
+af.print_array(af.rgb2gray(ac))
+ah = af.rgb2hsv(ac)
+af.print_array(ah)
+af.print_array(af.hsv2rgb(ah))
+
+af.print_array(af.color_space(a, af.AF_RGB, af.AF_GRAY))
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/python-arrayfire.git
More information about the debian-science-commits
mailing list