def paddingAnswers(answerSheet1, blankSheet1):
numRowsA, numColsA, numBandsA, dataTypeA = ipcv.dimensions(answerSheet1)
numRowsB, numColsB, numBandsB, dataTypeB = ipcv.dimensions(blankSheet1)
print numRowsB, numColsB
if numBandsA == 3:
answerSheet = cv2.cvtColor(answerSheet1, cv.CV_BGR2GRAY)
elif numBandsA == 1:
answerSheet = answerSheet1
if numBandsB == 3:
blankSheet = cv2.cvtColor(blankSheet1, cv.CV_BGR2GRAY)
elif numBandsB == 1:
blankSheet = blankSheet1
pad = numpy.absolute(numRowsA - numColsA)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsA-numColsA) % 2 != 0:
answerSheet = numpy.pad(answerSheet, ((0,0),(pad,pad+1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsA-numColsA) % 2 == 0:
answerSheet = numpy.pad(answerSheet, ((0,0),(pad,pad)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
pad1 = numpy.absolute(numRowsB - numColsB)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsB-numColsB) % 2 != 0:
blankSheet = numpy.pad(blankSheet, ((0,0),(pad1,pad1+1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsA-numColsA) % 2 == 0:
blankSheet = numpy.pad(blankSheet, ((0,0),(pad1,pad1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
return answerSheet, blankSheet
def register(fid1, fid2, fid3, image, blank):
numRows, numCols, numBands, dtype = ipcv.dimensions(blank)
blank1row, blank1col = ipcv.fftCorrelation2(fid1,blank)
blank2row, blank2col = ipcv.fftCorrelation2(fid2,blank)
blank3row, blank3col = ipcv.fftCorrelation2(fid3,blank)
print 'blank1row', blank1row
print 'blank1col', blank1col
print 'blank2row', blank2row
print 'blank2col', blank2col
print 'blank3row', blank3row
print 'blank3col', blank3col
#blankfid1 = numpy.array([738,60])
#blankfid2 = numpy.array([738,542])
#blankfid3 = numpy.array([53,556])
#print blankfid2.shape
fid1row, fid1col = ipcv.fftCorrelation2(fid1,image)
fid2row, fid2col = ipcv.fftCorrelation2(fid2,image)
fid3row, fid3col = ipcv.fftCorrelation2(fid3,image)
print 'fid1row', fid1row
print 'fid1col', fid1col
print 'fid2row', fid2row
print 'fid2col', fid2col
print 'fid3row', fid3row
print 'fid3col', fid3col
numRowsIm, numColsIm, numBandsIm, dataTypeIm = ipcv.dimensions(image)
#Rotated 180 degrees
if fid2row - 25 < fid1row < fid2row + 25 and fid3col - 25 < fid2col < fid3col + 25 and fid2row < numRowsIm/2 and fid3col < numColsIm/2:
print 'hello'
image = numpy.rot90(image, k=2)
cv2.namedWindow('image', cv2.WINDOW_AUTOSIZE)
cv2.imshow('image', image)
fid1row, fid1col = ipcv.fftCorrelation2(fid1,image)
fid2row, fid2col = ipcv.fftCorrelation2(fid2,image)
fid3row, fid3col = ipcv.fftCorrelation2(fid3,image)
blankpts = numpy.array([[blank1row,blank1col],[blank2row,blank2col],[blank3row,blank3col]]).astype(numpy.float32)
#blankpts = numpy.array([blankfid1,blankfid2,blankfid3]).astype(numpy.float32)
#print blankpts.shape
fidpts = numpy.array([[fid1row,fid1col],[fid2row,fid2col],[fid3row,fid3col]]).astype(numpy.float32)
#print fidpts.shape
M = cv2.getAffineTransform(blankpts,fidpts)
regIm = cv2.warpAffine(image,M,(numCols,numRows), borderMode = cv2.BORDER_TRANSPARENT)
cv2.namedWindow('rot',cv2.WINDOW_AUTOSIZE)
cv2.imshow('rot',regIm.astype(numpy.uint8))
cv2.waitKey()
cv2.imwrite('new0001.tif', regIm.astype(numpy.uint8))
return regIm
def fftCorrelation2(fiducial1C, blankSheetC):
numRows, numCols, numBands, dataType = ipcv.dimensions(blankSheetC)
numRows1, numCols1, numBands1, dataType1 = ipcv.dimensions(fiducial1C)
if numBands == 3:
blankSheet = cv2.cvtColor(blankSheetC, cv.CV_BGR2GRAY)
elif numBands == 1:
blankSheet = blankSheetC
if numBands1 == 3:
fiducial1 = cv2.cvtColor(fiducial1C, cv.CV_BGR2GRAY)
elif numBands1 == 1:
fiducial1 = fiducial1C
freqFid1 = numpy.fft.fft2(fiducial1)
freqBlank = numpy.fft.fft2(blankSheet)
magFid1 = numpy.absolute(freqFid1)
magBlank = numpy.absolute(freqBlank)
phaseFid1 = numpy.angle(freqFid1)
phaseBlank = numpy.angle(freqBlank)
correlation = magBlank * magFid1 * numpy.exp(1j * (phaseBlank - phaseFid1))
corrSpat = numpy.fft.ifft2(correlation)
corrSpat = numpy.absolute(numpy.fft.fftshift(corrSpat))
dispCorrSpat = corrSpat / numpy.max(corrSpat)
# print dispCorrSpat.max(), dispCorrSpat.min()
# cv2.namedWindow('corrSpat', cv2.WINDOW_AUTOSIZE)
# cv2.imshow('corrSpat', dispCorrSpat)
# cv2.waitKey()
locationMax = numpy.argmax(corrSpat)
rowLoc, colLoc = numpy.unravel_index(locationMax, (numRows, numCols))
displayIm = cv2.merge((blankSheet, blankSheet, blankSheet))
displayIm[rowLoc - 1:rowLoc+2, colLoc-1:colLoc+2, 2] = 0
displayIm[rowLoc-1:rowLoc+2, colLoc-1:colLoc+2, 0:1] = 255
# cv2.namedWindow('displayIm', cv2.WINDOW_AUTOSIZE)
# cv2.imshow('displayIm', displayIm)
# cv2.waitKey()
'''
fftFid1 = numpy.fft.ifftshift(centerFreqFid1)
fftBlank = numpy.fft.ifftshift(centerFreqBlank)
Fid1 = numpy.fft.ifft2(fftFid1)
Blank = numpy.fft.ifft2(fftBlank)
'''
return rowLoc, colLoc
def circle(blank):
numRows,numCols,numBands, dtype = ipcv.dimensions(blank)
img = cv2.medianBlur(blank,1)
cimg = cv2.cvtColor(img,cv.CV_BGR2GRAY)
img = cv2.cvtColor(img,cv.CV_BGR2GRAY)
mask = np.zeros((numRows,numCols)).astype(np.uint8)
mask[690:773,19:105] = 1
mask[15:100,512:603] = 1
mask[700:780,490:590] = 1
img = img*mask
circles = cv2.HoughCircles(img,cv.CV_HOUGH_GRADIENT,1,40,
param1=50,param2=20,minRadius=7,maxRadius=24)
# print circles
'''
circles = np.uint16(np.around(circles))
for i in circles[0,:]:
# draw the outer circle
cv2.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)
# draw the center of the circle
cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3)
# cv2.imwrite('cimg.tif',cimg)
cv2.imwrite('cimg.tif',cimg)
cv2.namedWindow('detected circles',cv2.CV_WINDOW_AUTOSIZE)
cv2.imshow('detected circles',cimg)
cv2.waitKey(0)
cv2.destroyAllWindows()
'''
return circles
def subtraction(newIm, newIm2): #subtracting images subtracted = numpy.abs(newIm2 - newIm) subtracted = (255 - subtracted) numberRows, numberColumns, numberBands, dataType = ipcv.dimensions(subtracted) return subtracted
def paddingFid1(answerSheet1, blankSheet1):
numRowsA, numColsA, numBandsA, dataTypeA = ipcv.dimensions(answerSheet1)
numRowsB, numColsB, numBandsB, dataTypeB = ipcv.dimensions(blankSheet1)
if numBandsA == 3:
answerSheet = cv2.cvtColor(answerSheet1, cv.CV_BGR2GRAY)
elif numBandsA == 1:
answerSheet = answerSheet1
if numBandsB == 3:
blankSheet = cv2.cvtColor(blankSheet1, cv.CV_BGR2GRAY)
elif numBandsB == 1:
blankSheet = blankSheet1
################FOR LOW RES#####################
#Bottom Left Fiducial
#fiducial1a = blankSheet[717:759,129:171]
fiducial1a = blankSheet[717:759,38:81]
numRowsF1, numColsF1, numBandsF1, dataTypeF1 = ipcv.dimensions(fiducial1a)
numRowsAN, numColsAN, numBandsAN, dataTypeAN = ipcv.dimensions(answerSheet)
print numRowsB, numColsB
print numRowsAN, numColsAN
pad_height1 = numpy.absolute(numRowsAN - numRowsF1)/2.0
pad_width1 = numpy.absolute(numColsAN - numColsF1)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsAN - numRowsF1) % 2 == 0 and (numColsAN - numColsF1) % 2 == 0:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1),(pad_width1, pad_width1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF1) % 2 == 0 and (numColsAN - numColsF1) % 2 != 0:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1),(pad_width1, pad_width1 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF1) %2 != 0 and (numColsAN - numColsF1) % 2 == 0:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1 + 1),(pad_width1, pad_width1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
else:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1 + 1),(pad_width1, pad_width1 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
numRowsF, numColsF, numBandsF, dataTypeF = ipcv.dimensions(fiducial1)
print numRowsF, numColsF
cv2.imwrite('fiducial1.tif', fiducial1)
return fiducial1
def filter_bandreject(img,
radialCenter,
bandwidth,
order=1,
filterShape=ipcv.IPCV_IDEAL):
"""
:purpose:
generates a bandreject filter
:inputs:
img [np.ndarray]
'--> img to generate filter for
radialCenter [np.ndarray]
'--> size of bandpass
bandwidth [np.ndarray]
'--> size of bandpass
order [int]
'--> order for butterworth filter
filterShape [int]
'--> type of filter to apply
:return:
frequency filter [np.ndarray]
"""
try:
dims = ipcv.dimensions(img)
r = dims["rows"]
c = dims["cols"]
u = np.arange(r)
v = np.arange(c)
u, v = np.meshgrid(u, v)
D = np.sqrt((u - r / 2)**2 + (v - c / 2)**2)
if filterShape == ipcv.IPCV_IDEAL:
D[D < (radialCenter - bandwidth / 2)] = 1
D[D >= (radialCenter + bandwidth / 2)] = 1
D[D != 1] = 0
elif filterShape == ipcv.IPCV_GAUSSIAN:
xp = -.5 * ((D**2 - radialCenter**2) / (D * bandwidth))**2
D = 1 - np.exp(xp)
D = np.clip(D, 0, 1)
elif filterShape == ipcv.IPCV_BUTTERWORTH:
denom = 1.0 + ((D * bandwidth) /
(D**2 - radialCenter**2))**(2 * order)
D = 1.0 / denom
return D
except Exception as e:
ipcv.debug(e)
def filter_notchreject(img, notchCenter, notchRadius, order=1, filterShape=ipcv.IPCV_IDEAL): """ :purpose: generates a notch reject filter :inputs: img [np.ndarray] '--> img to generate filter for notchCenter [tuple] '--> notch offset notchRadius '--> radius of the notch filterShape '--> type of filter to apply :return: frequency filter [np.ndarray] """ try: dims = ipcv.dimensions(img) r = dims["rows"] c = dims["cols"] u = np.arange(r) v = np.arange(c) u, v = np.meshgrid(u, v) uCenter = notchCenter[0] vCenter = notchCenter[1] D1 = np.sqrt( (u-r/2-uCenter)**2 + (v-c/2-vCenter)**2 ) D2 = np.sqrt( (u-r/2+uCenter)**2 + (v-c/2+vCenter)**2 ) if filterShape == ipcv.IPCV_IDEAL: H = np.zeros( (r,c) ) H[D1 <= notchRadius] = 1 H[D2 <= notchRadius] = 1 elif filterShape == ipcv.IPCV_GAUSSIAN: xp = -.5 * ( (D1 * D2)/(notchRadius**2) ) H = 1 - np.exp( xp ) elif filterShape == ipcv.IPCV_BUTTERWORTH: denom = 1 + ( (notchRadius**2) / (D1 * D2) )**order H = 1 / denom return H except Exception as e: ipcv.debug(e)
def read_in_files2(pdf,blank):
#convert pdf to tif
# os.system( "convert " + pdf + " answers_%d.tif")
# os.system( "convert " + blank + " orig.tif")
original = cv2.imread('original_300.tif')
numR, numC, numB, dtype = ipcv.dimensions(original)
print original.shape
if numB ==3:
original = cv2.cvtColor(original,cv.CV_BGR2GRAY)
original[original<=200]=0
original[original>200]=255
print original.shape
cv2.imwrite('original300dpi.tif',original )
lis = glob.glob('answers_rot*.tif')
lis = sorted(lis)
print'lis', lis
count = 0
sheets = []
for im in range(len(lis) ):
current = lis[im]
current = cv2.imread(current)
# numRows, numCols, numBands, dtype = scantron.dimensions(current)
numRows, numCols, numBands, dtype = ipcv.dimensions(current)
if numBands ==3:
im = cv2.cvtColor(current,cv.CV_BGR2GRAY)
else:
im = current
if numpy.average(im) > 230:
im[im<=200]=0
im[im>200]=255
cv2.imwrite('blackDPI%04i.tif' %count,im)
else:
cv2.imwrite('blackDPI%04i.tif' %count,im)
sheets.append(im)
count = count +1
return sheets, original
def paddingFid2(answerSheet1, blankSheet1):
numRowsA, numColsA, numBandsA, dataTypeA = ipcv.dimensions(answerSheet1)
numRowsB, numColsB, numBandsB, dataTypeB = ipcv.dimensions(blankSheet1)
if numBandsA == 3:
answerSheet = cv2.cvtColor(answerSheet1, cv.CV_BGR2GRAY)
elif numBandsA == 1:
answerSheet = answerSheet1
if numBandsB == 3:
blankSheet = cv2.cvtColor(blankSheet1, cv.CV_BGR2GRAY)
elif numBandsB == 1:
blankSheet = blankSheet1
################FOR LOW RES#####################
#Bottom Right Fiducial
#fiducial2a = blankSheet[714:762,608:656]
fiducial2a = blankSheet[714:762,517:567]
numRowsF2, numColsF2, numBandsF2, dataTypeF2 = ipcv.dimensions(fiducial2a)
numRowsAN, numColsAN, numBandsAN, dataTypeAN = ipcv.dimensions(answerSheet)
pad_height2 = numpy.absolute(numRowsAN - numRowsF2)/2.0
pad_width2 = numpy.absolute(numColsAN - numColsF2)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsAN - numRowsF2) % 2 == 0 and (numColsAN - numColsF2) % 2 == 0:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2),(pad_width2, pad_width2)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF2) % 2 == 0 and (numColsAN - numColsF2) % 2 != 0:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2),(pad_width2, pad_width2 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF2) %2 != 0 and (numColsAN - numColsF2) % 2 == 0:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2 + 1),(pad_width2, pad_width2)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
else:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2 + 1),(pad_width2, pad_width2 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
cv2.imwrite('fiducial2.tif', fiducial2)
return fiducial2
def rotate(blank, answer):
numRows, numCols, numBands, dtype = ipcv.dimensions(blank)
print 'blank:rows,cols', numRows, numCols
numRowsA, numColsA, numBandsA, dataTypeA = ipcv.dimensions(answer)
print 'answer:rows,cols', numRowsA, numColsA
blankPTS = ipcv.circle(blank)
answerPTS = ipcv.circle(answer)
blankPTS.shape = (3, 3)
answerPTS.shape = (3, 3)
blankPTS = blankPTS[:, 0:2].astype(np.float32)
answerPTS = answerPTS[:, 0:2].astype(np.float32)
M = cv2.getAffineTransform(blankPTS, answerPTS)
image = cv2.warpAffine(answer,M,(numCols,numRows))
cv2.namedWindow('rotated',cv2.WINDOW_AUTOSIZE)
cv2.imshow('rotated',image.astype(np.uint8))
numRowsi, numColsi, numBandsi, dataTypei = ipcv.dimensions(image)
print 'image:rows,cols:', numRowsi, numColsi
cv2.waitKey()
return image
def histogram(im, maxCount=255, ignoreZero=False):
numberRows, numberColumns, numberBands, dataType = ipcv.dimensions(im)
histogram = []
pdf = []
cdf = []
for band in range(numberBands):
h = numpy.int32(
cv2.calcHist([im], [band], None, [maxCount + 1],
[0, maxCount + 1]))
if ignoreZero:
h[0, 0] = 0
histogram.append(h)
pdf.append(histogram[-1] /
numpy.sum(histogram[-1]).astype(numpy.float64))
cdf.append(numpy.cumsum(pdf[-1]))
return numpy.asarray(histogram), numpy.asarray(pdf), numpy.asarray(cdf)
def frequency_filter(im, frequencyFilter, delta=0):
'''
title::
frequency_filter
description::
This method applies a frequency filter to the Fourier transform
of the specified input image.
First, the image dimensions are determined. The 2D inverse Fourier
Transform is taken of the input image, which is then shifted to
center the zero-frequency component to the center of the array.
The transform is then multiplied by the frequency filter.
The result is shifted back and the 2D inverse Fourier transform is
taken. These steps are performed for each band in the input image.
The filtered image is returned as type numpy.complex128.
attributes::
im
Input source image, of type numpy array
frequencyFilter
Mask to be applied to the input image to filter out some
frequencies and preserve others
delta
Bias value added to the filtered image with a default value of 0.
returns::
Filtered image array of type numpy.complex128
author::
Victoria Scholl
'''
# Find the image dimensions
imRows, imColumns, imBands, dataType = ipcv.dimensions(im)
filteredImage = numpy.zeros((imRows,imColumns,imBands))
for band in range(imBands):
imTransform = numpy.fft.fft2(im[:,:,band])
transformCentered = numpy.fft.fftshift(imTransform)
filteredTransform = transformCentered * frequencyFilter
filteredUncentered = numpy.fft.ifftshift(filteredTransform)
filteredImage[:,:,band] = numpy.fft.ifft2(filteredUncentered)
filteredImage += delta
return filteredImage.astype(numpy.complex128)
def fast(src,
differenceThreshold=50,
contiguousThreshold=12,
nonMaximalSuppression=True,
debug=True):
img = src.copy()
circumference = 16
rollArray = [[-3, 0], [-3, -1], [-2, -2], [-1, -3], [0, -3], [1, -3],
[2, -2], [3, -1], [3, 0], [3, 1], [2, 2], [1, 3], [0, 3],
[-1, 3], [-2, 2], [-3, 1]]
dims = ipcv.dimensions(img, 'dict')
allCorners = np.zeros(img.shape)
maximaSum = allCorners
points = np.zeros((dims["rows"], dims["cols"], circumference))
unchanged = np.zeros((dims["rows"], dims["cols"], circumference))
for index, rc in enumerate(rollArray):
points[:, :, index] = np.roll(np.roll(img, rc[0], axis=0),
rc[1],
axis=1)
unchanged[:, :, index] = img
greaterThan = (unchanged - points) > differenceThreshold
lessThan = ((points - unchanged) > differenceThreshold)
for band in range(circumference):
posOverlap = greaterThan[:, :, 0:contiguousThreshold] == 1
negOverlap = lessThan[:, :, 0:contiguousThreshold] == 1
posCornerCheck = np.sum(posOverlap, axis=2)
negCornerCheck = np.sum(negOverlap, axis=2)
allCorners[np.where(posCornerCheck >= contiguousThreshold)] = 1
allCorners[np.where(negCornerCheck >= contiguousThreshold)] = 1
maximaSum = maximaSum + allCorners
greaterThan = np.roll(greaterThan, 1, axis=2)
lessThan = np.roll(lessThan, 1, axis=2)
# if nonMaximalSuppression:
# firstDerivative = np.gradient(maximaSum)
# secondDerivative = np.gradient(maximaSum)
finalCorners = np.clip(allCorners, 0, 1).astype(ipcv.IPCV_8U)
return finalCorners
def map_rotation_scale(src, rotation=0, scale=[1, 1]):
try:
theta = np.radians(rotation)
srcDims = ipcv.dimensions(src, returnType="dictionary")
K = srcDims['cols']
L = srcDims['rows']
W = scale[0]
H = scale[1]
M = K * W
N = L * H
x = K
y = H
dimVector = np.asmatrix([x, y, 1])
# SCALING
scaleMat = np.asarray([[W, 0, 0], [0, H, 0], [0, 0, 1]])
dimVector = dimVector * scaleMat
scaledDims = np.asmatrix(
[np.arange(dimVector[0, 0]),
np.arange(dimVector[0, 1]), 1])
dimVector[0, 0] = dimVector[0, 0] - M / 2
dimVector[0, 1] = N / 2 - dimVector[0, 1]
# ROTATION
sinTheta = np.sin(theta)
cosTheta = np.cos(theta)
rotationMat = np.asmatrix([[cosTheta, -sinTheta, 0.0],
[sinTheta, cosTheta, 0.0], [0., 0., 1.0]])
dimVector = dimVector * rotationMat
#Realigning Image about corner
dimVector[0, 0] = dimVector[0, 0] + K / 2
dimVector[0, 1] = L / 2 - dimVector[0, 1]
return dimVector[0, 0].astype(IPCV_32F), dimVector[0,
1].astype(IPCV_32F)
except Exception as e:
ipcv.debug(e)
def filter_lowpass(img, cutoffFrequency, order=1, filterShape=ipcv.IPCV_IDEAL):
"""
:purpose:
generates a lowpass filter
:inputs:
img [np.ndarray]
'--> img to generate filter for
cutoffFrequency [np.ndarray]
'--> notch offset
order
'--> order for butterworth filter
filterShape
'--> type of filter to apply
:return:
frequency filter [np.ndarray]
"""
try:
dims = ipcv.dimensions(img)
r = dims["rows"]
c = dims["cols"]
u = np.arange(r)
v = np.arange(c)
u, v = np.meshgrid(u, v)
lowPass = np.sqrt((u - r / 2)**2 + (v - c / 2)**2)
if filterShape == ipcv.IPCV_IDEAL:
lowPass[lowPass <= cutoffFrequency] = 1
lowPass[lowPass >= cutoffFrequency] = 0
elif filterShape == ipcv.IPCV_GAUSSIAN:
xp = -1 * (lowPass**2) / (2 * cutoffFrequency**2)
lowPass = np.exp(xp)
lowPass = np.clip(lowPass, 0, 1)
elif filterShape == ipcv.IPCV_BUTTERWORTH:
denom = 1.0 + (lowPass / cutoffFrequency)**(2 * order)
lowPass = 1.0 / denom
return lowPass
except Exception as e:
ipcv.debug(e)
def scan_main(pdf,original):
answerSheets, blankSheet1 = ipcv.read_in_files(pdf,original)
numRowsO, numColsO, numBandsO, dataTypeO = ipcv.dimensions(blankSheet1)
regIm = numpy.zeros((numRowsO,numColsO))
x = 0
for answer in range(len(answerSheets)):
print 'x', x
answerSheet1 = numpy.asarray(answerSheets)
blankSheet1 = numpy.asarray(blankSheet1)
answerSheet = answerSheet1[answer]
blankSheet = blankSheet1
blankSheet2 = cv2.imread('paddedBlank.tif')
fiducial1 = ipcv.paddingFid1(answerSheet, blankSheet)
fiducial2 = ipcv.paddingFid2(answerSheet, blankSheet)
fiducial3 = ipcv.paddingFid3(answerSheet, blankSheet)
#Find points for the centers of the fiducials in the blank sheets
blank1row, blank1col = ipcv.fftCorrelation2(fiducial1,blankSheet)
blank2row, blank2col = ipcv.fftCorrelation2(fiducial2,blankSheet)
blank3row, blank3col = ipcv.fftCorrelation2(fiducial3,blankSheet)
#Find points for the centers of the fiducials in the answer sheets
fid1row, fid1col = ipcv.fftCorrelation2(fiducial1,answerSheet)
fid2row, fid2col = ipcv.fftCorrelation2(fiducial2,answerSheet)
fid3row, fid3col = ipcv.fftCorrelation2(fiducial3,answerSheet)
#Rotate, translate, and Scale
regIm = ipcv.register(fid1row, fid1col, fid2row, fid2col, fid3row, fid3col, blank1row, blank1col, blank2row, blank2col, blank3row, blank3col, answerSheet, blankSheet)
#blank = cv2.imread('paddedBlank.tif')
#Get info
firstName, lastName, UID, additional = ipcv.read_info(blankSheet2, regIm)
#Grading
newIm = ipcv.grading(regIm)
newIm2 = ipcv.answers(regIm)
subtracted = ipcv.subtraction(newIm, newIm2)
count = ipcv.convolution(subtracted, threshold = .9)
percent = ipcv.finalGrade(count)
x = x+1
return percent
def frequency_filter(img, frequencyFilter, delta=0):
"""
:purpose:
applies a frequency filter to an image
:inputs:
img [np.ndarray]
'--> image to be filtered
frequencyFilter [np.ndarray]
'--> filter to apply to image
delta [int]
'--> offset to be added to image at the end
:return:
filtered image
"""
try:
#generating deep copy
img = img.copy()
rows, cols, bands, _ = ipcv.dimensions(img, 't')
#preparing freq and filter arrays
freqFiltered = np.zeros((rows, cols, bands)).astype(ipcv.IPCV_128C)
spatialFiltered = np.zeros((rows, cols, bands)).astype(ipcv.IPCV_128C)
x, y = np.indices((rows, cols))
shifter = (-1)**(x + y)
#making image 3D if necessary for computational ese
if len(img.shape) == 2:
img = img.reshape((rows, cols, 1))
for band in range(bands):
#shifting image band by band
spatial = (img[:, :, band] * shifter).copy()
fft = np.fft.fft2(spatial)
#applying frequency filter
freqFiltered[:, :, band] = fft * frequencyFilter
spatialFiltered[:, :, band] = np.abs(
np.fft.ifft2(freqFiltered[:, :, band])) * shifter
return (spatialFiltered + delta)
except Exception as e:
ipcv.debug(e)
def frequency_filter(img, frequencyFilter, delta=0):
try:
rows, cols, bands, _ = ipcv.dimensions(img, 't')
freqFiltered = np.zeros((rows, cols, bands))
x, y = np.indices((rows, cols))
shifter = np.dstack(
((-1)**(x + y), ) * bands) if bands > 1 else (-1)**(x + y)
src = img.copy() * shifter
fft = np.fft.fft2(src)
frequencyFilter = np.dstack(
(frequencyFilter, ) * bands) if bands > 1 else frequencyFilter
freqFiltered = fft * frequencyFilter
spatialFiltered = np.abs(np.fft.ifft2(freqFiltered))
spatialFiltered = shifter * spatialFiltered
return (spatialFiltered + delta).astype(ipcv.IPCV_8U)
except Exception as e:
ipcv.debug(e)
def paddingFiducials(answerSheet1, blankSheet1):
numRowsA, numColsA, numBandsA, dataTypeA = ipcv.dimensions(answerSheet1)
numRowsB, numColsB, numBandsB, dataTypeB = ipcv.dimensions(blankSheet1)
print numRowsB, numColsB
if numBandsA == 3:
answerSheet = cv2.cvtColor(answerSheet1, cv.CV_BGR2GRAY)
elif numBandsA == 1:
answerSheet = answerSheet1
if numBandsB == 3:
blankSheet = cv2.cvtColor(blankSheet1, cv.CV_BGR2GRAY)
elif numBandsB == 1:
blankSheet = blankSheet1
################FOR HIGH RES####################
#Bottom Left Fiducial
#fiducial1a = blankSheet[2993:3162,167:337]
#Bottom Right Fiducial
#fiducial2a = blankSheet[2980:3174,2163:2356]
#Top Right Fiducial
#fiducial3a = blankSheet[120:323,2214:2416]
################FOR LOW RES#####################
#Bottom Left Fiducial
fiducial1a = blankSheet[717:759,38:81]
#Bottom Right Fiducial
fiducial2a = blankSheet[714:762,517:567]
#Top Right Fiducial
fiducial3a = blankSheet[29:78,531:579]
numRowsF1, numColsF1, numBandsF1, dataTypeF1 = ipcv.dimensions(fiducial1a)
numRowsF2, numColsF2, numBandsF2, dataTypeF2 = ipcv.dimensions(fiducial2a)
numRowsF3, numColsF3, numBandsF3, dataTypeF3 = ipcv.dimensions(fiducial3a)
print numRowsF1, numColsF1
pad = numpy.absolute(numRowsA - numColsA)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsA-numColsA) % 2 != 0:
answerSheet = numpy.pad(answerSheet, ((0,0),(pad,pad+1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsA-numColsA) % 2 == 0:
answerSheet = numpy.pad(answerSheet, ((0,0),(pad,pad)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
numRowsAN, numColsAN, numBandsAN, dataTypeAN = ipcv.dimensions(answerSheet)
pad_height1 = numpy.absolute(numRowsAN - numRowsF1)/2.0
pad_width1 = numpy.absolute(numColsAN - numColsF1)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsAN - numRowsF1) % 2 == 0 and (numColsAN - numColsF1) % 2 == 0:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1),(pad_width1, pad_width1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF1) % 2 == 0 and (numColsAN - numColsF1) % 2 != 0:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1),(pad_width1, pad_width1 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF1) %2 != 0 and (numColsAN - numColsF1) % 2 == 0:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1 + 1),(pad_width1, pad_width1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
else:
fiducial1 = numpy.pad(fiducial1a,((pad_height1, pad_height1 + 1),(pad_width1, pad_width1 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
print 'fiducial1 shape:', fiducial1.shape
print 'answerSheet shape:', answerSheet.shape
pad_height2 = numpy.absolute(numRowsAN - numRowsF2)/2.0
pad_width2 = numpy.absolute(numColsAN - numColsF2)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsAN - numRowsF2) % 2 == 0 and (numColsAN - numColsF2) % 2 == 0:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2),(pad_width2, pad_width2)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF2) % 2 == 0 and (numColsAN - numColsF2) % 2 != 0:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2),(pad_width2, pad_width2 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF2) %2 != 0 and (numColsAN - numColsF2) % 2 == 0:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2 + 1),(pad_width2, pad_width2)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
else:
fiducial2 = numpy.pad(fiducial2a,((pad_height2, pad_height2 + 1),(pad_width2, pad_width2 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
print 'fiducial2 shape:', fiducial2.shape
print 'answerSheet shape:', answerSheet.shape
pad_height3 = numpy.absolute(numRowsAN - numRowsF3)/2.0
pad_width3 = numpy.absolute(numColsAN - numColsF3)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsAN - numRowsF3) % 2 == 0 and (numColsAN - numColsF3) % 2 == 0:
fiducial3 = numpy.pad(fiducial3a,((pad_height3, pad_height3),(pad_width3, pad_width3)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF3) % 2 == 0 and (numColsAN - numColsF3) % 2 != 0:
fiducial3 = numpy.pad(fiducial3a,((pad_height3, pad_height3),(pad_width3, pad_width3 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsAN - numRowsF3) %2 != 0 and (numColsAN - numColsF3) % 2 == 0:
fiducial3 = numpy.pad(fiducial3a,((pad_height3, pad_height3 + 1),(pad_width3, pad_width3)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
else:
fiducial3 = numpy.pad(fiducial3a,((pad_height3, pad_height3 + 1),(pad_width3, pad_width3 + 1)), 'constant', constant_values = ((maxCount, maxCount),(maxCount,maxCount)))
print 'fiducial3 shape:', fiducial3.shape
print 'answerSheet shape:', answerSheet.shape
pad1 = numpy.absolute(numRowsB - numColsB)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsB-numColsB) % 2 != 0:
blankSheet = numpy.pad(blankSheet, ((0,0),(pad1,pad1+1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsA-numColsA) % 2 == 0:
blankSheet = numpy.pad(blankSheet, ((0,0),(pad1,pad1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
#cv2.imwrite('paddedBlank.tif', blankSheet)
fiducials = numpy.dstack([fiducial1, fiducial2, fiducial3])
print fiducials.shape
return fiducials, answerSheet, blankSheet
def filter_notchreject(im, notchCenter, notchRadius, order=1, filterShape=ipcv.IPCV_IDEAL):
'''
title::
filter_notchreject
description::
This method creates a frequency filter that rejects
specific frequencies supplied by the user.
User must specify the coordinates of the frequencies to be blocked
(in the form of a list of tuples (u,v)), each with a corresponding
radius value (in the list, notchRadius)
A mask is created to preserve the other frequencies in the image.
First, the dimensions of the input image are determined.
Then an array of ones is created with the same dimensions to serve
as the notchreject filter.
The dist method is used to return a distance value at each pixel
location (measured from the corner of the image). This dist filter
is then rolled twice in both the x and y dimensions to center the
values about the center of the array.
The specified filter shape is then created based on the use's input.
The filter is returned as type numpy.float64. The filter is ready to be
multiplied with a centered fourier transform of the input image.
attributes::
im
Input image of tpye numpy nd array, used to get the dimensions for
the frequency filter.
notchCenter
List of tuples with coordinates (u,v) corresponding to frequencies
in the fourier transform to be rejected.
notchRadius
The size of the notch to be created at each (u,v) coordinate.
order
Integer value that influences the shape of the butterworth filter.
The higher the order, the more the butterworth filter resembles an
ideal filter.
filterShape
Options for the shape of the filter, specified in the constants.py
file in the ipcv directory. The different shapes will attenuate
the frequencies differently.
IDEAL
Ideal shaped filter STRICTLY blocks ALL frequencies within the
specified notch sizes and locations. Binary mask.
BUTTERWORTH
Gaussian-like shaped filter that can be tuned based on the order
parameter.
GAUSSIAN
Gaussian-shaped filter.
returns::
notchreject filter - numpy array with the same dimensions as the input image
that will preserve all frequencies outside of the specified notches.
author::
Victoria Scholl
'''
# get image dimensions, which dictate the filter dimensions
imRows, imColumns, imBands, dataType = ipcv.dimensions(im)
notchRejectFilter = numpy.ones([imRows,imColumns])
# use ipcv.dist to generate an array with distances from the corner pixel.
# roll twice to center the array (distances measured from center)
distFilter = ipcv.dist( ( imRows, imColumns ) )
distFilter = numpy.roll(numpy.roll(distFilter, imRows/2, axis=0), imColumns/2, axis=1)
for center in range(len(notchCenter)):
# D1 is the distance from the notch
# D2 is the distance from the notch's conjugate
D1 = numpy.roll(numpy.roll(distFilter,imRows/2 - notchCenter[center][0],axis=1),imColumns/2-notchCenter[center][1],axis=0)
D2 = numpy.roll(numpy.roll(distFilter,imRows/2 + notchCenter[center][0],axis=1),imColumns/2+notchCenter[center][1],axis=0)
if filterShape == ipcv.IPCV_IDEAL:
notchRejectFilter[ D1 <= notchRadius[center] ] = 0
notchRejectFilter[ D2 <= notchRadius[center] ] = 0
elif filterShape == ipcv.IPCV_BUTTERWORTH: # butterworth equation
# To avoid a div by 0 error
productOfDs = D1 * D2
productOfDs[productOfDs == 0] == 1e-10
nextNotchRejectFilter = 1 / ( 1 + (( notchRadius[center]**2 ) / (productOfDs)) ** order)
notchRejectFilter = notchRejectFilter * nextNotchRejectFilter
else: # Third filter type option is Gaussian
nextNotchRejectFilter = 1 - numpy.exp( -0.5 * (D1 * D2) / ( notchRadius[center]**2) )
notchRejectFilter = notchRejectFilter * nextNotchRejectFilter
notchRejectFilter = numpy.roll(numpy.roll(notchRejectFilter, imRows/2, axis=0), imColumns/2, axis=1)
return notchRejectFilter.astype(numpy.float64)
def filter_lowpass(im, cutoffFrequency, order=1, filterShape=ipcv.IPCV_IDEAL):
'''
title::
filter_lowpass
description::
This method creates a lowpass filter to be applied to the
centered fourier transform of the input image.
First, the dimensions of the input image are determined.
Then an array of zeros is created with the same dimensions to serve
as the lowpass filter.
The dist method is used to return a distance value at each pixel
location (measured from the corner of the image). This dist filter
is then rolled twice in both the x and y dimensions to center the
values about the center of the array.
The specified filter shape is then created based on the use's input.
The filter is returned as type numpy.float64; ready to be applied to
the input image using the frequency_filter.py method.
attributes::
im
Input image of tpye numpy nd array, used to get the dimensions for
the frequency filter.
cutoffFrequency
Frequency of type integer above which to attentuate higher frequencies
(frequencies lower than the cutoff value will be preserved).
order
Integer value that influences the shape of the butterworth filter.
The higher the order, the more the butterworth filter resembles an
ideal filter.
filterShape
Options for the shape of the filter, specified in the constants.py
file in the ipcv directory. The different shapes will attenuate
the higher frequencies differently.
IDEAL
Ideal shaped filter STRICTLY blocks ALL frequencies greater than
the cutoffFrequency. Binary mask.
BUTTERWORTH
Gaussian-like shaped filter that can be tuned based on the order
parameter.
GAUSSIAN
Gaussian-shaped filter.
returns::
lowpass filter - numpy array with the same dimensions as the input image
author::
Victoria Scholl
'''
# get image dimensions, which dictate the filter dimensions
imRows, imColumns, imBands, dataType = ipcv.dimensions(im)
lowPassFilter = numpy.zeros([imRows,imColumns])
# use ipcv.dist to generate an array with distances from the corner pixel.
# roll twice to center the array (distances measured from center)
distFilter = ipcv.dist( ( imRows, imColumns ) )
distFilter = numpy.roll(numpy.roll(distFilter, imRows/2, axis=0),
imColumns/2, axis=1)
if filterShape == ipcv.IPCV_IDEAL:
# threshold dist array. distances < cutoff freq set to 1, else to 0.
lowPassFilter[ distFilter <= cutoffFrequency ] = 1
lowPassFilter[ distFilter > cutoffFrequency ] = 0
elif filterShape == ipcv.IPCV_BUTTERWORTH: # butterworth equation
lowPassFilter = 1 / ( 1 + (( distFilter/cutoffFrequency)**(2*order)))
else: # Third filter type option is Gaussian
lowPassFilter = numpy.exp(-1*(distFilter**2)/(2.0*cutoffFrequency**2))
return lowPassFilter.astype(numpy.float64)
def fftCorrelation(fiducial1C, fiducial2C, fiducial3C, blankSheetC):
numRows, numCols, numBands, dataType = ipcv.dimensions(blankSheetC)
numRows1, numCols1, numBands1, dataType1 = ipcv.dimensions(fiducial1C)
numRows2, numCols2, numBands2, dataType2 = ipcv.dimensions(fiducial2C)
numRows3, numCols3, numBands3, dataType3 = ipcv.dimensions(fiducial3C)
print 'blank bands:', numBands
print 'fiducial1 bands:', numBands1
print 'fiducial2 bands:', numBands2
print 'fiducial3 bands:', numBands3
if numBands == 3:
blankSheet = cv2.cvtColor(blankSheetC, cv.CV_BGR2GRAY)
elif numBands == 1:
blankSheet = blankSheetC
if numBands1 == 3:
fiducial1 = cv2.cvtColor(fiducial1C, cv.CV_BGR2GRAY)
elif numBands2 == 1:
fiducial1 = fiducial1C
if numBands2 == 3:
fiducial2 = cv2.cvtColor(fiducial2C, cv.CV_BGR2GRAY)
elif numBands2 == 1:
fiducial2 = fiducial2C
if numBands3 == 3:
fiducial3 = cv2.cvtColor(fiducial3C, cv.CV_BGR2GRAY)
elif numBands3 == 1:
fiducial3 = fiducial3C
freqFid1 = numpy.fft.fft2(fiducial3)
freqBlank = numpy.fft.fft2(blankSheet)
freqFid1 = numpy.fft.fftshift(freqFid1)
freqBlank = numpy.fft.fftshift(freqBlank)
magFid1 = numpy.absolute(freqFid1)
magBlank = numpy.absolute(freqBlank)
#Takes the log of the magnitude frequency image in order to diplay it
logMagnitude = numpy.log10(magFid1)
#Scales the image in order to display
scaledIm = logMagnitude/numpy.max(logMagnitude)
scaledIm2 = scaledIm * 255
intScaledIm2 = scaledIm2.astype(numpy.uint8)
cv2.namedWindow('fftFiducial', cv2.WINDOW_AUTOSIZE)
cv2.imshow('fftFiducial', intScaledIm2)
cv2.waitKey()
cv2.imwrite('fftFiducial.tif', intScaledIm2)
#Takes the log of the magnitude frequency image in order to diplay it
logMagnitude1 = numpy.log10(magBlank)
#Scales the image in order to display
scaledIm1 = logMagnitude/numpy.max(logMagnitude1)
scaledIm21 = scaledIm1 * 255
intScaledIm21 = scaledIm21.astype(numpy.uint8)
cv2.namedWindow('fftBlank', cv2.WINDOW_AUTOSIZE)
cv2.imshow('fftBlank', intScaledIm21)
cv2.waitKey()
cv2.imwrite('fftBlank.tif', intScaledIm21)
phaseFid1 = numpy.angle(freqFid1)
phaseBlank = numpy.angle(freqBlank)
correlation = magBlank * magFid1 * numpy.exp(1j * (phaseBlank - phaseFid1))
corrSpat = numpy.fft.ifft2(correlation)
corrSpat = numpy.absolute(numpy.fft.fftshift(corrSpat))
dispCorrSpat = corrSpat / numpy.max(corrSpat)
print dispCorrSpat.max(), dispCorrSpat.min()
cv2.namedWindow('corrSpat', cv2.WINDOW_AUTOSIZE)
cv2.imshow('corrSpat', dispCorrSpat)
cv2.waitKey()
locationMax = numpy.argmax(corrSpat)
rowLoc, colLoc = numpy.unravel_index(locationMax, (numRows, numCols))
displayIm = cv2.merge((blankSheet, blankSheet, blankSheet))
print rowLoc, colLoc
displayIm[rowLoc - 2:rowLoc+3, colLoc-2:colLoc+3, 2] = 0
displayIm[rowLoc-2:rowLoc+3, colLoc-2:colLoc+3, 0:1] = 255
cv2.namedWindow('displayIm', cv2.WINDOW_AUTOSIZE)
cv2.imshow('displayIm', displayIm)
cv2.waitKey()
cv2.imwrite('dotsFid3.tif', displayIm)
'''
fftFid1 = numpy.fft.ifftshift(centerFreqFid1)
fftBlank = numpy.fft.ifftshift(centerFreqBlank)
Fid1 = numpy.fft.ifft2(fftFid1)
Blank = numpy.fft.ifft2(fftBlank)
'''
return rowLoc, colLoc
def histogram_enhancement(im, etype='linear2', target=None, maxCount=255): """ Title: histogram_enhancement Author: Molly Hill, [email protected] Description: Returns given image quantized at set number of levels, using either a uniform or IGS method. Attributes: im - ndarray, can be grayscale or color of any size etype - enhancement type, of the following options: - 'linearX' where X is an integer percent of the area to be clipped/crushed with contrast increas - 'match' where the image is to be matched to a provided target image or PDF - 'equalize' where the image's histogram is to be spread equally across digital count target - if etype = 'match', then target must be provided as either an image (3D array) or PDF (1D array) maxCount - maximum code value of pixel; must be positive integer Requires: histogram.py, author: Carl Salvaggio dimensions.py, author: Carl Salvaggio """ if maxCount <= 0 or type(maxCount) is not int: msg = "Specified maximum digital count must be a positive integer." raise ValueError(msg) if type(im) is not numpy.ndarray: msg = "Specified image type must be ndarray." raise TypeError(msg) if etype[:6] != 'linear' and etype != 'match' and etype != 'equalize': msg = "Enhancement types available are linear, match, and equalize. Defaulting to linear2." print(msg) if etype == 'match': if type(target) == None: etype = 'equalize' msg = "If using match, target must be provided." print(msg) elif target.ndim !=1 and target.ndim !=2: print(target.ndim) msg = "Provided target must be PDF (1-D array) or image (3-D array)" raise TypeError(msg) enhIm = numpy.copy(im) srcCDF = ipcv.histogram(enhIm)[2] DCout = [] tgtCDF = [] tgtPDF = target if etype == 'match' or etype == 'equalize': if etype == 'match' and target.ndim != 1: #is image tgtCDF = ipcv.histogram(target)[2][0] #create CDF of target, currently does red channel if color else: #equalize or PDF passed in as target for matching if etype == 'equalize': tgtPDF = numpy.ones(maxCount+1)/(maxCount+1) tgtCDF = numpy.cumsum(tgtPDF) #convert PDF to CDF for i in range(ipcv.dimensions(srcCDF)[1]): #createLUT difference = numpy.fabs(numpy.subtract(tgtCDF,srcCDF[0][i])) #red channel only DCout.extend([int(maxCount*tgtCDF[numpy.argmin(difference)])]) for j in range(im.size): #apply LUT enhIm.flat[j] = DCout[enhIm.flat[j]] #uses original code value to assign new output from LUT else: #linear pct = (int(etype[6:])/2) / 100 #extract percent from etype and halve difference = numpy.fabs(numpy.subtract(srcCDF[0],pct)) DCmin = numpy.argmin(difference) difference = numpy.fabs(numpy.subtract(srcCDF[0],(1-pct))) DCmax = numpy.argmin(difference) slope = (maxCount+1)/(DCmax-DCmin) intercept = -slope * DCmin for j in range(enhIm.size): px = enhIm.flat[j] if px >= DCmax: px = maxCount elif px <= DCmin: px = 0 else: px = slope * px + intercept enhIm.flat[j] = int(px) return enhIm
def convolution(subtracted, threshold = .9):
numberRows, numberColumns, numberBands, dataType = ipcv.dimensions(subtracted)
answerRegion = numpy.zeros((300, 60))
kernel = numpy.zeros((12,12))
neighborhood = numpy.ones((12, 60))
answerRegion = answerRegion * 1.0
kernel = kernel * 1.0
answerRegion = subtracted[numberRows-407:numberRows-107, numberColumns-540:numberColumns-480]
cv2.imshow('region', answerRegion)
numberRowsR, numberColumnsR, numberBandsR, dataType = ipcv.dimensions(answerRegion)
if numberBandsR == 3:
answerRegion = cv2.cvtColor(answerRegion,cv.CV_BGR2GRAY)
answerRegion[answerRegion <= 200] = 0
answerRegion[answerRegion > 200] = 255
count = 0
#cv2.namedWindow('hood', cv2.WINDOW_AUTOSIZE)
#for row in range(numberRowsR):
for row in range(25):
row = row * 12
neighborhood = answerRegion[row : row + 12, 0:numberColumnsR]
#cv2.imshow('hood', neighborhood)
#cv2.waitKey(300)
#print neighborhood.shape
if numpy.mean(neighborhood) >= 254:
count = count + 1
#print count
else:
count = count + 0
row = row + 12
#print count
count1 = count
#column 2
answerRegion = subtracted[numberRows-407:numberRows-107, numberColumns-464:numberColumns-404]
cv2.imshow('region', answerRegion)
cv2.waitKey()
numberRowsR, numberColumnsR, numberBandsR, dataType = ipcv.dimensions(answerRegion)
if numberBandsR == 3:
answerRegion = cv2.cvtColor(answerRegion,cv.CV_BGR2GRAY)
answerRegion[answerRegion <= 200] = 0
answerRegion[answerRegion > 200] = 255
count = 0
#cv2.namedWindow('hood', cv2.WINDOW_AUTOSIZE)
for row in range(25):
row = row * 12
neighborhood = answerRegion[row : row + 12, 0:numberColumnsR]
#cv2.imshow('hood', neighborhood)
#cv2.waitKey(300)
#print neighborhood.shape
if numpy.mean(neighborhood) >= 254:
count = count + 1
#print count
else:
count = count + 0
row = row + 12
#print count
count2 = count
count = count1 + count2
#print count
return count
def answers(key):
#ANSWER KEY
numberRows, numberColumns, numberBands, dataType = ipcv.dimensions(key)
neighborhood = numpy.zeros((12, 12))
#For questions 1-25 (first column)
column = 72
newIm2 = key
for answer in range(5):
row = 385
for question in range(25):
neighborhood = key[row : row + 12, column : column + 12]
if numpy.mean(neighborhood) < 190:
newIm2[row : row + 12, column : column + 12] = 0
else:
newIm2[row : row + 12, column : column + 12] = 255
row = row + 12
column = column + 12
#For questions 26-50 (second column)
column = 148
newIm2 = key
for answer in range(5):
row = 385
for question in range(25):
neighborhood = key[row : row + 12, column : column + 12]
if numpy.mean(neighborhood) < 190:
newIm2[row : row + 12, column : column + 12] = 0
else:
newIm2[row : row + 12, column : column + 12] = 255
row = row + 12
column = column + 12
#For questions 51-75 (third column)
column = 225
newIm2 = key
for answer in range(5):
row = 385
for question in range(25):
neighborhood = key[row : row + 12, column : column + 12]
if numpy.mean(neighborhood) < 190:
newIm2[row : row + 12, column : column + 12] = 0
else:
newIm2[row : row + 12, column : column + 12] = 255
row = row + 12
column = column + 12
#For questions 76-100 (fourth column)
column = 305
newIm2 = key
for answer in range(5):
row = 385
for question in range(25):
neighborhood = key[row : row + 12, column : column + 12]
if numpy.mean(neighborhood) < 190:
newIm2[row : row + 12, column : column + 12] = 0
else:
newIm2[row : row + 12, column : column + 12] = 255
row = row + 12
column = column + 12
#For questions 101-125 (fifth column)
column = 385
newIm2 = key
for answer in range(5):
row = 385
for question in range(25):
neighborhood = key[row : row + 12, column : column + 12]
if numpy.mean(neighborhood) < 190:
newIm2[row : row + 12, column : column + 12] = 0
else:
newIm2[row : row + 12, column : column + 12] = 255
row = row + 12
column = column + 12
#For questions 125-150 (last column)
column = 465
newIm2 = key
for answer in range(5):
row = 385
for question in range(25):
neighborhood = key[row : row + 12, column : column + 12]
if numpy.mean(neighborhood) < 190:
newIm2[row : row + 12, column : column + 12] = 0
else:
newIm2[row : row + 12, column : column + 12] = 255
row = row + 12
column = column + 12
return newIm2
def read_info(sheets, original):
# original = cv2.cvtColor(original,cv.CV_BGR2GRAY)
# sheets = cv2.cvtColor(sheets,cv.CV_BGR2GRAY)
hood = numpy.ones((12,12))
numRows, numCols, numBands, dtype = ipcv.dimensions(original)
# original = numpy.absolute(original - sheets)
# cv2.namedWindow('orig',cv2.WINDOW_AUTOSIZE)
# cv2.imshow('orig', original)
# cv2.waitKey()
lastName = []
hcol = 12
hrow = 12
col = 72
# col =162
cv2.namedWindow('hood')
letter = numpy.zeros((26,1))
for C in range(11):
row = 51
for L in range(26):
hood = original[row:row + hrow,col:col +hcol]
if numpy.mean(hood) < 185:
total = 0
else:
total = 255
# print 'total', total
# total = numpy.sum(hood)
letter[L] = total
row = row +hrow
if L == 6:
row = row-1
# print 'row',row
# cv2.imshow('hood',hood)
# cv2.waitKey(600)
val = (letter[numpy.argmin(letter)])
#val = (letter[numpy.argmin(letter)])
#print 'lastval',val
mean = numpy.mean(letter)
#print 'mean', mean
#if mean - 1 < val < mean + 1:
if val > 0:
#if mean - 9000 < val < mean + 9000:
# if mean - 5900 < val < mean + 5900:
lastName.append(chr(32))
else:
lastName.append(chr(numpy.argmin(letter)+65))
col = col + hcol
print 'lastname',lastName
'''
hood = numpy.ones((9,10))
numRows, numCols, numBands, dtype = ipcv.dimensions(original)
# original = numpy.absolute(original - sheets)
# cv2.namedWindow('orig',cv2.WINDOW_AUTOSIZE)
# cv2.imshow('orig', original)
# cv2.waitKey()
lastName = []
drow = 3
dcol = 2
hcol = 10
hrow = 9
# col = 72
col =162
cv2.namedWindow('hood')
letter = numpy.zeros((26,1))
for C in range(11):
row = 51
for L in range(26):
hood = original[row:row + hrow,col:col +hcol]
# print 'hood', numpy.mean(hood)
# if numpy.mean(hood) < 180:
# im,threshold = ipcv.otsu_threshold(hood,255, verbose=False)
#print 'thresh', threshold
# if numpy.mean(hood) < threshold:
# total = 0
# else:
# total = 255
total = numpy.sum(hood)
letter[L] = total
row = row + drow +hrow
if L == 6:
row = row-1
# print 'row',row
# cv2.imshow('hood',hood)
# cv2.waitKey(600)
val = (letter[numpy.argmin(letter)])
val = (letter[numpy.argmin(letter)])
print 'lastval',val
mean = numpy.mean(letter)
print 'mean', mean
# if mean - 3 < val < mean + 3:
#if mean - 9000 < val < mean + 9000:
if mean - 5900 < val < mean + 5900:
lastName.append(chr(32))
else:
lastName.append(chr(numpy.argmin(letter)+65))
col = col + hcol + dcol
print 'lastname',lastName
# print 'letter', letter
# print 'row',row
# print 'col',col
'''
hood = numpy.ones((9,10))
firstName = []
drow = 3
dcol = 2
hcol = 10
hrow = 9
# hcol = 12
# hrow = 12
col = 235
cv2.namedWindow('hood')
letter = numpy.zeros((26,1))
for C in range(9):
row = 51
for L in range(26):
hood = original[row:row + hrow,col:col +hcol]
# # if numpy.mean(hood) < 185:
# if (numpy.mean(hood)< 175 and numpy.mean(hood) <185):
# # if numpy.mean(hood) < 175:
# total = 0
# else:
# total = 255
total = numpy.sum(hood)
letter[L] = total
# row = row +hrow
row = row +hrow + drow
if L == 6:
row = row-1
#cv2.imshow('hood',hood)
# cv2.waitKey(600)
val = (letter[numpy.argmin(letter)])
#print 'location', numpy.argmin(letter)
#print 'firstval',val
mean = numpy.mean(letter)
# print'mean', mean
if mean - 9000 < val < mean + 9000:
# if val > 0:
firstName.append(chr(32))
else:
firstName.append(chr(numpy.argmin(letter)+65))
# col = col + hcol
col = col + hcol + dcol
print 'firstname',firstName
# UID = numpy.zeros((9))
UID = []
drow = 3
dcol = 2
hcol = 10
hrow = 9
col = 370
cv2.namedWindow('hood')
letter = numpy.zeros((10,1))
for C in range(9):
row = 51
for L in range(10):
hood = original[row:row + hrow,col:col +hcol]
total = numpy.sum(hood)
letter[L] = total
row = row + drow +hrow
if L == 6:
row = row-1
mean = numpy.mean(letter)
val = (letter[numpy.argmin(letter)])
if mean - 5000 < val < mean + 5000:
UID.append(chr(32))
else:
UID.append(numpy.argmin(letter))
# UID[C] = numpy.argmax(letter)
col = col + hcol + dcol
print 'UID',UID
#additional = numpy.zeros((9))
additional = []
drow = 3
dcol = 2
hcol = 10
hrow = 9
col = 370
#cv2.namedWindow('hood')
letter = numpy.zeros((10,1))
for C in range(9):
row = 218
for L in range(10):
hood = original[row:row + hrow,col:col +hcol]
total = numpy.sum(hood)
letter[L] = total
row = row + drow +hrow
# if L == 6:
# row = row-1
mean = numpy.mean(letter)
val = (letter[numpy.argmin(letter)])
if mean - 8000 < val < mean + 8000:
UID.append(chr(32))
else:
additional.append(numpy.argmin(letter))
# additional[C] = numpy.argmax(letter)
col = col + hcol + dcol
print 'add', additional
return lastName,firstName,UID,additional
def otsu_threshold(img, maxCount=255, verbose=False):
"""
:NAME:
otsu_threshold
:PURPOSE:
this method generates a binary thresholded image based off of
Otsu's class discrimination method
:CATEGORY:
ipcv -- object recognition and thresholding tool
:CALLING SEQUENCE:
quantizedImage = quantize(img = inputImage,\
maxCount = max display level\
verbose = true or false)
:INPUTS:
img
[numpy.ndarray] input image to be quanitized
maxCount
[int] maximum pixel value in the output array
verbose
[boolean] whether or not to graph the histogram
:RETURN VALUE:
tuple containing:
returnTuple[0] -- binary numpy.array of the same shape as the input image
returnTuple[1] -- threshold determined by otsu's method
:ERROR CHECKING:
TypeError
ValueError
RuntimeError
:REQUIRES:
np
sys.exc_info
os.path.split
ipcv
:MODIFICATION HISTORY:
Engineer: Jeff Maggio
08/25/16: otsu code
"""
###################### BEGIN ERROR CHECKING #######################
if isinstance(img,np.ndarray) == True:
dims = ipcv.dimensions(img,"dictionary")
if dims["bands"] == 1:
if len(img.shape) == 3:
#making the array two dimensional if it only has 1 band
img = img.reshape(dims['rows'],dims['cols'])
else:
print("")
print("input 'img' must be grayscale or single-banded")
print("")
raise RuntimeError
else:
print("")
print("input 'img' must be a valid 2 dimensional numpy array, currently {0}".format(type(img)))
print("")
raise TypeError
if isinstance(maxCount,int) == False:
print("")
print("input 'maxCount' must be an int, currently {0}".format(type(maxCount)))
print("")
raise TypeError
elif maxCount <= 0:
print("")
print("input 'maxCount' must be greater than zero")
print("")
raise ValueError
if isinstance(verbose,bool) == False:
print("")
print("input 'verbose' must be integer boolean , currently {0}".format(verbose))
print("")
raise TypeError
###################### END ERROR CHECKING #######################
try:
numberCounts = maxCount + 1
#generating the pdf and cdf
hist,pdf,cdf = ipcv.histogram(img,histSize=numberCounts,ranges=[0,numberCounts])
meanLevelArray = np.cumsum( np.arange(0,numberCounts) * pdf )
muTotal = meanLevelArray[-1]
sigmaSquaredBValues = np.zeros(numberCounts)
startingK = np.where(cdf>0.0)[0][0]
endingK = np.where(cdf<1.0)[0][-1]
for k in range(startingK, endingK):
muK = meanLevelArray[k]
omegaK = cdf[k]
sigmaSquaredB = ( ( (muTotal * omegaK) - muK )**2 ) / ( omegaK * (1-omegaK) )
sigmaSquaredBValues[k] = sigmaSquaredB
threshold = np.argmax(sigmaSquaredBValues)
LUT = np.zeros( numberCounts )
LUT[threshold+1:] = 1
img = LUT[img]
if verbose == True:
values = (pdf,)
colors = ('r',)
filename = "image_pdf_wOtsu.eps"
thresholdMarker = (threshold,)
labels = ("pdf",)
graph = ipcv.quickplot(values,colors,labels,filename=filename,verticalMarkers=thresholdMarker,\
xLabel="Digital Counts",yLabel="probability",display=False)
graph.annotate("otsu's Threshold", xy=(threshold, .01), xytext=(3, 1.5),arrowprops=dict(facecolor='black', shrink=0.05))
graph.show()
return img.astype(np.uint8), threshold
except Exception as e:
print("===============================================================")
exc_type, exc_obj, tb = exc_info()
fname = split(tb.tb_frame.f_code.co_filename)[1]
print("\r\nfile: {0}\r\n\r\nline: {1} \r\n\r\n{2}\r\n\r\n".format(fname,tb.tb_lineno,exc_obj,e))
print("===============================================================")
numberColumns = dimensions[1]
if len(dimensions) == 3:
numberBands = dimensions[2]
else:
numberBands = 1
dataType = im.dtype
return numberRows, numberColumns, numberBands, dataType
if __name__ == '__main__':
import cv2
import ipcv
import os.path
home = os.path.expanduser('~')
path = os.path.join(home, 'src', 'python', 'examples', 'data')
filename = os.path.join(path, 'lenna.tif')
filename = os.path.join(path, 'redhat.ppm')
filename = os.path.join(path, 'crowd.jpg')
filename = os.path.join(path, 'checkerboard.tif')
im = cv2.imread(filename, cv2.IMREAD_UNCHANGED)
print('Filename = {0}'.format(filename))
print('Data type = {0}'.format(type(im)))
print('Image shape = {0}'.format(im.shape))
print('Image size = {0}'.format(im.size))
print(ipcv.dimensions(im))
def read_info2(sheets, original):
hood = numpy.ones((39,37))
numRows, numCols, numBands, dtype = ipcv.dimensions(original)
# original = ((original*1.0) - (sheets*1.0)) *255
original = ((original*1.0) - (sheets*1.0)) *255
# original = original.astype(numpy.unit8)
# cv2.namedWindow('orig',cv2.WINDOW_AUTOSIZE)
# cv2.imshow('orig', original)
# cv2.waitKey()
lastName = []
drow = 11
dcol = 13
hcol = 37
hrow = 39
col = 303
cv2.namedWindow('hood')
letter = numpy.zeros((26,1))
for C in range(11):
row = 211
for L in range(26):
hood = original[row:row + hrow,col:col +hcol]
total = numpy.sum(hood)
letter[L] = total
row = row + drow +hrow
if L == 1 or L == 6 or L == 12 or L ==17 or L == 23:
row = row-1
print 'row',row
cv2.imshow('hood',hood)
cv2.waitKey(600)
val = (letter[numpy.argmin(letter)])
print 'lastval',val
mean = numpy.mean(letter)
print 'mean',mean
# if mean - 3 < val < mean + 3:
# lastName.append(chr(32))
if mean - 9000 < val < mean + 9000:
lastName.append(chr(32))
else:
lastName.append(chr(numpy.argmin(letter)+65))
col = col + hcol + dcol
print 'lastname',lastName
# print 'letter', letter
# print 'row',row
# print 'col',col
firstName = []
drow = 11
dcol = 13
hcol = 37
hrow = 39
col = 983
cv2.namedWindow('hood')
letter = numpy.zeros((26,1))
for C in range(9):
row = 211
for L in range(26):
hood = original[row:row + hrow,col:col +hcol]
total = numpy.sum(hood)
letter[L] = total
row = row + drow +hrow
# if L == 6:
if L == 1 or L == 6 or L == 12 or L ==17 or L == 23:
row = row-1
print 'row',row
cv2.imshow('hood',hood)
cv2.waitKey(300)
val = (letter[numpy.argmin(letter)])
mean = numpy.mean(letter)
if mean - 9000 < val < mean + 9000:
firstName.append(chr(32))
else:
firstName.append(chr(numpy.argmin(letter)+65))
# firstName[C] = numpy.argmax(letter)
col = col + hcol + dcol
print 'firstname',firstName
'''
'''
# UID = numpy.zeros((9))
UID = []
drow = 11
dcol = 13
hcol = 37
hrow = 39
col = 1545
cv2.namedWindow('hood')
letter = numpy.zeros((10,1))
for C in range(9):
row = 211
for L in range(10):
hood = original[row:row + hrow,col:col +hcol]
total = numpy.sum(hood)
letter[L] = total
row = row + drow +hrow
# if L == 6:
if L == 1 or L == 6 or L == 12 or L ==17 or L == 23:
row = row-1
print 'row',row
cv2.imshow('hood',hood)
cv2.waitKey(300)
mean = numpy.mean(letter)
val = (letter[numpy.argmin(letter)])
if mean - 9000 < val < mean + 9000:
UID.append(chr(32))
else:
UID.append(numpy.argmin(letter))
# UID[C] = numpy.argmax(letter)
col = col + hcol + dcol
print 'UID',UID
#additional = numpy.zeros((9))
additional = []
drow = 11
dcol = 13
hcol = 37
hrow = 39
col = 1545
cv2.namedWindow('hood')
letter = numpy.zeros((10,1))
for C in range(9):
row = 907
for L in range(10):
hood = original[row:row + hrow,col:col +hcol]
total = numpy.sum(hood)
letter[L] = total
row = row + drow +hrow
if L == 3 or L == 8:
row = row-1
print 'row',row
cv2.imshow('hood',hood)
cv2.waitKey(300)
mean = numpy.mean(letter)
val = (letter[numpy.argmin(letter)])
if mean - 8000 < val < mean + 8000:
additional.append(chr(32))
else:
additional.append(numpy.argmin(letter))
# additional[C] = numpy.argmax(letter)
col = col + hcol + dcol
print 'add', additional
return lastName,firstName,UID,additional
def fftCorrelation(fiducial1C, blankSheetC):
numRows, numCols, numBands, dataType = ipcv.dimensions(blankSheetC)
numRows1, numCols1, numBands1, dataType1 = ipcv.dimensions(fiducial1C)
print 'blank bands:', numBands
print 'fiducial1 bands:', numBands1
if numBands == 3:
blankSheet = cv2.cvtColor(blankSheetC, cv.CV_BGR2GRAY)
elif numBands == 1:
blankSheet = blankSheetC
if numBands1 == 3:
fiducial1 = cv2.cvtColor(fiducial1C, cv.CV_BGR2GRAY)
elif numBands2 == 1:
fiducial1 = fiducial1C
freqFid1 = numpy.fft.fft2(fiducial1)
freqBlank = numpy.fft.fft2(blankSheet)
magFid1 = numpy.absolute(freqFid1)
magBlank = numpy.absolute(freqBlank)
phaseFid1 = numpy.angle(freqFid1)
phaseBlank = numpy.angle(freqBlank)
correlation = magBlank * magFid1 * numpy.exp(1j * (phaseBlank - phaseFid1))
corrSpat = numpy.fft.ifft2(correlation)
corrSpat = numpy.absolute(numpy.fft.fftshift(corrSpat))
print corrSpat
dispCorrSpat = corrSpat / numpy.max(corrSpat)
print dispCorrSpat.max(), dispCorrSpat.min()
numberRows, numberColumns, numberBands, dataType1 = ipcv.dimensions(blankSheet)
numIncorrect = numpy.zeros((numberRows, numberColumns))
threshold = 0.9999999999999955
#
numIncorrect[dispCorrSpat < threshold] = 0
#if response is greater than/equal to the threshold, a match occurs
numIncorrect[dispCorrSpat >= threshold] = 1
print numIncorrect
totalIncorrect = numpy.sum(numIncorrect)
print 'totalIncorrect', totalIncorrect
cv2.namedWindow('corrSpat', cv2.WINDOW_AUTOSIZE)
cv2.imshow('corrSpat', dispCorrSpat)
cv2.waitKey()
locationMax = numpy.argmax(corrSpat)
rowLoc, colLoc = numpy.unravel_index(locationMax, (numRows, numCols))
displayIm = cv2.merge((blankSheet, blankSheet, blankSheet))
print rowLoc, colLoc
displayIm[rowLoc - 1:rowLoc+2, colLoc-1:colLoc+2, 2] = 0
displayIm[rowLoc-1:rowLoc+2, colLoc-1:colLoc+2, 0:1] = 255
cv2.namedWindow('displayIm', cv2.WINDOW_AUTOSIZE)
cv2.imshow('displayIm', displayIm)
cv2.waitKey()
cv2.imwrite('dotsInCir3.tif', displayIm)
'''
fftFid1 = numpy.fft.ifftshift(centerFreqFid1)
fftBlank = numpy.fft.ifftshift(centerFreqBlank)
Fid1 = numpy.fft.ifft2(fftFid1)
Blank = numpy.fft.ifft2(fftBlank)
'''
return rowLoc, colLoc
def testRotation2():
print 'hello'
#sheets, img2 = ipcv.read_in_files('answer_sheets.pdf','original_scan_sheet.pdf')
#colorimg1 = cv2.imread('test0001.tif', 0) # queryImage
#colorimg2 = cv2.imread('original.tif', 0)
#print colorimg1
colorimg1 = cv2.imread('girlRotated.jpeg')
colorimg2 = cv2.imread('girl.jpeg')
numRows, numCols, numBands, dataType = ipcv.dimensions(colorimg1)
if numBands == 3:
image1 = cv2.cvtColor(colorimg1, cv.CV_BGR2GRAY)
elif numBands == 1:
image1 = colorimg1
numRows2, numCols2, numBands2, dataType2 = ipcv.dimensions(colorimg2)
if numBands2 == 3:
image2 = cv2.cvtColor(colorimg2, cv.CV_BGR2GRAY)
elif numBands2 == 1:
image2 = colorimg2
#image1 = cv2.GaussianBlur(image1,(5,5),0)
#image2 = cv2.GaussianBlur(image2,(5,5),0)
mask = np.zeros((numRows, numCols)).astype(np.uint8)
#3 circles
#mask[690:773,19:105] = 1
#mask[15:100,512:603] = 1
#mask[700:780,490:590] = 1
#First Name
mask[25:43,230:347] = 1
#3 Half Circles
#mask[715:761,62:82] = 1
#mask[712:776,548:568] = 1
#mask[27:80,561:581] = 1
#mask[375:385,146:206] = 1
#Quarter Circle
#mask[59:80,561:581] = 1
#Additional Information
mask[190:203,367:480] = 1
#University ID
mask[24:38,364:484] = 1
#Last
mask[25:35,70:92] = 1
cv2.namedWindow('mask', cv2.WINDOW_NORMAL)
cv2.imshow('mask', mask)
cv2.waitKey()
print 'mask dataType', mask.dtype
print 'img1 datatype', image1.dtype
print 'img2 datatype', image2.dtype
#img2 = cv2.imread('scene.jpeg',0) # trainImage
#initiate SIFT detector
sift = cv2.SIFT()
# find the keypoints and descriptors with SIFT
keypoint1, descriptor1 = sift.detectAndCompute(image1,None)
keypoint2, descriptor2 = sift.detectAndCompute(image2,None)
print 'keypoint1', keypoint1
# A combo of FAST and BRIEF
#orb = cv2.ORB()
#keypoint1, descriptor1 = orb.detectAndCompute(image1,None)
#keypoint2, descriptor2 = orb.detectAndCompute(image2,None)
i_params = dict(algorithm=0, trees=5)
s_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(i_params, s_params)
matches = flann.knnMatch(descriptor1, descriptor2, k=2)
good_matches = []
for m, n in matches:
if m.distance < 0.7*n.distance:
good_matches.append(m)
src_points = np.float32([keypoint1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
dst_points = np.float32([keypoint2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
print 'test', src_points
print 'original', dst_points
# create BFMatcher object
#bfObject = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True)
# Match descriptors.
#matches = bfObject.match(descriptor1,descriptor2)
# Sort them in the order of their distance.
good_matches = sorted(good_matches, key = lambda x:x.distance)
# Draw first 10 matches.
image3 = drawMatches(image1,keypoint1,image2,keypoint2,good_matches[:10])
#image3 = drawMatches(image1,src_points.astype(np.uint8),image2, dst_points(np.uint8),good_matches[:10])
cv2.imwrite('matching.tif', image3)
#Create Affine Transform
M = cv2.getAffineTransform(src_points[0:3], dst_points[0:3])
print M
dst = cv2.warpAffine(image1, M, (numRows, numCols))
print np.min(dst), np.max(dst)
cv2.namedWindow('rotatedIm', cv2.WINDOW_AUTOSIZE)
cv2.imshow('rotatedIm', dst.astype(np.uint8))
cv2.waitKey()
def fft_display(img, videoFilename=None):
try:
img = img.copy()
dims = ipcv.dimensions(img)
r, c = dims["rows"], dims["cols"]
temp = np.zeros((r, c))
# generating FFT
# FFT = np.fft.fftshift(np.fft.fft(img))
# FFT = np.fft.fftshift( np.fft.fft2(img) )
# logFFT = np.log( np.abs( FFT / np.sqrt(FFT.size) ) ).astype(ipcv.IPCV_8U)
FFT = np.fft.fft2(img)
# print("AVERAGE VALUE IS EQUAL TO:",FFT.flat[0])
FFT = np.fft.fftshift(FFT)
FFT = np.abs(FFT)
logFFT = np.log10(FFT)
logFFT = (logFFT / np.max(logFFT)) * 255
print("MAX IS EQUAL TO:", np.max(logFFT))
print("MIN IS EQUAL TO:", np.min(logFFT))
# creating array to poulate with maximum values
maximumValues = np.flipud(np.argsort(logFFT.flatten()))
used = temp.copy()
current = temp.copy()
currentScaled = temp.copy()
summed = temp.copy()
#creating writer and image window
cv2.namedWindow(videoFilename)
writer = create_video_writer(img.shape, videoFilename)
for freqIndex in maximumValues:
# for index in np.arange(0,maximumValues.size,2)
# puting frequency in 'used' array
used.flat[freqIndex] = logFFT.flat[freqIndex]
# returning the spatial sine wave for freq
temp.flat[freqIndex] = logFFT.flat[freqIndex]
current = np.fft.ifft2(temp)
temp.flat[freqIndex] = 0
print("MAX IS EQUAL TO:", np.max(current))
print("MIN IS EQUAL TO:", np.min(current))
#scaling the current
currentScaled = (
(current - np.min(current)) / np.max(current)) * 255
#summing up all the freq
summed = summed + current
#stiching all images together
frame = stich(img, logFFT, used, current, currentScaled, summed)
print("frame dataType =", frame.dtype)
#writing frame
if writer.isOpened():
writer.write(frame)
#displaying image
cv2.imshow(videoFilename, frame)
action = ipcv.flush()
if action == "pause":
action = ipcv.flush()
if action == "pause":
continue
elif action == "exit":
writer.release()
sys.exit()
except Exception as e:
ipcv.debug(e)
