def __init__(self):
QMainWindow.__init__(self, None,
"FFTLab Main Window",
Qt.WType_TopLevel | Qt.WDestructiveClose)
self.file_menu = QPopupMenu(self)
self.file_menu.insertItem('&Quit', self.file_quit, Qt.CTRL + Qt.Key_Q)
self.menuBar().insertItem('&File', self.file_menu)
self.help_menu = QPopupMenu(self)
self.menuBar().insertSeparator()
self.menuBar().insertItem('&Help', self.help_menu)
self.help_menu.insertItem('&About', self.about)
self.main_widget = QWidget(self, "Main widget")
data = ((lena()/255.)).astype("complex64")
kernel = np.ones((6,6)).astype("complex64")
#data = np.random.uniform(0,1,(8,8)).astype("complex64")
#kernel = np.random.uniform(0,1,(7,7)).astype("complex64")
#power_spec = fftshift(log(abs(signal.fftn(data))))
gpu_conv = fftconvolve2d(data,kernel)
cpu_conv = fftconvolve(data.real, kernel.real, mode="valid")
info("GPU shape = (%s, %s)" % gpu_conv.shape)
info("CPU shape = (%s, %s)" % cpu_conv.shape)
check_results(cpu_conv, gpu_conv)
data_c = ImageCanvas(data.real, self.main_widget)
kernel_c = ImageCanvas(kernel.real, self.main_widget)
gpu_conv_c = ImageCanvas(gpu_conv, self.main_widget)
cpu_conv_c = ImageCanvas(cpu_conv, self.main_widget)
#power_spec = ImageCanvas(power_spec,self.main_widget)
data_label = QLabel("Input Data (lena)", self.main_widget)
data_label.setAlignment(QLabel.AlignCenter)
kernel_label = QLabel("Convolution Kernel", self.main_widget)
kernel_label.setAlignment(QLabel.AlignCenter)
gpu_conv_label = QLabel("GPU fftconvolve (CUDA)", self.main_widget)
gpu_conv_label.setAlignment(QLabel.AlignCenter)
cpu_conv_label = QLabel("CPU fftconvolve (NumPy)", self.main_widget)
cpu_conv_label.setAlignment(QLabel.AlignCenter)
g = QGridLayout(self.main_widget)
g.addWidget(data_label,0,0)
g.addWidget(kernel_label,0,1)
g.addWidget(data_c,1,0)
g.addWidget(kernel_c,1,1)
g.addWidget(gpu_conv_label,2,0)
g.addWidget(cpu_conv_label,2,1)
g.addWidget(gpu_conv_c,3,0)
g.addWidget(cpu_conv_c,3,1)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
self.statusBar().message("%s - v%s" % (PROGNAME, PROG_VERSION) , 2000)
def test_connect_regions_with_grid():
lena = sp.lena()
mask = lena > 50
graph = grid_to_graph(*lena.shape, **{'mask': mask})
assert_equal(ndimage.label(mask)[1], cs_graph_components(graph)[0])
mask = lena > 150
def test_connect_regions():
lena = sp.lena()
for thr in (50, 150):
mask = lena > thr
graph = img_to_graph(lena, mask)
nose.tools.assert_equal(ndimage.label(mask)[1],
cs_graph_components(graph)[0])
def __init__(self):
QMainWindow.__init__(self, None, "FFTLab Main Window",
Qt.WType_TopLevel | Qt.WDestructiveClose)
self.file_menu = QPopupMenu(self)
self.file_menu.insertItem('&Quit', self.file_quit, Qt.CTRL + Qt.Key_Q)
self.menuBar().insertItem('&File', self.file_menu)
self.help_menu = QPopupMenu(self)
self.menuBar().insertSeparator()
self.menuBar().insertItem('&Help', self.help_menu)
self.help_menu.insertItem('&About', self.about)
self.main_widget = QWidget(self, "Main widget")
data = ((lena() / 255.)).astype("complex64")
kernel = np.ones((6, 6)).astype("complex64")
#data = np.random.uniform(0,1,(8,8)).astype("complex64")
#kernel = np.random.uniform(0,1,(7,7)).astype("complex64")
#power_spec = fftshift(log(abs(signal.fftn(data))))
gpu_conv = fftconvolve2d(data, kernel)
cpu_conv = fftconvolve(data.real, kernel.real, mode="valid")
info("GPU shape = (%s, %s)" % gpu_conv.shape)
info("CPU shape = (%s, %s)" % cpu_conv.shape)
check_results(cpu_conv, gpu_conv)
data_c = ImageCanvas(data.real, self.main_widget)
kernel_c = ImageCanvas(kernel.real, self.main_widget)
gpu_conv_c = ImageCanvas(gpu_conv, self.main_widget)
cpu_conv_c = ImageCanvas(cpu_conv, self.main_widget)
#power_spec = ImageCanvas(power_spec,self.main_widget)
data_label = QLabel("Input Data (lena)", self.main_widget)
data_label.setAlignment(QLabel.AlignCenter)
kernel_label = QLabel("Convolution Kernel", self.main_widget)
kernel_label.setAlignment(QLabel.AlignCenter)
gpu_conv_label = QLabel("GPU fftconvolve (CUDA)", self.main_widget)
gpu_conv_label.setAlignment(QLabel.AlignCenter)
cpu_conv_label = QLabel("CPU fftconvolve (NumPy)", self.main_widget)
cpu_conv_label.setAlignment(QLabel.AlignCenter)
g = QGridLayout(self.main_widget)
g.addWidget(data_label, 0, 0)
g.addWidget(kernel_label, 0, 1)
g.addWidget(data_c, 1, 0)
g.addWidget(kernel_c, 1, 1)
g.addWidget(gpu_conv_label, 2, 0)
g.addWidget(cpu_conv_label, 2, 1)
g.addWidget(gpu_conv_c, 3, 0)
g.addWidget(cpu_conv_c, 3, 1)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
self.statusBar().message("%s - v%s" % (PROGNAME, PROG_VERSION), 2000)
def _downsampled_lena():
lena = sp.lena()
lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + \
lena[1::2, 1::2]
lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + \
lena[1::2, 1::2]
lena /= 16.0
return lena
def test_connect_regions_with_grid():
lena = sp.lena()
mask = lena > 50
graph = grid_to_graph(*lena.shape, **{"mask": mask})
assert_equal(ndimage.label(mask)[1], cs_graph_components(graph)[0])
mask = lena > 150
graph = grid_to_graph(*lena.shape, **{"mask": mask, "dtype": None})
assert_equal(ndimage.label(mask)[1], cs_graph_components(graph)[0])
def __init__(self):
iris = datasets.load_iris()
self._x_iris = iris.data
self._y_iris = iris.target
try:
self._lena = sp.lena()
except AttributeError:
from scipy import misc
self._lena = misc.lena()
def test_connect_regions_with_grid():
lena = sp.lena()
mask = lena > 50
graph = grid_to_graph(*lena.shape, mask=mask)
nose.tools.assert_equal(ndimage.label(mask)[1],
cs_graph_components(graph)[0])
mask = lena > 150
graph = grid_to_graph(*lena.shape, mask=mask, dtype=None)
nose.tools.assert_equal(ndimage.label(mask)[1],
cs_graph_components(graph)[0])
def test_connect_regions_with_grid():
lena = sp.lena()
mask = lena > 50
graph = grid_to_graph(*lena.shape, **{'mask' : mask})
nose.tools.assert_equal(ndimage.label(mask)[1],
cs_graph_components(graph)[0])
mask = lena > 150
graph = grid_to_graph(*lena.shape, **{'mask' : mask, 'dtype' : None})
nose.tools.assert_equal(ndimage.label(mask)[1],
cs_graph_components(graph)[0])
def test_tvdenoise():
lena = scipy.lena().astype(np.float)
noisy_lena = lena + 0.2 * lena.std()*np.random.randn(*lena.shape)
denoised_lena_W5 = tvdenoise(lena, niter=10, W=5.0)
denoised_lena_W50 = tvdenoise(lena, niter=10, W=50.)
grad_mag_lena = gradient_magnitude(lena).sum()
grad_mag_noisy = gradient_magnitude(noisy_lena).sum()
grad_mag_denoised_W5 = gradient_magnitude(denoised_lena_W5).sum()
grad_mag_denoised_W50 = gradient_magnitude(denoised_lena_W50).sum()
assert grad_mag_noisy > max(grad_mag_denoised_W5, grad_mag_denoised_W50)
assert grad_mag_denoised_W5 > grad_mag_denoised_W50
assert grad_mag_denoised_W5 > 0.5 * grad_mag_lena
def main():
x=lena()
a=int(32)
y=wv.misc.per_ext2d(x,a)
z=wv.misc.symm_ext2d(x,a)
plt.subplot(2,1,1)
plt.imshow(y,cmap=cm.gray)
plt.xlabel('Periodic Ext')
plt.subplot(2,1,2)
plt.imshow(z,cmap=cm.gray)
plt.xlabel('Symmetric Ext')
plt.show()
def unsupervisedLearningTest02(): from sklearn import cluster import scipy as sp import numpy as np try: lena = sp.lena() except AttributeError: from scipy import misc lena = misc.lena() X = lena.reshape((-1, 1)) k_means = cluster.KMeans(n_clusters = 5, n_init = 1) k_means.fit(X) values = k_means.cluster_centers_.squeeze() labels = k_means.labels_ lena_compressed = np.choose(labels, values) lena_compressed.shape = lena.shape print lena_compressed
def test_tv_denoise_2d(self):
"""
Apply the TV denoising algorithm on the lena image provided
by scipy
"""
import scipy
# lena image
lena = scipy.lena().astype(np.float)
# add noise to lena
lena += 0.5 * lena.std()*np.random.randn(*lena.shape)
# denoise
denoised_lena = F.tv_denoise(lena, weight=60.0)
# which dtype?
assert denoised_lena.dtype in [np.float, np.float32, np.float64]
from scipy import ndimage
grad = ndimage.morphological_gradient(lena, size=((3,3)))
grad_denoised = ndimage.morphological_gradient(denoised_lena, size=((3,3)))
# test if the total variation has decreased
assert np.sqrt((grad_denoised**2).sum()) < np.sqrt((grad**2).sum()) / 2
denoised_lena_int = F.tv_denoise(lena.astype(np.int32), \
weight=60.0, keep_type=True)
assert denoised_lena_int.dtype is np.dtype('int32')
def test_tv_denoise_2d(self):
"""
Apply the TV denoising algorithm on the lena image provided
by scipy
"""
import scipy
# lena image
lena = scipy.lena().astype(np.float)
# add noise to lena
lena += 0.5 * lena.std() * np.random.randn(*lena.shape)
# denoise
denoised_lena = F.tv_denoise(lena, weight=60.0)
# which dtype?
assert denoised_lena.dtype in [np.float, np.float32, np.float64]
from scipy import ndimage
grad = ndimage.morphological_gradient(lena, size=((3, 3)))
grad_denoised = ndimage.morphological_gradient(denoised_lena,
size=((3, 3)))
# test if the total variation has decreased
assert np.sqrt((grad_denoised**2).sum()) < np.sqrt((grad**2).sum())
denoised_lena_int = F.tv_denoise(lena.astype(np.int32), \
weight=60.0, keep_type=True)
assert denoised_lena_int.dtype is np.dtype('int32')
for key in paths:
shift = numpy.zeros(2)
count = min(paths[key]["count"])
for npa in paths[key]["shift"]:
shift += npa
d.append({"path": key, "shift": shift, "count": count})
d.sort(mysort)
return d
if __name__ == "__main__":
#lena1 = numpy.zeros((512, 512))
#scipy.lena()
#lena1[100:150, 160:200] = 1
ao1, ao2 = 5, 3
print("Absolute offset is %s,%s" % (ao1, ao2))
lena1 = scipy.lena()
lena2 = numpy.zeros_like(lena1)
lena2[ao1:, ao2:] = lena1[:-ao1, :-ao2]
# out = Visual_SURF(lena1, lena2)
"""
out = feature.surf2(lena1, lena2, verbose=1)
print "clacShift", calcShift(out)
# raw_input("Enter to continue")
out2 = feature.reduce_orsa(out)
# print "SURF: %s keypoint; ORSA -> %s" % (out.shape[0], out2.shape[0])
# out = out2
print "*" * 80
# out = feature.sift2(lena1, lena2, verbose=1)
out = Visual_SIFT(lena1, lena2)
print "clacShift", calcShift(out)
import numpy as np
import scipy as sp
import pylab as pl
from scipy import ndimage, signal
l = sp.lena()[200:-140, 190:-150]
l = l/float(l.max())
pl.figure(figsize=(12, 4.5))
pl.axes([0.15, 0, 0.3, 1])
pl.gray()
pl.imshow(l, vmin=0, vmax=1)
pl.title('Ground truth')
pl.axis('off')
pl.axes([0.5, 0, 0.3, 1])
g = l + .13*np.random.normal(size=l.shape)
pl.imshow(g, vmin=0, vmax=1)
pl.title('Noisy observation')
pl.axis('off')
import numpy as np import scipy as sp import harris im = sp.lena() harrisim = harris.compute_harris_response(im) filtered_coords = harris.get_harris_points(harrisim, 6) harris.plot_harris_points(im, filtered_coords)
# Read in the lena image and use an averging filter # to "smooth" the image. Use a "5 point stencil" where # you average the current pixel with its neighboring pixels # # 0 0 0 0 0 0 0 # 0 0 0 x 0 0 0 # 0 0 x x x 0 0 # 0 0 0 x 0 0 0 # 0 0 0 0 0 0 0 # # Plot the image, the smoothed image, and the difference between the # two. # # Bonus: Re-filter the image by passing the result image # through the filter again. Do this 50 times and plot # the resulting image. from scipy import lena from matplotlib.pylab import subplot, imshow, title, show, gray, cm img = lena() imshow(img, cmap=cm.gray) show()
import scipy as sp
import numpy as np
import pylab as pl
l = sp.lena()
l = l[235:235 + 153, 205:162 + 205]
t = pl.imread('tarek.jpg')
t = t[::-1, ...]
t = t.sum(axis=-1)
pl.figure()
pl.imshow(t, cmap=pl.cm.gray)
pl.axis('off')
pl.figure()
pl.imshow(l, cmap=pl.cm.gray)
pl.axis('off')
t = t.astype(np.float)
t /= t.max()
l = l.astype(np.float)
l /= l.max()
pl.figure()
pl.imshow(t + l, cmap=pl.cm.gray)
pl.axis('off')
print __doc__ from time import time import pylab as pl import scipy as sp import numpy as np from sklearn.decomposition import DictionaryLearningOnline from sklearn.feature_extraction.image import extract_patches_2d from sklearn.feature_extraction.image import reconstruct_from_patches_2d ############################################################################### # Load Lena image and extract patches lena = sp.lena() / 256.0 # downsample for higher speed lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2] lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2] lena /= 16.0 height, width = lena.shape # Distort the right half of the image print 'Distorting image...' distorted = lena.copy() distorted[:, height / 2:] += 0.075 * np.random.randn(width, height / 2) # Extract all clean patches from the left half of the image print 'Extracting clean patches...' t0 = time()
0 0 x x x 0 0
0 0 0 x 0 0 0
0 0 0 0 0 0 0
Once you have a numpy expression that works correctly, time it
using time.time (or time.clock on windows).
Use scipy.weave.blitz to run the same expression. Again time it.
Compare the speeds of the two function and calculate the speed-up
(numpy_time/weave_time).
Plot two images that result from the two approaches and compare them.
"""
import time
from numpy import empty, float64
from scipy import lena
from scipy import weave
from matplotlib.pylab import subplot, imshow, title, show, gray, figure
img = lena()
expr = """avg_img =( img[1:-1 ,1:-1] # center
+ img[ :-2 ,1:-1] # left
+ img[2: ,1:-1] # right
+ img[1:-1 , :-2] # top
+ img[1:-1 ,2: ] # bottom
) / 5.0"""
#!/usr/bin/env python
import numpy as np
import scipy
import linear_operators as lo
# Load the infamous Lena image from scipy
im = scipy.lena()
im = im[::4, ::4]
# Generate a convolution model with a 7x7 uniform kernel
model = lo.convolve_fftw3(im.shape, np.ones((7, 7)))
# convolve the original image
data = model * im.ravel()
# add noise to the convolved data
data += 1e0 * np.random.randn(*data.shape)
# define smoothness prior
#prior = lo.concatenate([lo.diff(im.shape, axis=i) for i in xrange(im.ndim)])
prior = lo.concatenate([lo.diff(im.shape, axis=i) for i in xrange(im.ndim)]
+ [lo.wavelet2(im.shape, "haar"),])
# generate algorithm
algo = lo.DoubleLoopAlgorithm(model, data, prior)
# start the estimation algorithm
xe = algo()
# reshape the output as the algorithm only handles vectors
xe.resize(im.shape)
# TODO: simpler imshow, without complete GUI
return _advanced_imshow(im, flip=flip, mgr=mgr)
def _advanced_imshow(im, flip=None, mgr=None):
return AdvancedImageViewerApp(im, flip=flip, mgr=mgr)
if __name__ == "__main__":
from scikits.image.filter import tvdenoise
from scikits.image.io import imread, imshow
import numpy.random as npr
import os, os.path
import sys
app = QApplication(sys.argv)
if len(sys.argv) > 1:
image = imread(sys.argv[1])
else:
import scipy
image = scipy.lena()
flip = None
if len(sys.argv) > 2:
flip = imread(sys.argv[2])
viewer = _advanced_imshow(image, flip=flip, mgr=None)
viewer.show()
sys.exit(app.exec_())
# select the best points taking min_distance into account
filtered_coords = []
for i in index:
if allowed_locations[coords[i][0]][coords[i][1]] == 1:
filtered_coords.append(coords[i])
allowed_locations[
(coords[i][0] - min_distance):(coords[i][0] + min_distance),
(coords[i][1] - min_distance):(coords[i][1] + min_distance)] = 0
return filtered_coords
def plot_harris_points(image, filtered_coords):
""" plots corners found in image"""
pyplot.subplot(111)
pyplot.imshow(image)
pyplot.plot([p[1] for p in filtered_coords],
[p[0] for p in filtered_coords],
'*')
pyplot.axis('off')
pyplot.show()
if __name__ == '__main__':
import scipy as sp
im = sp.lena().astype(float)
harrisim = compute_harris_response(im)
filtered_coords = get_harris_points(harrisim, 6)
plot_harris_points(im, filtered_coords)
def _downsampled_lena():
lena = sp.lena()
lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2]
lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2]
lena /= 16.0
return lena
print __doc__ from time import time import pylab as pl import scipy as sp import numpy as np from sklearn.decomposition import MiniBatchDictionaryLearning from sklearn.feature_extraction.image import extract_patches_2d from sklearn.feature_extraction.image import reconstruct_from_patches_2d ############################################################################### # Load Lena image and extract patches lena = sp.lena() / 256.0 # downsample for higher speed lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2] lena /= 4.0 height, width = lena.shape # Distort the right half of the image print 'Distorting image...' distorted = lena.copy() distorted[:, height / 2:] += 0.075 * np.random.randn(width, height / 2) # Extract all clean patches from the left half of the image print 'Extracting clean patches...' t0 = time() patch_size = (7, 7)
shift = numpy.zeros(2)
count = min(paths[key]["count"])
for npa in paths[key]["shift"]:
shift += npa
d.append({"path": key, "shift": shift, "count": count})
d.sort(mysort)
return d
if __name__ == "__main__":
# lena1 = numpy.zeros((512, 512))
# scipy.lena()
# lena1[100:150, 160:200] = 1
ao1, ao2 = 5, 3
print ("Absolute offset is %s,%s" % (ao1, ao2))
lena1 = scipy.lena()
lena2 = numpy.zeros_like(lena1)
lena2[ao1:, ao2:] = lena1[:-ao1, :-ao2]
# out = Visual_SURF(lena1, lena2)
"""
out = feature.surf2(lena1, lena2, verbose=1)
print "clacShift", calcShift(out)
# raw_input("Enter to continue")
out2 = feature.reduce_orsa(out)
# print "SURF: %s keypoint; ORSA -> %s" % (out.shape[0], out2.shape[0])
# out = out2
print "*" * 80
# out = feature.sift2(lena1, lena2, verbose=1)
out = Visual_SIFT(lena1, lena2)
print "clacShift", calcShift(out)
import numpy as np
import scipy
from scipy import ndimage
import matplotlib.pyplot as plt
lena = scipy.lena()
lx, ly = lena.shape
# Copping
crop_lena = lena[lx / 4:-lx / 4, ly / 4:-ly / 4]
# up <-> down flip
flip_ud_lena = np.flipud(lena)
# rotation
rotate_lena = ndimage.rotate(lena, 45)
rotate_lena_noreshape = ndimage.rotate(lena, 45, reshape=False)
plt.figure(figsize=(12.5, 2.5))
plt.subplot(151)
plt.imshow(lena, cmap=plt.cm.gray)
plt.axis('off')
plt.subplot(152)
plt.imshow(crop_lena, cmap=plt.cm.gray)
plt.axis('off')
plt.subplot(153)
plt.imshow(flip_ud_lena, cmap=plt.cm.gray)
plt.axis('off')
plt.subplot(154)
plt.imshow(rotate_lena, cmap=plt.cm.gray)
plt.axis('off')
plt.subplot(155)
plt.imshow(rotate_lena_noreshape, cmap=plt.cm.gray)
import scipy as sp
import numpy as np
import pylab as pl
l = sp.lena()
l_ = l[235:235+153, 205:162+205]
t = pl.imread('tarek.jpg')
t = t[::-1, ...]
t_ = t.sum(axis=-1)
################################################################################
pl.figure(0, figsize=(12, 4.5))
pl.gray()
pl.clf()
pl.axes([0, 0, 0.3, 1])
pl.imshow(t_.copy())
pl.axis('off')
pl.axes([0.33, 0, 0.3, 1])
pl.imshow(l_.copy())
pl.axis('off')
t_ = t_.astype(np.float)
t_ /= t_.max()
l_ = l_.astype(np.float)
l_ /= l_.max()
pl.axes([0.66, 0, 0.3, 1])
pl.imshow(t_ + l_)
pl.axis('off')
from numpy import float32 from pylab import imshow, figure, show from scipy import signal, lena figure() lena = lena() lena = lena.astype(float32) imshow(lena) figure() fl = signal.medfilt2d(lena,[15,15]) imshow(fl) show()
while len(stack)>0:
p=stack.pop()
for pp in map(lambda x:(min(max(x[0]+p[0],0),h-1)*w+min(max(x[1]+p[1],0),w-1)) ,footprintp):
p2=(pp//w,pp%w)
if (img[p2]==img[p]) and L[p2]<0:
assert(L[p]>=0)
L[p2]=L[p]
stack.append(p2)
for x in imgsrt:
p=(x//w,x%w)
if L[p]<0:
#surroundlabels=LR.take(map(lambda x:(min(max(x[0]+p[0],0),h-1)*w+min(max(x[1]+p[1],0),w-1)) ,footprintp))
surroundlabels=collect_around(p)
surroundlabels=filter(lambda x:x>=0,surroundlabels)
if len(set(surroundlabels))<=1:
if len(surroundlabels)==0:
L[p]=clabel
propagate_around(p)
clabel+=1
else:
L[p]=surroundlabels[0]
propagate_around(p)
else:
L[p]=random.choice(surroundlabels)
propagate_around(p)
return L
if __name__=="__main__":
r=watershed(scipy.ndimage.distance_transform_edt(scipy.lena()[::4,::4]>128).astype(numpy.uint8),F1)
pylab.clf();pylab.imshow(r);pylab.show()
return self.splines.contents
def __init__(self):
self.opts = at_fitting_opts_new()
self.output_opts = at_output_opts_new()
def trace(self,img):
ab=NumPy2AtBitmap(img)
splines = at_splines_new(ab,
self.opts,
at_msg_func(),
at_address())
at_bitmap_free(ab)
return AutoTrace.AutoTraceResult(splines)
def output(self,filename,tracing):
a=at_output_get_handler_by_suffix(c_char_p(filename.split('.')[-1]))
b=_libc.fopen(filename,"wb")
at_splines_write(a,b,"",self.output_opts,
tracing.splines,
at_msg_func(),
at_address()
)
_libc.fclose(b)
if __name__=="__main__":
import scipy
xl=scipy.lena().astype(numpy.uint8).reshape(512,512,1)
at=AutoTrace()
at.opts.contents.despeckle_level=10
print at.trace(xl).__dict__()
import numpy as np
import scipy as sp
import pylab as pl
from scipy import ndimage, signal
l = sp.lena()[200:-140, 190:-150]
l = l / float(l.max())
pl.figure(figsize=(12, 4.5))
pl.axes([0.15, 0, 0.3, 1])
pl.gray()
pl.imshow(l, vmin=0, vmax=1)
pl.title('Ground truth')
pl.axis('off')
pl.axes([0.5, 0, 0.3, 1])
g = l + .13 * np.random.normal(size=l.shape)
pl.imshow(g, vmin=0, vmax=1)
pl.title('Noisy observation')
pl.axis('off')
import numpy as np
import scipy
import matplotlib.pyplot as plt
lena = scipy.lena()
lena[10:13, 20:23]
lena[100:120] = 255
lx, ly = lena.shape
X, Y = np.ogrid[0:lx, 0:ly]
mask = (X - lx/2)**2 + (Y - ly/2)**2 > lx*ly/4
lena[mask] = 0
lena[range(400), range(400)] = 255
plt.figure(figsize=(3,3))
plt.axes([0, 0, 1, 1])
plt.imshow(lena, cmap=plt.cm.gray)
plt.axis('off')
plt.show()
def test_write_frame_image():
img = Image.fromarray(lena()).convert("RGB")
b = TheoraEncoder(VIDEO_DIR+"/b.ogv", img.size[0], img.size[1])
b.write_frame_image(img)
import matplotlib.pyplot as plt import matplotlib.cm as cm from sklearn import cluster, datasets import scipy as sp import numpy as np try: lena = sp.lena() except AttributeError: from scipy import misc lena = misc.lena() X = lena.reshape((-1, 1)) # We need an (n_sample, n_feature) array k_means = cluster.KMeans(n_clusters=5, n_init=1) k_means.fit(X) values = k_means.cluster_centers_.squeeze() labels = k_means.labels_ lena_compressed = np.choose(labels, values) lena_compressed.shape = lena.shape plt.imshow(lena_compressed, cmap = cm.Greys_r) plt.show()
import numpy as np import scipy import matplotlib.pyplot as plt l = scipy.lena()
import numpy as np
import scipy
from scipy import ndimage
import matplotlib.pyplot as plt
l = scipy.lena()
sx, sy = l.shape
X, Y = np.ogrid[0:sx, 0:sy]
r = np.hypot(X - sx/2, Y - sy/2)
rbin = (20* r/r.max()).astype(np.int)
radial_mean = ndimage.mean(l, labels=rbin, index=np.arange(1, rbin.max() +1))
plt.figure(figsize=(5,5))
plt.axes([0, 0, 1, 1])
plt.imshow(rbin, cmap=plt.cm.spectral)
plt.axis('off')
plt.show()
def plotTest02(): import numpy as np import scipy as sp import matplotlib.pyplot as plt from sklearn import cluster n_clusters = 5 np.random.seed(0) try: lena = sp.lena() except AttributeError: from scipy import misc lena = misc.lena() X = lena.reshape((-1, 1)) k_means = cluster.KMeans(n_clusters = n_clusters, n_init = 4) k_means.fit(X) values = k_means.cluster_centers_.squeeze() #这是获得聚类中心 labels = k_means.labels_ lena_compressed = np.choose(labels, values) lena_compressed.shape = lena.shape vmin = lena.min() vmax = lena.max() #original plt.figure(1, figsize = (3, 2.2)) plt.imshow(lena, cmap = plt.cm.gray, vmin = vmin, vmax = vmax) #compressed data plt.figure(2, figsize = (3, 2.2)) plt.imshow(lena_compressed, cmap = plt.cm.gray, vmin = vmin, vmax = vmax) #这里面有一些函数要搞清楚意义是什么 #equal bins lena regular_values = np.linspace(0, 256, n_clusters + 1) regular_labels = np.searchsorted(regular_values, lena) - 1 regular_values = 0.5 * (regular_values[1:] + regular_values[:-1]) #mean regular_lena = np.choose(regular_labels.ravel(), regular_values) regular_lena.shape = lena.shape plt.figure(3, figsize=(3, 2.2)) plt.imshow(regular_lena, cmap = plt.cm.gray, vmin = vmin, vmax = vmax) #histogram plt.figure(4, figsize = (3, 2.2)) plt.clf() plt.axes([0.01, 0.01, 0.98, 0.98]) plt.hist(X, bins = 256, color = '0.5', edgecolor = '.5') plt.yticks() plt.xticks(regular_values) values = np.sort(values) for center_1, center_2 in zip(values[:-1], values[1:]): plt.axvline(0.5 * (center_1 + center_2), color = 'b') for center_1, center_1 in zip(regular_values[:-1], regular_values[1:]): plt.axvline(0.5 * (center_1 + center_2), color = 'b', linestyle = '--') plt.show()
# -*- coding: utf-8 -*- """ Spyder Editor This temporary script file is located here: C:\Users\Administrator\.spyder2\.temp.py """ import pylab as pl import scipy as sp img = sp.lena() pl.imshow(img, cmap=pl.cm.gray) img2 = img[:-2, 1:-1] - img[2:, 1:-1] + img[1:-1, :-2] - img[1:-1, 2:] pl.figure() pl.imshow(img2, cmap=pl.cm.gray) pl.show()
# Code source: Gaël Varoquaux
# Modified for documentation by Jaques Grobler
# License: BSD 3 clause
import numpy as np
import scipy as sp
import pylab as pl
from sklearn import cluster
n_clusters = 5
np.random.seed(0)
try:
lena = sp.lena()
except AttributeError:
# Newer versions of scipy have lena in misc
from scipy import misc
lena = misc.lena()
X = lena.reshape((-1, 1)) # We need an (n_sample, n_feature) array
k_means = cluster.KMeans(n_clusters=n_clusters, n_init=4)
k_means.fit(X)
values = k_means.cluster_centers_.squeeze()
labels = k_means.labels_
# create an array from labels and values
lena_compressed = np.choose(labels, values)
lena_compressed.shape = lena.shape
vmin = lena.min()
#CV_FOURCC('U', '2', '6', '3') = H263 codec
#CV_FOURCC('I', '2', '6', '3') = H263I codec
#CV_FOURCC('F', 'L', 'V', '1') = FLV1 codec
class CvVideoWriter:
def __init__(self,fname,fps = 25,frameW = 320,frameH = 200, codec="MJPG", isColor=1):
self.writer=cvCreateVideoWriter(fname,
CV_FOURCC(codec[0],codec[1],codec[2],codec[3]),
fps,
cvSize(frameW,frameH),
isColor)
def push(self,img):
cvWriteFrame(self.writer,img.copy('C'))
def __del__(self):
pass
#cvReleaseVideoWriter(self.writer)
# import pycvf.lib.video.cvvideowriter as cvw; cvw.CvVideoWriter("/tmp/out1.avi")
if __name__ == "__main__":
import numpy,scipy
from pycvf.lib.graphics.rescale import Rescaler2d
rsc=Rescaler2d((320,200))
c=CvVideoWriter("/tmp/test.mpg")
ib=scipy.lena().reshape((512,512,1)).repeat(3,axis=2)
for i in range(100):
print "Frame ",i
ib[:,:,0]=i*3
c.push(rsc.process(ib).astype(numpy.uint8))
#type_converters = converters.blitz
)
assert(not context.has_key("__inlineargs__"))
context["__inlineargs__"]=args
context["__inlinekwargs__"]=kwargs
r= eval("inline(*__inlineargs__,**__inlinekwargs__)",globals(),context)
context["__inlineargs__"]=None
return r
return fct
if __name__=="__main__":
import time
st=time.clock()
lena=scipy.lena().reshape(512,512,1).repeat(3,axis=2).astype(numpy.uint8).swapaxes(0,1).copy('F')
cimg_code("do_test( a_array );",
"""
#include <CImg.h>
using namespace cimg_library;
int do_test(PyArrayObject * npimg ) {
assert(npimg->nd==3);
printf("%p %d x %d x %d\\n",npimg->data,npimg->dimensions[1],npimg->dimensions[0],npimg->dimensions[2]);
CImg<unsigned char> image(npimg->data,npimg->dimensions[1],npimg->dimensions[0],1,npimg->dimensions[2]), visu(500,400,1,3,0);
image=image.blur(2.5);
return 0;
}
""",True)(a=lena)
print "done in ",time.clock()-st, "seconds";
# -*- coding: utf-8 -*- """ 对图像进行浮雕处理 """ import pylab as pl import scipy as sp img = sp.lena() pl.imshow(img, cmap=pl.cm.gray) img2 = img[:-2,1:-1]-img[2:,1:-1]+img[1:-1, :-2]-img[1:-1,2:] pl.figure() pl.imshow(img2, cmap=pl.cm.gray) pl.show()
