def templateMatchingDemo(console):
root_path = os.path.dirname(os.path.abspath(__file__))
file_path = root_path
if console:
file_path += "/../../assets/examples/images/square.png"
else:
file_path += "/../../assets/examples/images/man.jpg"
img_color = af.load_image(file_path, True)
# Convert the image from RGB to gray-scale
img = af.color_space(img_color, af.CSPACE.GRAY, af.CSPACE.RGB)
iDims = img.dims()
print("Input image dimensions: ", iDims)
# Extract a patch from the input image
patch_size = 100
tmp_img = img[100:100 + patch_size, 100:100 + patch_size]
result = af.match_template(img, tmp_img) # Default disparity metric is
# Sum of Absolute differences (SAD)
# Currently supported metrics are
# AF_SAD, AF_ZSAD, AF_LSAD, AF_SSD,
# AF_ZSSD, AF_LSSD
disp_img = img / 255.0
disp_tmp = tmp_img / 255.0
disp_res = normalize(result)
minval, minloc = af.imin(disp_res)
print("Location(linear index) of minimum disparity value = {}".format(
minloc))
if not console:
marked_res = af.tile(disp_img, 1, 1, 3)
marked_res = draw_rectangle(marked_res, minloc%iDims[0], minloc/iDims[0],\
patch_size, patch_size)
print(
"Note: Based on the disparity metric option provided to matchTemplate function"
)
print(
"either minimum or maximum disparity location is the starting corner"
)
print(
"of our best matching patch to template image in the search image")
wnd = af.Window(512, 512, "Template Matching Demo")
while not wnd.close():
wnd.set_colormap(af.COLORMAP.DEFAULT)
wnd.grid(2, 2)
wnd[0, 0].image(disp_img, "Search Image")
wnd[0, 1].image(disp_tmp, "Template Patch")
wnd[1, 0].image(marked_res, "Best Match")
wnd.set_colormap(af.COLORMAP.HEAT)
wnd[1, 1].image(disp_res, "Disparity Values")
wnd.show()
def susan_demo(console):
root_path = os.path.dirname(os.path.abspath(__file__))
file_path = root_path
if console:
file_path += "/../../assets/examples/images/square.png"
else:
file_path += "/../../assets/examples/images/man.jpg"
img_color = af.load_image(file_path, True)
img = af.color_space(img_color, af.CSPACE.GRAY, af.CSPACE.RGB)
img_color /= 255.0
features = af.susan(img)
xs = features.get_xpos().to_list()
ys = features.get_ypos().to_list()
draw_len = 3
num_features = features.num_features().value
for f in range(num_features):
print(f)
x = xs[f]
y = ys[f]
# TODO fix coord order to x,y after upstream fix
img_color = draw_corners(img_color, y, x, draw_len)
print("Features found: {}".format(num_features))
if not console:
# Previews color image with green crosshairs
wnd = af.Window(512, 512, "SUSAN Feature Detector")
while not wnd.close():
wnd.image(img_color)
else:
print(xs)
print(ys)
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af
import sys
import os
if __name__ == "__main__":
if (len(sys.argv) == 1):
raise RuntimeError("Expected to the image as the first argument")
if not os.path.isfile(sys.argv[1]):
raise RuntimeError("File %s not found" % sys.argv[1])
if (len(sys.argv) > 2):
af.set_device(int(sys.argv[2]))
af.info()
hist_win = af.Window(512, 512, "3D Plot example using ArrayFire")
img_win = af.Window(480, 640, "Input Image")
img = (af.load_image(sys.argv[1])).(af.Dtype.u8)
hist = af.histogram(img, 256, 0, 255)
while (not hist_win.close()) and (not img_win.close()):
hist_win.hist(hist, 0, 255)
img_win.image(img)
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, 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
af.info()
POINTS = 30
N = 2 * POINTS
x = (af.iota(d0=N, d1=1, tile_dims=(1, N)) - POINTS) / POINTS
y = (af.iota(d0=1, d1=N, tile_dims=(N, 1)) - POINTS) / POINTS
win = af.Window(800, 800, "3D Surface example using ArrayFire")
t = 0
while not win.close():
t = t + 0.07
z = 10 * x * -af.abs(y) * af.cos(x * x * (y + t)) + af.sin(y *
(x + t)) - 1.5
win.surface(x, y, z)
# Copyright (c) 2015, 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
af.info()
ITERATIONS = 200
POINTS = int(10.0 * ITERATIONS)
Z = 1 + af.range(POINTS) / ITERATIONS
win = af.Window(800, 800, "3D Plot example using ArrayFire")
t = 0.1
while not win.close():
X = af.cos(Z * t + t) / Z
Y = af.sin(Z * t + t) / Z
X = af.maxof(af.minof(X, 1), -1)
Y = af.maxof(af.minof(Y, 1), -1)
Pts = af.join(1, X, Y, Z)
win.plot3(Pts)
t = t + 0.01
# 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
import math
POINTS = 10000
PRECISION = 1.0 / float(POINTS)
val = -math.pi
X = math.pi * (2 * (af.range(POINTS) / POINTS) - 1)
win = af.Window(512, 512, "2D Plot example using ArrayFire")
sign = 1.0
while not win.close():
Y = af.sin(X)
win.plot(X, Y)
X += PRECISION * sign
val += PRECISION * sign
if (val > math.pi):
sign = -1.0
elif (val < -math.pi):
sign = 1.0
def harris_demo(console):
root_path = os.path.dirname(os.path.abspath(__file__))
file_path = root_path
if console:
file_path += "/../../assets/examples/images/square.png"
else:
file_path += "/../../assets/examples/images/man.jpg"
img_color = af.load_image(file_path, True)
img = af.color_space(img_color, af.CSPACE.GRAY, af.CSPACE.RGB)
img_color /= 255.0
ix, iy = af.gradient(img)
ixx = ix * ix
ixy = ix * iy
iyy = iy * iy
# Compute a Gaussian kernel with standard deviation of 1.0 and length of 5 pixels
# These values can be changed to use a smaller or larger window
gauss_filt = af.gaussian_kernel(5, 5, 1.0, 1.0)
# Filter second order derivatives
ixx = af.convolve(ixx, gauss_filt)
ixy = af.convolve(ixy, gauss_filt)
iyy = af.convolve(iyy, gauss_filt)
# Calculate trace
itr = ixx + iyy
# Calculate determinant
idet = ixx * iyy - ixy * ixy
# Calculate Harris response
response = idet - 0.04 * (itr * itr)
# Get maximum response for each 3x3 neighborhood
mask = af.constant(1, 3, 3)
max_resp = af.dilate(response, mask)
# Discard responses that are not greater than threshold
corners = response > 1e5
corners = corners * response
# Discard responses that are not equal to maximum neighborhood response,
# scale them to original value
corners = (corners == max_resp) * corners
# Copy device array to python list on host
corners_list = corners.to_list()
draw_len = 3
good_corners = 0
for x in range(img_color.dims()[1]):
for y in range(img_color.dims()[0]):
if corners_list[x][y] > 1e5:
img_color = draw_corners(img_color, x, y, draw_len)
good_corners += 1
print("Corners found: {}".format(good_corners))
if not console:
# Previews color image with green crosshairs
wnd = af.Window(512, 512, "Harris Feature Detector")
while not wnd.close():
wnd.image(img_color)
else:
idx = af.where(corners)
corners_x = idx / float(corners.dims()[0])
corners_y = idx % float(corners.dims()[0])
print(corners_x)
print(corners_y)
h_kernel = array.array('f', (1, 1, 1, 1, 0, 1, 1, 1, 1))
reset = 500
game_w = 128
game_h = 128
fps = 30
print("Example demonstrating conway's game of life using arrayfire")
print("The conway_pretty example visualizes all the states in Conway")
print("Red : Cells that have died due to under population" )
print("Yellow: Cells that continue to live from previous state" )
print("Green : Cells that are new as a result of reproduction" )
print("Blue : Cells that have died due to over population" )
print("This examples is throttled to 30 FPS so as to be a better visualization")
simple_win = af.Window(512, 512, "Conway's Game of Life - Current State")
pretty_win = af.Window(512, 512, "Conway's Game of Life - Current State with visualization")
simple_win.set_pos(25, 15)
pretty_win.set_pos(600, 25)
frame_count = 0
# Copy kernel that specifies neighborhood conditions
kernel = af.Array(h_kernel, dims=(3,3))
# Generate the initial state with 0s and 1s
state = (af.randu(game_h, game_w) > 0.4).as_type(af.Dtype.f32)
# tile 3 times to display color
display = af.tile(state, 1, 1, 3, 1)
def normalize(a):
mx = af.max(a)
mn = af.min(a)
return (a - mn) / (mx - mn)
if __name__ == "__main__":
if (len(sys.argv) > 1):
af.set_device(int(sys.argv[1]))
af.info()
print("ArrayFire Fractal Demo\n")
win = af.Window(width, height, "Fractal Demo")
win.set_colormap(af.COLORMAP.SPECTRUM)
center = (-0.75, 0.1)
for i in range(10, 400):
zoom = i * i
if not (i % 10):
print("Iteration: %d zoom: %d" % (i, zoom))
c = complex_grid(width, height, zoom, center)
it = sqrt(2 * sqrt(abs(1 - sqrt(5 * zoom)))) * 100
if (win.close()): break
mag = mandelbrot(c, int(it), 1000)
