def __init__(self, image=[[0.0]]):
from scipy import signal, misc
import numpy as np
self.img = np.array(image)
dim = len(image.shape)
derfilt = np.array([1.0, -2, 1.0], dtype=np.float32)
if dim == 3:
for sl1 in range(image.shape[2]):
ck = signal.cspline2d(self.img[:, :, sl1].copy(), 8.0)
self.img[:, :, sl1] = (signal.sepfir2d(ck, derfilt, [1]) +
signal.sepfir2d(ck, [1], derfilt))
if dim == 4:
for sl1 in range(image.shape[2]):
for sl2 in range(image.shape[3]):
ck = signal.cspline2d(self.img[:, :, sl1, sl2].copy(), 8.0)
self.img[:, :, sl1,
sl2] = (signal.sepfir2d(ck, derfilt, [1]) +
signal.sepfir2d(ck, [1], derfilt))
if dim == 5:
for sl1 in range(image.shape[2]):
for sl2 in range(image.shape[3]):
for sl3 in range(image.shape[4]):
ck = signal.cspline2d(
self.img[:, :, sl1, sl2, sl3].copy(), 8.0)
self.img[:, :, sl1, sl2,
sl3] = (signal.sepfir2d(ck, derfilt, [1]) +
signal.sepfir2d(ck, [1], derfilt))
def laplace_interp(image,
splineimage=None,
direction='vertical',
splinesmooth=1.0):
if splineimage is None:
splineimage = signal.cspline2d(image, splinesmooth)
laplacian = np.zeros([3, 3], dtype='float32')
laplacian[1, 1] = -2.0
if direction in ("diagonal1", "diagonalleft"):
laplacian[0, 0] = 1.0
laplacian[2, 2] = 1.0
elif direction in ("diagonal2", "diagonalright"):
laplacian[2, 0] = 1.0
laplacian[0, 2] = 1.0
elif direction == 'vertical':
laplacian[1, 0] = 1.0
laplacian[1, 2] = 1.0
elif direction == 'horizontal':
laplacian[0, 1] = 1.0
laplacian[2, 1] = 1.0
filtered_image = signal.convolve2d(splineimage,
laplacian,
mode='same',
boundary='symm')
# edges have no curvature
filtered_image[0, :] = 0.0
filtered_image[-1, :] = 0.0
filtered_image[:, 0] = 0.0
filtered_image[:, -1] = 0.0
return filtered_image
def TestLaws( mgnames, NJ = 100 ):
# create laws filters
filts = texture.BuildLawsFilters()
# allocate for jets
NI = len( mgnames ) # number of images
jets = np.zeros( (NJ*NI, 25 ))
# for each image
for i in xrange( NI ):
# load
# correlate
#corrs = BruteCorrelate( data, filts )
data = mgnames[i]+0
corrs = map( lambda x: correlate2d( data, x ), filts )
for j in range( 25 ):
corrs[i] = cspline2d( abs(corrs[i]), 200 )
corrs = np.array( corrs )
# extract random jets
V,H = data.shape
vs = range( V )
hs = range( H )
np.random.shuffle( vs ); np.random.shuffle( hs )
for j in range( NJ ):
jets[i*NJ + j] = corrs[:,vs[j], hs[j] ]
# k-means clustering
clust, mmb = kmeans.KMeans( NI, jets )
#return jets
cffs,evecs = pca.PCA(clust,3)
cffs = pca.Map2PCA(clust,evecs)
gnu.Save('Laws_results.txt',cffs)
return clust,cffs
def TestLaws(mgnames, NJ=100):
# create laws filters
filts = texture.BuildLawsFilters()
# allocate for jets
NI = len(mgnames) # number of images
jets = np.zeros((NJ * NI, 25))
# for each image
for i in xrange(NI):
# load
# correlate
#corrs = BruteCorrelate( data, filts )
data = mgnames[i] + 0
corrs = map(lambda x: correlate2d(data, x), filts)
for j in range(25):
corrs[i] = cspline2d(abs(corrs[i]), 200)
corrs = np.array(corrs)
# extract random jets
V, H = data.shape
vs = range(V)
hs = range(H)
np.random.shuffle(vs)
np.random.shuffle(hs)
for j in range(NJ):
jets[i * NJ + j] = corrs[:, vs[j], hs[j]]
# k-means clustering
clust, mmb = kmeans.KMeans(NI, jets)
#return jets
cffs, evecs = pca.PCA(clust, 3)
cffs = pca.Map2PCA(clust, evecs)
gnu.Save('Laws_results.txt', cffs)
return clust, cffs
def laplace_interp(image, splineimage=None, direction='vertical', splinesmooth=1.0):
if splineimage is None:
splineimage = signal.cspline2d(image,splinesmooth)
laplacian = np.zeros([3,3],dtype='float32')
laplacian[1,1] = -2.0
if direction in ("diagonal1","diagonalleft"):
laplacian[0,0] = 1.0
laplacian[2,2] = 1.0
elif direction in ("diagonal2","diagonalright"):
laplacian[2,0] = 1.0
laplacian[0,2] = 1.0
elif direction == 'vertical':
laplacian[1,0] = 1.0
laplacian[1,2] = 1.0
elif direction == 'horizontal':
laplacian[0,1] = 1.0
laplacian[2,1] = 1.0
filtered_image = signal.convolve2d(splineimage,laplacian,mode='same',boundary='symm')
# edges have no curvature
filtered_image[0,:] = 0.0
filtered_image[-1,:] = 0.0
filtered_image[:,0] = 0.0
filtered_image[:,-1] = 0.0
return filtered_image
def filter_grid(grid, input_filter, min_value=0, size=5):
result = None
if input_filter == "edge":
ck = signal.cspline2d(grid, 8.0)
laplacian = array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], float32)
result = signal.convolve2d(ck, laplacian, mode="same", boundary="symm")
elif input_filter == "bulge":
ck = signal.cspline2d(grid, 8.0)
laplacian = array([[0, 1, 0], [1, -3.9, 1], [0, 1, 0]], float32)
grid1 = signal.convolve2d(ck, laplacian, mode="same", boundary="symm")
grid1 = absolute(grid1)
result = grid * 0.1 + grid1
elif input_filter == "nearby": # this is just a boolean filter
mask = ones((size, size))
edge = signal.convolve2d(grid, mask, mode="same", boundary="symm")
result = edge > (min_value * mask.size)
return result
def max_curvature(image, splinesmooth=2.0):
splineimage = signal.cspline2d(image, splinesmooth)
curvarr = np.array([
laplace_interp(image, splineimage, direction=D)
for D in ['vertical', 'horizontal', 'diagonal1', 'diagonal2']
]) * -1.0
return curvarr.max(axis=0)
def filter(self):
# img_average = numpy.average(self.training_set[0].image_data)
image = self.training_set[0].image_data
derfilt = numpy.array([1.0,-2,1.0],numpy.float32)
ck = signal.cspline2d(image,8.0)
deriv = signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)
print_image(deriv, 'bsplines.png')
for std in [1,2,4,8,16,32,64,128]:
filtered_img = ndimage.median_filter(image, std)
print_image(filtered_img, 'median_{}.png'.format(std))
def SoftSquareAnnulus( D=512, L1=64, L2=48, sm=25 ):
"""Frame, box radii, smooth
Creates an image array with a smoothed square annulus
D = frame size: answ is D x D
L1 = half width (height) of outer annulus box
L2 = half width (height) of inner annulus box
sm = smoothing factor
returns: array"""
answ = SquareAnnulus( D, L1, L2 )
answ = cspline2d( answ, sm )
return answ
def pixel_basis_to_bspline(image, bspline_degree):
m = bspline_degree
if m == 0:
bspline_image = image
elif m == 2:
bspline_image = signal.qspline2d(image)
elif m == 3:
bspline_image = signal.cspline2d(image)
else:
sys.exit('\nERROR: B-spline degree not supported !!')
return bspline_image
def pixel_basis_to_bspline( image , bspline_degree ):
m = bspline_degree
if m == 0:
bspline_image = image
elif m == 2:
bspline_image = signal.qspline2d( image )
elif m == 3:
bspline_image = signal.cspline2d( image )
else:
sys.exit('\nERROR: B-spline degree not supported !!')
return bspline_image
def edge_laplacian(images):
'''Do edge detection'''
from scipy import signal
output = []
dim = np.sqrt(images.shape[1])
for image in images.reshape(len(images), dim, dim):
ck_spline = signal.cspline2d(image, 8.0, 1.0)
laplacian = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], np.float32)
deriv2 = signal.convolve2d(ck_spline, laplacian, mode = 'same', boundary = 'symm')
output.append(deriv2)
return np.array(output, dtype = float).reshape(len(images), -1)
def interpolate(img_stack, slices, method='bcspline'):
"""interpolate a single frame. method can be none, bilinear, lanczos3, or bcspline"""
#TODO: make this more efficient!!
if method == 'none':
return img_stack
#create the filter based on the type of interpolation:
if method == 'bcspline':
#reconstruction/interpolation filter
#3rd order bspline function
filt = signal.bspline([-1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5], 3)
elif method == 'bilinear':
filt = [0.5, 1.0, 0.5]
elif method == 'lanczos3':
#x = linspace(-2.5,2.5,11) #evenly spaced from -2.5 to 2.5 by 0.5 increments
#filt = sinc(x/3)*sinc(x)
filt = [
2.44565217e-02, 0, -1.35869565e-01, 0, 6.11413043e-01, 1,
6.11413043e-01, 0, -1.35869565e-01, 0, 2.44565217e-02
]
#allocate the output array:
#img_stack.shape is (w/2, h/2, 4)
#we're going to expand to (w,h,4):
s = list(img_stack.shape)
s[:2] = np.multiply(s[:2], 2) #element-wise multiply (w,h,4)
#interpolated result:
interp_stack = zeros(s)
#interpolation coefficients for intermediate steps
c_jk = zeros(s[:2]) #(w,h)
#loop over last dimension (i0,i90,...)
for j in xrange(s[-1]):
#zero the coefficients
c_jk[...] = 0.0
#get coefficients
if method in ['bilinear', 'lanczos3']:
#coefficients are just the image slices
c_jk[slices[j]] = img_stack[..., j]
elif method == 'bcspline':
#coefficients are bicubic spline coefficients for slice
c_jk[slices[j]] = signal.cspline2d(img_stack[..., j])
#convolve (filters are seperable, so we can use sepfir2d)
interp_stack[..., j] = signal.sepfir2d(c_jk, filt, filt)
#return interpolated image:
return interp_stack
def FuzzBlocks():
data = np.zeros((512,512))
k = 0.0
for v in range( 7 ):
for h in range( 7 ):
# create the image
temp = np.zeros((64,64))
temp[16:48,16:48] = 1
if k > 0:
temp = cspline2d( temp, k )
# place in large array
vv = (v+1)*64-32
hh = (h+1)*64-32
data[vv:vv+64,hh:hh+64] = temp + 0
k += 1
return data
def edge_laplacian(images):
'''Do edge detection'''
from scipy import signal
output = []
dim = np.sqrt(images.shape[1])
for image in images.reshape(len(images), dim, dim):
ck_spline = signal.cspline2d(image, 8.0, 1.0)
laplacian = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], np.float32)
deriv2 = signal.convolve2d(ck_spline,
laplacian,
mode='same',
boundary='symm')
output.append(deriv2)
return np.array(output, dtype=float).reshape(len(images), -1)
def Process(self, steps):
N = len(steps)
for command in steps:
cName = command[0]
if (cName == "D"):
print("in Shift")
yIn = command[1]
xIn = command[2]
vec = np.array([yIn, xIn])
self.finalImg = nd.shift(self.finalImg, vec)
elif (cName == "R"):
print("in Rotate")
deg = command[1]
self.finalImg = nd.rotate(self.finalImg, deg)
elif (cName == "C"):
print("in Crop")
top = command[1]
bottom = command[2]
left = command[3]
right = command[4]
self.finalImg = self.finalImg[top:bottom, left:right]
elif (cName == "S"):
print("in Smooth")
smooth = command[1]
self.finalImg = sg.cspline2d(self.finalImg, smooth)
elif (cName == "L"):
print("in Dilation")
dil = command[1]
self.finalImg = nd.grey_dilation(self.finalImg, dil)
elif (cName == "T"):
print("in Square Root")
self.finalImg = np.sqrt(self.finalImg)
elif (cName == "P"):
print("in Passive Threshold")
thresh = command[1]
lowValIndic = self.finalImg < thresh
self.finalImg[lowValIndic] = 0
sm.imsave("finalImag.jpg", self.finalImg)
def test_cspline2d():
np.random.seed(181819142)
image = np.random.rand(71, 73)
signal.cspline2d(image, 8.0)
def max_curvature(image, splinesmooth=2.0):
splineimage = signal.cspline2d(image,splinesmooth)
curvarr = np.array([laplace_interp(image,splineimage,direction=D) for D in ['vertical','horizontal','diagonal1','diagonal2']]) * -1.0
return curvarr.max(axis=0)
# the transpose makes the coordinates of images match those of matrices
img_array = np.array(img).transpose()
img.close()
# x_points = []
# y_points = []
# for i in range(len(img_array)):
# for j in range(len(img_array[i])):
# if img_array[i][j] == 1:
# x_points.append(i)
# y_points.append(j)
#
# tck = interpolate.splrep(x_points, y_points)
derfilt = np.array([1.0, -2, 1.0], dtype=np.float32)
ck = signal.cspline2d(img_array, 8.0)
deriv = (signal.sepfir2d(ck, derfilt, [1]) +
signal.sepfir2d(ck, [1], derfilt))
plt.figure()
plt.imshow(deriv)
plt.gray()
plt.title('Output of spline edge filter')
image_file_name = image_file_name.replace(input_extension, '')
plt.savefig(OUTPUT_DIR + image_file_name + '.pdf')
plt.show()
plt.close()
# np.savetxt(OUTPUT_DIR + image_file_name + '.txt', [[contour[:, 1], contour[:, 0]] for contour in contours], fmt='%s')
import numpy as np
from scipy import signal, misc
import matplotlib.pyplot as plt
image = misc.face(gray=True).astype(np.float32)
derfilt = np.array([1.0, -2, 1.0], dtype=np.float32)
ck = signal.cspline2d(image, 8.0)
deriv = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt))
# Alternatively we could have done::
# laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32)
# deriv2 = signal.convolve2d(ck,laplacian,mode='same',boundary='symm')
plt.figure()
plt.imshow(image)
plt.gray()
plt.title('Original image')
plt.show()
plt.figure()
plt.imshow(deriv)
plt.gray()
plt.title('Output of spline edge filter')
plt.show()
def edgeDetect2(imageArray):
derfilt = numpy.array([1.0,-2,1.0],numpy.float32)
ck = signal.cspline2d(imageArray,8.0)
deriv = signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)
return deriv
============================ To smoothen the input raw satellite image or image with general formats using various smoothing filters such as average filter, Weighted average filter, Gaussian smoothing, etc. ============================ created: 17/08/2015 *auhor: [email protected]* ''' from scipy import misc, signal import numpy as np x = misc.lena() x1 = misc.lena().astype(np.float32) w = signal.gaussian(50, 5.0) laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32) derfilt = np.array([1.0, -2, 1.0], dtype=np.float32) ck = signal.cspline2d(x1, 8.0) deriv = (signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(ck, [1], derfilt)) im1 = signal.convolve2d(x1,laplacian,mode='same',boundary='symm') im2 = signal.sepfir2d(x, w, w) plt.figure() plt.subplot(221) plt.imshow(x) plt.title('original image') plt.subplot(222) plt.imshow(im1) plt.title('laplacian filter image') plt.subplot(223) plt.imshow(im2) plt.title('gaussian blurred iamge') plt.subplot(224) plt.imshow(deriv)
def edgeDetect2(imageArray):
derfilt = numpy.array([1.0, -2, 1.0], numpy.float32)
ck = signal.cspline2d(imageArray, 8.0)
deriv = signal.sepfir2d(ck, derfilt, [1]) + signal.sepfir2d(
ck, [1], derfilt)
return deriv
import numpy as np from scipy import signal, misc import matplotlib.pyplot as plt img = misc.lena() splineresult = signal.cspline2d(img, 2.0) laplacian = np.array([[-1,0,1], [-2,0,2], [-1,0,1]], dtype=np.float32) derivative = signal.convolve2d(splineresult,laplacian,mode=’same’,boundary=’symm’) plt.figure() plt.imshow(derivative) plt.title(’Image filtered by spline edge filter’) plt.show()
# Purpose: Image test from examples (header added)
# Date: N/A
# Notes:
# 1) from examples
# Ref: http://docs.scipy.org/doc/scipy/reference/tutorial/signal.html
import numpy as np
from scipy import signal, misc
import matplotlib.pyplot as plt
# import the image -- pre-defined
image = misc.lena().astype(np.float32)
# filter the image
derfilt = np.array([1.0, -2, 1.0], dtype=np.float32)
ck = signal.cspline2d(image, 8.0)
deriv = (signal.sepfir2d(ck, derfilt, [1]) +
signal.sepfir2d(ck, [1], derfilt))
laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32)
deriv2 = signal.convolve2d(ck,laplacian,mode='same',boundary='symm')
# plot the original
plt.figure()
plt.imshow(image)
plt.gray()
plt.title('Original image')
plt.show()
# plot the edge filter
plt.figure()
