def feature_match_bf_img(img1, img2): """ Brute-force feature matching between two images. Returns matches, keypoints of image 1, keypoints of image 2, descriptors of 1, descriptors of 2 """ gray1 = ImageIO.grayscale(img1) gray2 = ImageIO.grayscale(img2) cv2.ocl.setUseOpenCL(False) orb = cv2.ORB() kp1, des1 = orb.detectAndCompute(gray1, None) kp2, des2 = orb.detectAndCompute(gray2, None) matches = feature_match_bf(kp1, des1, kp2, des2)[0] return matches, kp1, kp2, des1, des2
def findPoints(poinsts):
for dog_octaves in poinsts:
nextgen_list = []
for sacle in range(2):
a = dog_octaves[sacle]
b = dog_octaves[sacle + 1]
c = dog_octaves[sacle + 2]
result = b
height, width = b.shape[:2]
# print(width, height)
for jj in range(height):
for kk in range(width):
target = b[jj][kk]
window = []
for i in range(3):
for j in range(3):
try:
window.append(a[jj - 1 + i][kk - 1 + j])
except:
print('')
for i in range(3):
for j in range(3):
try:
if i != 1 and j != 1:
window.append(b[jj - 1 + i][kk - 1 + j])
except:
print('')
for i in range(3):
for j in range(3):
try:
window.append(c[jj - 1 + i][kk - 1 + j])
except:
print('')
tmax = max(window)
tmin = min(window)
if target > tmax:
result[jj][kk] = target
# result[jj][kk] = 255
elif target < tmin:
result[jj][kk] = target
# result[jj][kk] = 255
else:
result[jj][kk] = 0
print('how keypoints')
io.showImage(result)
nextgen_list.append(result)
keypoints_octaves.append(nextgen_list)
return keypoints_octaves
def test_mass():
dataPath = 'C:/Tomosynthesis/localtest/'
fileName = '5131R-recon08_45-1.tif'
outputPath = 'C:/Tomosynthesis/localtest/res/'
im = ImageIO.imReader(dataPath,fileName, 'tif',2)
# padding borarders
'''
paddingrd = 10
bordares = ((paddingrd,paddingrd),(paddingrd,paddingrd))
paddingv = 10000
bordarevs = ((paddingv,paddingv),(paddingv,paddingv))
im = np.lib.pad(im.data[0], bordares, 'constant',constant_values = bordarevs)
'''
eqimg = histEqualization.histEqualization(im.data[0], 16)
denoised = AT_denoising.DenoisingAW(eqimg)
denoised = AT_denoising.DenoisingAW(denoised)
denoised = AT_denoising.DenoisingAW(denoised)
img = AT_denoising.DenoisingAW(denoised)
tiffLib.imsave(outputPath + 'denoised.tif',img)
# g(I)
gI = morphsnakes.gborders(img, alpha=1, sigma=8)
tiffLib.imsave(outputPath + 'gI.tif',np.float32(gI))
# Morphological GAC. Initialization of the level-set.
mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.035, balloon=-1)
mgac.levelset = circle_levelset(img.shape, (img.shape[0]/2, img.shape[1]/2), 140, scalerow=0.75)
# Visual evolution.
ppl.figure()
ls = morphsnakes.evolve_visual(mgac, num_iters=110, background=img)
tiffLib.imsave(outputPath + 'ls.tif',np.float32(ls))
def test_func():
"""Please specify the image tiff stack directory, file name and output
path. Extracted masses list will be save in a workspace file for further use.
Also please specify how many cores will be allocated for the parallel process.
"""
dataPath = '/home/yanbin/Tomosynthesis/data/tiffs_3d/5016/'
outputPath = '/home/yanbin/Tomosynthesis/script_test/'
fileName = '5016EMML08.tif'
## load image data
im = ImageIO.imReader(dataPath,fileName, 'tif')
## allocate cpu source
pool = Pool(processes=6)
params =[(i,im.data[i]) for i in range(im.size_2)]
## run in parallel
sliceList = []
sliceList = pool.map(mass3d.parallelWrapper,params)
## save the workspace
output = open(outputPath + 'suspicious.pkl', 'wb')
pickle.dump(sliceList, output)
output.close()
def creatTrainigSam_3D(dataPath, iRnum = 6,iSnum = 12, gRnum = 4,gSnum = 12):
""" Creat training samples(3D) and compute features for each training sample
Parameters
----------
dataPath: str
The directory where training image ROIs are stores.
opt: str
Options for compute features.
iRnum: integer
The number of rings to be divided in computing intensity features
iSnum: integer
The number of sectors to be divided in computing intensity features
gRnum: integer
The number of rings to be divided in computing gradient features
gSnum: integer
The number of sectors to be divided in computing gradient features
"""
file_list = os.listdir(dataPath)
LightPatchList = []
bagid = 0
instanceid = 0
for fil in file_list:
im = ImageIO.imReader(dataPath, fil,'tif',3)
for i in range(im.size_2):
# Calculating intensity features
patch = TPatch.TPatch()
patch.initialize(im.data[i])
int_feats = patch.getIntenfeats(iRnum,iSnum)
# Calculating segment features
seg_feats = patch.getSegmentFeats()
# Calculating gradient features
im.downSample(rate = 2)
eqimg = histEqualization.histEqualization(im.sampled_data[i], 16)
smoothimg = filters.gaussian_filter(eqimg, sigma = 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)
patch = TPatch.TPatch()
patch.initialize(smoothimg)
gr_feats = patch.getGradfeats(gRnum,gSnum)
feats = np.hstack((int_feats, gr_feats, seg_feats))
lightPatch = TPatch.TLightPatch()
lightPatch.pdata = im.data[i]
lightPatch.feats = feats
lightPatch.patch_center = (im.data[i].shape[0]/2, im.data[i].shape[1]/2)
lightPatch.bagID = bagid
lightPatch.instanceID = instanceid
LightPatchList.append(lightPatch)
instanceid = instanceid + 1
bagid = bagid + 1
return LightPatchList
def LK_Optical_Flow(image, p0, mask=None):
lk_params = dict(winSize=(50, 50),
maxLevel=5,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
10, 0.03))
image_old = image
image_old = cv2.add(image_old,
np.zeros(np.shape(image_old), dtype=np.uint8),
mask=mask)
linemask = np.zeros_like(image)
while 1:
#image=cv2.add(image,np.zeros(np.shape(image),dtype=np.uint8),mask=mask)
p1, st, err = cv2.calcOpticalFlowPyrLK(image_old, image, p0, None,
**lk_params)
try:
good_new = p1[st == 1]
good_old = p0[st == 1]
except TypeError:
warn("Lose track")
return
for i, (new, old) in enumerate(zip(good_new, good_old)):
a, b = new.ravel()
c, d = old.ravel()
linemask = cv2.line(linemask, (a, b), (c, d), color[i].tolist(), 2)
image = cv2.circle(image, (a, b), 5, color[i].tolist(), -1)
img = cv2.add(image, linemask)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
image_old = image.copy()
p0 = good_new.reshape(-1, 1, 2)
image = (yield img)
def otsu(img): """ Method to threshold via a OTSU binarization """ gray = ImageIO.grayscale(img) gray = cv2.GaussianBlur(img, (5,5), 0) ret, th = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU) return th
def fft_img(img): """ Fast Fourier Transform in 2-D. """ gray = ImageIO.grayscale(img) f = np.fft.fft2(gray) fshift = np.fft.fftshift(f) return fshift
def good_corners(img, numFeatures = 25): """ Finds corners via Shi-Tomasi Good Features To Track. Returns corners. """ gray = ImageIO.grayscale(img) corners = cv2.goodFeautresToTrack(gray, numFeatures, 0.01, 10) corners = np.int0(corners) return corners
def setUp(self):
imageFile = '../test/test.jpg'
self.image = ImageIO.cv2read(imageFile)
self.grayscale = cv2.cvtColor(self.image,cv2.COLOR_BGR2GRAY)
self.stats = stats()
self.fft = fft()
self.feats = Features()
self.lap = Laplacian()
self.edges = Edges()
def adaptiveMean(img): """ Method to threshold using a threshold value that is the mean of neighbourhood area. """ gray = ImageIO.grayscale(img) gray = cv2.medianBlur(img, 5) meanThresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2) return meanThresh
def harris_corner_detector(img, blockSize = 2, ksize = 3, k = 0.04): """ Harris Corner Detection. """ gray = ImageIO.grayscale(img) gray = np.float32(gray) dst = cv2.cornerHarris(gray, blockSize, ksize, k) dst = cv2.dilate(dst, None) return dst
def test_cvread(self):
img = ImageIO.cvread(self.imageFile)
tmpImg = cv.LoadImage(self.imageFile)
cv.AbsDiff(img,tmpImg,img)
mat = cv.GetMat(img)
arr = numpy.asarray(mat)
equalityBool = (arr.all() == 0)
self.assertTrue(equalityBool)
def adaptiveGaussian(img): """ Method to threshold using a threshold value that is the weighted sum of neighbourhood values where weights are a gaussian window. """ gray = ImageIO.grayscale(img) gray = cv2.medianBlur(img, 5) gaussThresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2) return gaussThresh
def threshold(img, threshold = 127, invert=False): """ Method to quickly compute the binary image. """ gray = ImageIO.grayscale(img) if invert: ret, thresh = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY_INV) return thresh ret, thresh = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY) return thresh
def getOctaves(img):
octaves = []
b = 0.5
# print(b)
for x in range(4):
List = []
a = b
# print(a)
for y in range(5):
a = a * math.sqrt(2)
List.append(cv2.GaussianBlur(img, (5, 5), a))
# print(a)
io.showImage(List[y])
b *= 2
octaves.append(List)
height, width = img.shape[:2]
img = cv2.resize(img, (int(width / 2), int(height / 2)),
interpolation=cv2.INTER_AREA)
return octaves
def removeLowThreshold(low_threshold, points):
low_threshold_keypoints = []
for list in points:
scales_list = []
for index, a in enumerate(list):
print(index)
result = a
height, width = a.shape[:2]
# avoid low_threshold pixels
for j in range(height):
for k in range(width):
if a[j][k] < low_threshold[index]:
result[j][k] = 0
else:
result[j][k] = 255
low_threshold[index] *= 0.75
io.showImage(result)
scales_list.append(result)
low_threshold_keypoints.append(scales_list)
return low_threshold_keypoints
def removeEdge(points, scale_space):
mask_x = [[1, 0, -1], [2, 0, -2], [1, 0, -1]]
mask_y = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]
for a, list in enumerate(points):
scale_list = []
imX = cv.filter2D(scale_space[a][0], -1, kernel=np.array(mask_x))
imY = cv.filter2D(scale_space[a][0], -1, kernel=np.array(mask_y))
for index, item in enumerate(list):
height, width = item.shape[:2]
for j in range(height):
for k in range(width):
if imX[j][k] != 0 and imY[j][k] != 0:
if 0.5 < imX[j][k] / imY[j][k] < 1.5 and item[j][
k] != 0:
item[j][k] = 0
else:
item[j][k] = 0
io.showImage(item)
scale_list.append(item)
keypoints.append(scale_list)
return keypoints
def my_svm():
trainSet_x, trainSet_y, testSet_x, testSet_y = ImageIO.loadSVMImage()
# clf = svm.SVC(C=100.0, kernel='rbf', gamma=0.03)
clf = svm.LinearSVC()
print('start fit')
clf.fit(trainSet_x, trainSet_y)
print('finish fit')
predictions = [int(a) for a in clf.predict(testSet_x)]
predictions_2 = [int(a) for a in clf.predict(trainSet_x)]
num_correct = sum(int(a == y) for a, y in zip(predictions, testSet_y))
num_correct_2 = sum(int(a == y) for a, y in zip(predictions_2, trainSet_y))
print("%s of %s test values correct." % (num_correct, len(testSet_y)))
print("%s of %s train values correct." % (num_correct_2, len(trainSet_y)))
def worddetect():
print "start run..."
filename = "train_data/image_label.csv"
dataModelSet = DataModelSet(ImageIO.read_image_label_model_file(filename))
print "num_examples : %d" %(dataModelSet.num_examples)
#dataModelpart = dataModelSet.next_batch(5)
#for dataModel in dataModelpart:
# dataModel.discription()
epochs = 10000
# 输入变量,x为图像,y为标签
x = tf.placeholder(dtype=tf.float32, shape=[None, 224, 224,3], name='x')
y = tf.placeholder(dtype=tf.float32, shape=[None, 224, 224,1], name='y')
hedmodel = HedNetModel("vgg16.npy")
score = hedmodel.build(x,is_training = True)
print "score.shape : "
print score.shape
cost = class_balanced_sigmoid_cross_entropy(score,y)
accucy = 1 - cost;
# 建立会话
with tf.Session() as sess:
# 初始化变量
sess.run(tf.global_variables_initializer())
for i in range(epochs):
print "training... "
# 批量数据,大小为5
tmpDataList = []
tmpLabelList = []
dataModelpart = dataModelSet.next_batch(5)
for tmpDataModel in dataModelpart:
tmpDataList.append(tmpDataModel.imageData)
tmpLabelList.append(tmpDataModel.labelData)
x_batch = np.array(tmpDataList)
y_batch = np.array(tmpLabelList)
c = sess.run(cost, feed_dict={x:x_batch, y:y_batch})
print "cost:"
print c
print "stop run..."
def getHeaderBitmap():
''' Get the header bitmap if specified, or use a default. '''
if Utils.getMainWin():
if Model.race and Model.race.headerImage:
try:
bitmap = ImageIO.toBitmapFromBuf( Model.race.headerImage )
return bitmap
except:
pass
graphicFName = Utils.getMainWin().getGraphicFName()
extension = os.path.splitext( graphicFName )[1].lower()
bitmapType = {
'.gif': wx.BITMAP_TYPE_GIF,
'.png': wx.BITMAP_TYPE_PNG,
'.jpg': wx.BITMAP_TYPE_JPEG,
'.jpeg':wx.BITMAP_TYPE_JPEG }.get( extension, wx.BITMAP_TYPE_PNG )
bitmap = wx.Bitmap( graphicFName, bitmapType )
else:
bitmap = wx.Bitmap( os.path.join(Utils.getImageFolder(), 'CrossMgrHeader.png'), wx.BITMAP_TYPE_PNG )
return bitmap
def getHeaderBitmap():
''' Get the header bitmap if specified, or use a default. '''
if Utils.getMainWin():
if Model.race and Model.race.headerImage:
try:
bitmap = ImageIO.toBitmapFromBuf( Model.race.headerImage )
return bitmap
except:
pass
graphicFName = Utils.getMainWin().getGraphicFName()
extension = os.path.splitext( graphicFName )[1].lower()
bitmapType = {
'.gif': wx.BITMAP_TYPE_GIF,
'.png': wx.BITMAP_TYPE_PNG,
'.jpg': wx.BITMAP_TYPE_JPEG,
'.jpeg':wx.BITMAP_TYPE_JPEG }.get( extension, wx.BITMAP_TYPE_PNG )
bitmap = wx.Bitmap( graphicFName, bitmapType )
else:
bitmap = wx.Bitmap( os.path.join(Utils.getImageFolder(), 'CrossMgrHeader.png'), wx.BITMAP_TYPE_PNG )
return bitmap
def test_func():
"""You can conver a single smv file to 3D tiff by specifying
data_path, output_path, fileName and set the SigleConvert flag to 1.
You can conver a batch of smv files to 3D tiffs by specifying
root data_path, output_path and set the BatchConvert flag to 1.
"""
## Please specify paths ##
data_path = '/home/yanbin/Tomosynthesis/data/SAP_test_datasets/Screening_30_cases/6002/'
output_path = '/home/yanbin/Tomosynthesis/script_test/'
fileName = '6002L06.smv'
## Please specify Parameters ##
BatchConvert = 0
SigleConvert = 0
dim = 3
## data_path check
if not os.path.isdir(data_path):
print "Data directory:\n"+ data_path +"\ndoes not exist"
sys.exit()
## Format convert batch
if BatchConvert == 1:
print 'here'
dir_list = os.listdir(data_path)
print dir_list
for dirc in dir_list:
print dirc
if os.path.isdir(data_path + dirc):
# make directory for output files
opath = output_path + dirc + '/'
print opath
if not os.path.isdir(opath):
os.makedirs(opath)
file_list = os.listdir(data_path + dirc)
for fil in file_list:
im = ImageIO.imReader(data_path + dirc + '/', fil, 'smv')
ImageIO.imWriter(opath, fil.strip('smv') + 'tif',im,dim)
## Format convert single
if SigleConvert == 1:
im = ImageIO.imReader(data_path,fileName, 'smv')
ImageIO.imWriter(output_path, fileName.strip('smv') + 'tif',im, dim)
def imageHandler(imgfile):
retStrings = []
if imgfile in seen:
return
if os.path.isdir(os.path.join(args.directory, imgfile)):
temp = os.listdir(os.path.join(args.directory, imgfile))
for f in temp:
images.append(os.path.join(imgfile, f))
return
# silently skip the bin files that have the gps data
if imgfile.endswith('bin'):
return
# alert to other files that were skipped
if not (imgfile.endswith('png') | imgfile.endswith('jpg')):
sys.stderr.write("Skipped file: " + imgfile + "\n")
return
if args.verbose:
sys.stderr.write("Parsing " + imgfile + "\n")
retStrings.append( imgfile + "\t" )
img = ImageIO.cv2read(os.path.join(args.directory, imgfile))
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ngray = Normalization.equalizeHistograms(gray)
ngray = cv2.GaussianBlur(ngray, (3,3), 0)
feats.detect_kp_ORB(ngray)
retStrings.append( str(feats.numberKeyPoints()) + "\t" + str(feats.medianKeyPointSize()) + "\t" + str(feats.meanKeyPointSize()) )
for i in range(15):
retStrings.append("\t" + str(feats.numKeyPoints(i*10)))
retStrings.append("\n")
return retStrings
def test_func():
"""Please specify the data directory and file name.This function runs
the detection for a 3D stack.
"""
dataPath = 'C:/Tomosynthesis/localtest/'
outputPath = 'C:/Tomosynthesis/test_script/'
fileName = '5092-1.tif'
# Loading data
im = ImageIO.imReader(dataPath,fileName, 'tif',3)
# run detection in parallel
mc_Lists = []
pool = Pool(processes=1)
params =[(i,im.data[i]) for i in range(im.size_2)]
mc_Lists = pool.map(mc.parallelWrapper,params)
global_id = mc.MC_connect_3d(mc_Lists)
gloabal_list = mc.MCs_constuct_3d(mc_Lists,global_id)
MC_List_3D = mc.MCs_constrain(gloabal_list)
for item in MC_List_3D:
print(item.center, item.intensity, item.volume)
out.append("使用中")
return out
def GetCapturePointList(image, n): #image为所要交互获取点的图像，n为想要获取的点的个数
im_array = np.array(image)
pylab.imshow(im_array)
X = pylab.ginput(n) # x 为列表，元素为坐标 例：[（x1,y1),(x2,y2),......]
pylab.close()
return X
if __name__ == "__main__":
import imutils
reader = image.reader("E:/[工程项目]/[数据集]/[图书馆占座识别视频样本]/00129_1.mp4")
_, a = reader.read()
_, b = reader.read(False)
print("=" * 10, "蒙版", "=" * 10)
# mask=Mask_Square(reader.size,100,100,50)
pointlist = np.array([[242, 351], [407, 353], [398, 478], [213, 479]],
dtype=np.int32)
pointlist = pointlist.reshape([1, 4, 2])
mask = Mask_Polygon(a.shape, pointlist)
#cv2.imshow("mask",mask)
#cv2.imshow("s",a)
addresult = cv2.add(a, np.zeros(np.shape(a), dtype=np.uint8), mask=mask)
#cv2.imshow("add",addresult)
print("=" * 10, "特征点提取", "=" * 10)
def main():
## Please specify paths ##
data_path = '/home/yanbin/Tomosynthesis/data/SAP_test_datasets/Screening_30_cases/'
output_path = '/home/yanbin/Tomosynthesis/data/tiffs_3d/'
exe_path= '/home/yanbin/Tomosynthesis/code/'
## Please specify Run Flags ##
FormatConvert = 1
AWDenoising = 0
ContrastEnhancement = 0
## Please specify parameters ##
dim = 3 # For format convert: save as 2d slices / 3d stack
opt = 'asymptotic' # For AWdenoising inverse transform options
block_m=5
block_n=5 # For AWdenoising Wiener filter window size block_m = block_n
###################### Avalability Check #######################
# data_path check
if not os.path.isdir(data_path):
print "Data directory:\n"+ data_path +"\ndoes not exist"
sys.exit()
# exe_path check
if not os.path.isdir(exe_path):
print "Executable directory:\n"+ exe_path +"\ndoes not exist"
sys.exit()
###################### Format Convert #######################
if FormatConvert == 1:
dir_list = os.listdir(data_path)
print dir_list
for dirc in dir_list:
print dirc
if os.path.isdir(data_path + dirc):
# make directory for output files
opath = output_path + dirc + '/'
print opath
if not os.path.isdir(opath):
os.makedirs(opath)
file_list = os.listdir(data_path + dirc)
for fil in file_list:
im = ImageIO.imReader(data_path + dirc + '/', fil, 'smv')
ImageIO.imWriter(opath, fil.strip('smv') + 'tif',im,dim)
############################# Denoising ##########################
if AWDenoising == 1:
dir_list = os.listdir(data_path)
print dir_list
for dirc in dir_list:
print dirc
if os.path.isdir(data_path + dirc):
# make directory for output files
opath = output_path + dirc + '/'
print opath
if not os.path.isdir(opath):
os.makedirs(opath)
file_list = os.listdir(data_path + dirc)
for fil in file_list:
im = ImageIO.imReader(data_path + dirc + '/', fil, 'tif',2)
denoised = AT_denoising.DenoisingAW(im.data[0], opt = 'asymptotic', block_m=5,block_n=5)
tiffLib.imsave(opath + 'denoised_' + fil,denoised)
###################### Contrast enhancement #######################
if ContrastEnhancement == 1:
dir_list = os.listdir(data_path)
print dir_list
for dirc in dir_list:
print dirc
if os.path.isdir(data_path + dirc):
# make directory for output files
opath = output_path + dirc + '/'
print opath
if not os.path.isdir(opath):
os.makedirs(opath)
file_list = os.listdir(data_path + dirc)
for fil in file_list:
im = ImageIO.imReader(data_path + dirc + '/', fil, 'tif',2)
enhanced = histEqualization.histEqualization(im.data[0], 16)
tiffLib.imsave(opath + 'enhanced_' + fil,enhanced)
data_projected = Dimreduction.dim_Reduction(data, label, opt, n_components=2, visualize = True)
classifier = classification.classifier(data_projected,label)
classifier.train(opt ='SVM')
classifier.classify()
'''
############################# Mass 3D extraction ########################################
dataPath = '/home/yanbin/Tomosynthesis/data/tiffs_3d/5016/'
paraPath = '/home/yanbin/localtest/'
outputPath = '/home/yanbin/Tomosynthesis/results/5016/'
im_name = '5016EMML08.tif'
# loading
im = ImageIO.imReader(dataPath,im_name, 'tif',3)
print (im.size_0,im.size_1,im.size_2)
control_name = 'feats_control_1.txt'
cancer_name = 'feats_cancer.txt'
control = np.loadtxt(paraPath + control_name)
cancer = np.loadtxt(paraPath + cancer_name)
# training
data = np.vstack((control,cancer))
label = np.zeros((control.shape[0] + cancer.shape[0],),np.int)
label[0:control.shape[0]] = 1
data_projected = Dimreduction.dim_Reduction(data, label, opt='randtree', n_components=5, visualize = False)
classifier = classification.classifier(data_projected,label)
classifier.train(opt ='SVM')
import ImageIO as io
from SiftSteps import LoG, \
ScaleSpace as scale_space, \
findingKeyPoint as key_point, \
gettingRideOfLowContrastKeypoints as decrese_keypoints, \
GenerateFeature as gn, \
KeypointOrientations as key_orientation
img = io.getImage("test2.jpg")
octaves = scale_space.getOctaves(img)
log_approximations = LoG.getDoGOctaves(octaves)
points = key_point.findPoints(octaves)
points = decrese_keypoints.removeKeypoints([2, 4], points, octaves)
oriented_points = key_orientation.orientations(points, octaves)
final_points = gn.generate_feature(oriented_points, points, octaves)
import ImageIO import TImage import tiffLib from scipy import ndimage as nd import scipy from skimage.filter import gabor_kernel import numpy as np import time from numpy.fft import fft, ifft, fft2, ifft2, fftshift dataPath = 'C:/Tomosynthesis/localtest/' fileName = 'test-crop.tif' outputPath = 'C:/Tomosynthesis/localtest/res/' im = ImageIO.imReader(dataPath,fileName, 'tif',2) kernel = np.real(gabor_kernel(0.0185, 0, 20, 20/float(0.9))) print kernel.shape start = time.clock() temp_response = nd.convolve(im.data[0], kernel, mode='nearest') elapsed = (time.clock() - start) print elapsed start = time.clock() data = np.lib.pad(im.data[0], ((0,kernel.shape[0]),(0,kernel.shape[1])),'edge') temp_response_2 = np.fft.irfft2(np.fft.rfft2(data) * np.fft.rfft2(kernel,data.shape)) temp_response_2 = temp_response_2[kernel.shape[0]/2:data.shape[0] - kernel.shape[0]/2,kernel.shape[1]/2:data.shape[1] - kernel.shape[1]/2] elapsed = (time.clock() - start) print elapsed
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument(
'objects_list',
help='List of objects (.json)'
)
args = parser.parse_args()
reader = open(os.path.join(os.environ['FS_ROOT'], args.objects_list), 'rt')
data = json.load(reader)
reader.close()
input_file = data['input_file']
output_dir = os.path.join(os.environ['FS_ROOT'], 'dataset', os.path.splitext(os.path.basename(input_file))[0])
offset = min([data['frames'][f]['frame_id'] for f in range(len(data['frames']))])
clip = (f + offset) / 900
if args.objects_list.find('selected') == -1:
sub_dir = 'clip{0:03d}'.format(clip)
else:
sub_dir = 'selected'
if os.path.isfile('{0}/{1}/All/objects.json'.format(output_dir, sub_dir)) and os.path.isfile('{0}/{1}/Export/objects.json'.format(output_dir, sub_dir)):
return
elif os.path.isfile('{0}/{1}/All/objects.json'.format(output_dir, sub_dir)):
reader = open('{0}/{1}/All/objects.json'.format(output_dir, sub_dir), 'rt')
data = json.load(reader)
reader.close()
else:
if not os.path.exists('{0}/{1}/All'.format(output_dir, sub_dir)):
os.makedirs('{0}/{1}/All'.format(output_dir, sub_dir))
if not os.path.exists('{0}/{1}/Export'.format(output_dir, sub_dir)):
os.makedirs('{0}/{1}/Export'.format(output_dir, sub_dir))
if os.path.isfile(os.path.join(os.environ['FS_ROOT'], input_file)):
cap = cv2.VideoCapture(os.path.join(os.environ['FS_ROOT'], input_file))
if cap.isOpened() == False:
print('Cannot open input file: ' + os.path.join(os.environ['FS_ROOT'], input_file))
exit(1)
cap.set(cv2.CAP_PROP_POS_FRAMES,offset)
else:
filelist = sorted(glob.glob(os.path.join(os.environ['FS_ROOT'], input_file, '*.jpg')))
for f in range(len(data['frames'])):
if os.path.isfile(os.path.join(os.environ['FS_ROOT'], input_file)):
ret,img = cap.read()
else:
img = cv2.imread(filelist[f + offset])
ret = img is not None
if ret:
for r in range(len(data['frames'][f]['frame_rois'])):
#print json.dumps(data['frames'][f]['frame_rois'][r], indent = 4)
roi = (data['frames'][f]['frame_rois'][r]['roi_x'], data['frames'][f]['frame_rois'][r]['roi_y'], data['frames'][f]['frame_rois'][r]['roi_w'], data['frames'][f]['frame_rois'][r]['roi_h'])
print roi
if not os.path.isfile('{0}/{1}/All/objects.json'.format(output_dir, sub_dir)):
output = '{0}/{1}/Import/{2}/images/frame{3:06d}/{3:06d}_{4:06d}.jpg'.format(output_dir, sub_dir, data['frames'][f]['frame_rois'][r]['roi_label']['label_name'], data['frames'][f]['frame_id'], data['frames'][f]['frame_rois'][r]['roi_id'])
print output
ImageIO.saveImg(output, img, roi)
output = '{0}/{1}/All/images/frame{2:06d}/{2:06d}_{3:06d}.jpg'.format(output_dir, sub_dir, data['frames'][f]['frame_id'], data['frames'][f]['frame_rois'][r]['roi_id'])
ImageIO.saveImg(output, img, roi)
if not os.path.isfile('{0}/{1}/Export/objects.json'.format(output_dir, sub_dir)) and data['frames'][f]['frame_rois'][r]['roi_label']['label_name'] != 'Unsorted':
output = '{0}/{1}/Export/{2}/{3:06d}_{4:06d}.jpg'.format(output_dir, sub_dir, data['frames'][f]['frame_rois'][r]['roi_label']['label_name'], data['frames'][f]['frame_id'], data['frames'][f]['frame_rois'][r]['roi_id'])
print output
ImageIO.saveImg(output, img, roi)
if not os.path.isfile('{0}/{1}/All/objects.json'.format(output_dir, sub_dir)):
shutil.copy(os.path.join(os.environ['FS_ROOT'], args.objects_list), '{0}/{1}/All/objects.json'.format(output_dir, sub_dir))
if not os.path.isfile('{0}/{1}/Export/objects.json'.format(output_dir, sub_dir)):
shutil.copy('{0}/{1}/All/objects.json'.format(output_dir, sub_dir), '{0}/{1}/Export/objects.json'.format(output_dir, sub_dir))
def test_cv2read(self):
img = ImageIO.cv2read(self.imageFile)
tmpImg = cv2.imread(self.imageFile)
equalityBool = (img == tmpImg).all()
self.assertTrue(equalityBool)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument('objects_list', help='List of objects (.json)')
args = parser.parse_args()
reader = open(os.path.join(os.environ['FS_ROOT'], args.objects_list), 'rt')
data = json.load(reader)
reader.close()
input_file = data['input_file']
output_dir = os.path.join(
os.environ['FS_ROOT'], 'dataset',
os.path.splitext(os.path.basename(input_file))[0])
offset = min(
[data['frames'][f]['frame_id'] for f in range(len(data['frames']))])
clip = (f + offset) / 900
if args.objects_list.find('selected') == -1:
sub_dir = 'clip{0:03d}'.format(clip)
else:
sub_dir = 'selected'
if os.path.isfile('{0}/{1}/All/objects.json'.format(
output_dir, sub_dir)) and os.path.isfile(
'{0}/{1}/Export/objects.json'.format(output_dir, sub_dir)):
return
elif os.path.isfile('{0}/{1}/All/objects.json'.format(output_dir,
sub_dir)):
reader = open('{0}/{1}/All/objects.json'.format(output_dir, sub_dir),
'rt')
data = json.load(reader)
reader.close()
else:
if not os.path.exists('{0}/{1}/All'.format(output_dir, sub_dir)):
os.makedirs('{0}/{1}/All'.format(output_dir, sub_dir))
if not os.path.exists('{0}/{1}/Export'.format(output_dir, sub_dir)):
os.makedirs('{0}/{1}/Export'.format(output_dir, sub_dir))
if os.path.isfile(os.path.join(os.environ['FS_ROOT'], input_file)):
cap = cv2.VideoCapture(os.path.join(os.environ['FS_ROOT'], input_file))
if cap.isOpened() == False:
print('Cannot open input file: ' +
os.path.join(os.environ['FS_ROOT'], input_file))
exit(1)
cap.set(cv2.CAP_PROP_POS_FRAMES, offset)
else:
filelist = sorted(
glob.glob(os.path.join(os.environ['FS_ROOT'], input_file,
'*.jpg')))
for f in range(len(data['frames'])):
if os.path.isfile(os.path.join(os.environ['FS_ROOT'], input_file)):
ret, img = cap.read()
else:
img = cv2.imread(filelist[f + offset])
ret = img is not None
if ret:
for r in range(len(data['frames'][f]['frame_rois'])):
#print json.dumps(data['frames'][f]['frame_rois'][r], indent = 4)
roi = (data['frames'][f]['frame_rois'][r]['roi_x'],
data['frames'][f]['frame_rois'][r]['roi_y'],
data['frames'][f]['frame_rois'][r]['roi_w'],
data['frames'][f]['frame_rois'][r]['roi_h'])
print roi
if not os.path.isfile('{0}/{1}/All/objects.json'.format(
output_dir, sub_dir)):
output = '{0}/{1}/Import/{2}/images/frame{3:06d}/{3:06d}_{4:06d}.jpg'.format(
output_dir, sub_dir, data['frames'][f]['frame_rois'][r]
['roi_label']['label_name'],
data['frames'][f]['frame_id'],
data['frames'][f]['frame_rois'][r]['roi_id'])
print output
ImageIO.saveImg(output, img, roi)
output = '{0}/{1}/All/images/frame{2:06d}/{2:06d}_{3:06d}.jpg'.format(
output_dir, sub_dir, data['frames'][f]['frame_id'],
data['frames'][f]['frame_rois'][r]['roi_id'])
ImageIO.saveImg(output, img, roi)
if not os.path.isfile('{0}/{1}/Export/objects.json'.format(
output_dir,
sub_dir)) and data['frames'][f]['frame_rois'][r][
'roi_label']['label_name'] != 'Unsorted':
output = '{0}/{1}/Export/{2}/{3:06d}_{4:06d}.jpg'.format(
output_dir, sub_dir, data['frames'][f]['frame_rois'][r]
['roi_label']['label_name'],
data['frames'][f]['frame_id'],
data['frames'][f]['frame_rois'][r]['roi_id'])
print output
ImageIO.saveImg(output, img, roi)
if not os.path.isfile('{0}/{1}/All/objects.json'.format(
output_dir, sub_dir)):
shutil.copy(os.path.join(os.environ['FS_ROOT'], args.objects_list),
'{0}/{1}/All/objects.json'.format(output_dir, sub_dir))
if not os.path.isfile('{0}/{1}/Export/objects.json'.format(
output_dir, sub_dir)):
shutil.copy('{0}/{1}/All/objects.json'.format(output_dir, sub_dir),
'{0}/{1}/Export/objects.json'.format(output_dir, sub_dir))
warped_im1,d1, d2 = registration.registration(im_r.data[0], im_l.data[0], 15,'c')
tiffLib.imsave(outputPath + 'warped_im1.tif',np.float32(warped_im1))
tiffLib.imsave(outputPath + 'd1.tif',np.float32(d1))
tiffLib.imsave(outputPath + 'd2.tif',np.float32(d2))
'''
############################# comparision test #####################################
dataPath = 'C:/Tomosynthesis/localtest/reg/'
outputPath = 'C:/Tomosynthesis/localtest/reg/'
fileName_r = 'op.tif'
fileName_l = '6044_l.tif'
im_r = ImageIO.imReader(dataPath,fileName_r, 'tif',2)
im_l = ImageIO.imReader(dataPath,fileName_l, 'tif',2)
params = []
params.append(('1d', 'cv_comp', cv.CV_COMP_CORREL))
params.append(('1d', 'scipy_comp', 'Euclidean'))
params.append(('1d', 'scipy_comp', 'Manhattan'))
params.append(('1d', 'kl_div', 'None'))
params.append(('2d', cv.CV_TM_SQDIFF_NORMED, 'None'))
params.append(('2d', cv.CV_TM_CCORR_NORMED, 'None'))
params.append(('2d', cv.CV_TM_CCOEFF_NORMED, 'None'))
params.append(('decomp', 'eigen', 'None'))
params.append(('decomp', 'NMF', 'None'))
sys.path.append('../Modules/')
import cv2
import ImageIO
import Normalization
from matplotlib import pyplot as plt
import numpy
'''
A test program to make sure that the Normalization methods work.
This normalizes the images, and displays them.
'''
#test = 'test.jpg'
test = "/home/redwards/Dropbox/ComputerVision/TestCode/test.png"
im = ImageIO.cv2read(test)
print im.shape
print "Testing Tylers normalization"
tn = Normalization.Tyler(im)
print "Testing histogram equalization"
he = Normalization.equalizeHistograms(im)
heo = numpy.ones_like(im)
heo[:,:,0]=he
heo[:,:,1]=he
heo[:,:,2]=he
print "Simple normaliztion"
nh = Normalization.simpleNorm(im)
def setUp(self):
imageFile = '../test/test.jpg'
self.img = ImageIO.cv2read(imageFile)
self.contours = contours(self.img)
import sys
sys.path.append('../Modules/')
import ImageIO
from Analysis import *
'''
A simple test whether the bgr_energy calculation works
'''
im = sys.argv[1]
img = ImageIO.cv2read(im)
fft=FFT()
for i in range(3):
print "The energy for the ", i, " channel is ", fft.energy(img[:,:,i])
def imageWriter(images,seen,args,fout,classification,stats,fft,lap,edge):
for imgfile in images:
if imgfile in seen: continue
if os.path.isdir(os.path.join(args.directory, imgfile)):
temp = os.listdir(os.path.join(args.directory, imgfile))
for f in temp:
images.append(os.path.join(imgfile, f))
continue
#rewrite of above if statement
#if os.path.isdir(os.path.join(args.directory,imgfile)):
# temp = os.listdir(os.path.join(args.directory,imgfile))
# pool = Pool()
# pool.map(images.append, os.path.join(imgfile, f))
# pool.close()
# pool.join()
# continue
if not args.all and imgfile not in classification:
continue
# silently skip the bin files that have the gps data
if imgfile.endswith('bin'):
continue
# alert to other files that were skipped
if not (imgfile.endswith('png') | imgfile.endswith('jpg')):
sys.stderr.write("Skipped file: " + imgfile + "\n")
continue
if args.verbose:
sys.stderr.write("Parsing " + imgfile + "\n")
fout.write( imgfile + "\t" )
if imgfile in classification:
fout.write( classification[imgfile] + "\t")
else:
fout.write( "unknown\t" )
img = ImageIO.cv2read(os.path.join(args.directory, imgfile))
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
fout.write( ('\t'.join(map(str, [stats.min(gray), stats.max(gray), stats.median(gray), stats.mean(gray)]))) + "\t" )
ngray = Normalization.equalizeHistograms(gray)
# apply a gaussian blur to remove edge effects
ngray = cv2.GaussianBlur(ngray, (3,3), 0)
fout.write( ('\t'.join(map(str, [stats.min(ngray), stats.max(ngray), stats.median(ngray), stats.mean(ngray)]))) + "\t")
for i in range(3):
imp = img[:,:,i]
fout.write( ('\t'.join(map(str, [stats.min(imp), stats.max(imp), stats.median(imp), stats.mean(imp)]))) + "\t" )
fout.write( str(fft.energy(gray)) + "\t" + str(fft.energy(ngray)) + "\t")
if args.features:
feats.detect_kp_ORB(ngray)
fout.write( str(feats.numberKeyPoints()) + "\t" + str(feats.medianKeyPointSize()) + "\t" + str(feats.meanKeyPointSize()) + "\t")
for i in range(15):
fout.write( str(feats.numKeyPoints(i*10)) + "\t")
else:
fout.write("0\t0\t0\t");
for i in range(15):
fout.write("0\t")
for i in range(15):
k=2*i+1
fout.write( str(lap.sum(ngray, k)) + "\t")
for i in range(25):
t2 = 10*i
fout.write( str(edge.sumCanny(ngray, 1, t2)) + "\t")
#edge.sumCanny(gray)
# Contour detection
ctr = Contours.contours(ngray)
for i in range(5):
threshold=50*i
ctr.withCanny(1, threshold)
if ctr.numberOfContours() == 0:
fout.write( "0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t" )
else:
try:
fout.write( "\t".join(map(str, [ctr.numberOfContours(), ctr.numberOfClosedContours(),
ctr.numberOfOpenContours(), ctr.totalContourArea(), cv2.contourArea(ctr.largestContourByArea()),
ctr.totalPerimeterLength()])) + "\t")
ctr.linelengths()
fout.write( "\t".join(map(str, [ctr.maxLineLength(), ctr.meanLineLength(), ctr.medianLineLength(), ctr.modeLineLength()])) + "\t")
except Exception as e:
sys.stderr.write("There was an error calculating the contours for " + imgfile +": " + e.message + "\n")
fout.write( "0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t" )
fout.write("\n")
def __init__(self):
self.iio = IIO.ImageIO("test.png", "test_o.png")
self.image = None
self.result = None
self.cwd = os.getcwd()
self.ui = UI.UI(self)
def creatTrainigSam(dataPath, opt = 'all', iRnum = 6,iSnum = 12, gRnum = 4,gSnum = 12):
""" Creat training samples(2D) and compute features for each training sample
Parameters
----------
dataPath: str
The directory where training image ROIs are stores.
opt: str
Options for compute features.
iRnum: integer
The number of rings to be divided in computing intensity features
iSnum: integer
The number of sectors to be divided in computing intensity features
gRnum: integer
The number of rings to be divided in computing gradient features
gSnum: integer
The number of sectors to be divided in computing gradient features
"""
file_list = os.listdir(dataPath)
int_feats = np.zeros((len(file_list),4),np.double)
gr_feats = np.zeros((len(file_list),4),np.double)
seg_feats = np.zeros((len(file_list),7),np.double)
all_feats = np.zeros((len(file_list),15),np.double)
LightPatchList = []
counter = 0
for fil in file_list:
im = ImageIO.imReader(dataPath, fil,'tif',2)
# Calculating intensity features
if opt == 'Int' or opt == 'all':
patch = TPatch.TPatch()
patch.initialize(im.data[0])
int_feats[counter,:] = patch.getIntenfeats(iRnum,iSnum)
# Calculating gradient features
if opt == 'Grad' or opt == 'all':
# preprocess
im.downSample(rate = 2)
eqimg = histEqualization.histEqualization(im.sampled_data[0], 16)
smoothimg = filters.gaussian_filter(eqimg, sigma = 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)
patch = TPatch.TPatch()
patch.initialize(smoothimg)
gr_feats[counter,:] = patch.getGradfeats(gRnum,gSnum)
# Calculating segment features
if opt == 'seg' or opt == 'all':
patch = TPatch.TPatch()
patch.initialize(im.data[0])
seg_feats[counter,:] = patch.getSegmentFeats()
if opt == 'all':
all_feats[counter,:] = np.hstack((int_feats[counter,:], gr_feats[counter,:], seg_feats[counter,:]))
lightPatch = TPatch.TLightPatch()
lightPatch.pdata = im.data[0]
lightPatch.feats = all_feats[counter,:]
lightPatch.patch_center = (im.data[0].shape[0]/2, im.data[0].shape[1]/2)
LightPatchList.append(lightPatch)
counter = counter + 1
if opt == 'all':
return LightPatchList
if opt == 'Int':
return int_feats
if opt == 'Grad':
return gr_feats
if opt == 'seg':
return seg_feats
import ScaleSpace as scale_space
import ImageIO as io
import LoG as log
octaves = scale_space.getOctaves()
for li in octaves:
for x in li:
io.showImage(x)
print(x)
log.calculateLoG(octaves)
for n in range(y - 1, y + 2):
if ary[n, m] == 255:
num = num + 1
ary[n, m] = 0
group[n, m] = val
q.append((m, n))
fea.append(num)
com = 0
pos = 0
for k in range(len(fea)):
if fea[k] >= com:
com = fea[k]
pos = k
for i in range(L):
for j in range(W):
if group[j, i] == pos + 1:
ary[j, i] = 255
ary = dilation(dilation(ary))
ary = erosion(erosion(ary))
ary = gradient(ary)
return ary
if __name__ == "__main__":
iio = IIO.ImageIO()
arr = iio.get_input_image("img/I0071695_1.jpg", "L")
ans = run(arr, 205, 380, 170, 325)
plt.imshow(ans)
plt.show()
''' A test suite written to test the image analysis code.
All of these tests should pass'''
import sys
sys.path.append('../Modules/')
import ImageIO
from Analysis import *
import os
imageFile = 'test.jpg'
if not os.path.exists(imageFile):
sys.stderr.write("The test image file " + imageFile + " does not exist! Can't complete tests");
sys.exit(-1)
image = ImageIO.cv2read(imageFile)
grayscale = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# test the statistics module
print "The following tests are performed on the grayscale image:"
print "\nTesting the stats class"
s=Stats()
print "Testing minimum: ", s.min(grayscale)
print "Testing maximum: ", s.max(grayscale)
print "Testing mean: ", s.mean(grayscale)
print "Testing median: ", s.median(grayscale)
print "\nTesting the fft class"
f=FFT()
print "Testing FFT: "
# encoding: utf-8
import tensorflow as tf
import numpy as np
import DataModel
from DataModelSet import DataModelSet
import ImageIO
from HedNetModel import HedNetModel
print "start run..."
filename = "train_data/image_label.csv"
dataModelSet = DataModelSet(ImageIO.read_image_label_model_file(filename))
print "num_examples : %d" % (dataModelSet.num_examples)
for x in xrange(1, 10):
dataModelpart = dataModelSet.next_batch(5)
for dataModel in dataModelpart:
dataModel.discription()
print "stop run..."
import cv2
import ImageIO as io
import math
img =io.getImage("test2.jpg")
Octaves=[]
io.showImage(img)
b= 1/2
for x in range(4):
List = []
a=b
for y in range(5):
a = a* math.sqrt(2)
List.append(cv2.GaussianBlur(img, (5, 5), sigmaX=a, sigmaY=0, borderType=1))
b*=2
Octaves.append(List)
height, width = img.shape[:2]
img = cv2.resize(img, (int(width / 2), int(height / 2)), interpolation=cv2.INTER_AREA)
def getOctaves():
return Octaves
test_correct = 0
for i in trange(len(test_x), ascii=True):
test_correct = test_correct + accuracy.eval(
feed_dict={
x: test_x[i].reshape((1, 64, 64)),
y_: test_y[i].reshape((1, 28)),
keep_prob: 1.
})
test_accuracy = test_correct / len(test_x)
print('the accuracy in fake test set:{}'.format(test_accuracy))
print('*' * 40)
if __name__ == "__main__":
if (sys.argv[1] == 'train'):
x_train_use_ori, y_train_use_ori, x_valid_use_ori, y_valid_use_ori, ori_test_x, ori_test_y = ImageIO.loadTrainImage(
0.1, False)
'''print(x_train_use_ori.shape)
print(y_train_use_ori.shape)
print(x_valid_use_ori.shape)
print(y_valid_use_ori.shape)
print(ori_test_x.shape)
print(ori_test_y.shape)'''
model(x_train_use_ori,
y_train_use_ori,
x_valid_use_ori,
y_valid_use_ori,
ori_test_x,
ori_test_y,
mode='train')
elif (sys.argv[1] == 'test'):
x_train_use_ori, y_train_use_ori, x_valid_use_ori, y_valid_use_ori, ori_test_x, ori_test_y = ImageIO.loadTrainImage(
def model(model_x, model_y, valid_x, valid_y, test_x, test_y, mode='train'):
x = tf.placeholder(np.float32, [None, 64, 64])
y_ = tf.placeholder(tf.float32, [None, 68])
x_image = tf.reshape(x, [-1, 64, 64, 1])
W_conv1 = weight_variable([3, 3, 1, 16])
b_conv1 = bias_variable([16])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # 64*64*16
W_conv1_1 = weight_variable([3, 3, 16, 32])
b_conv1_1 = bias_variable([32])
h_conv1_1 = tf.nn.relu(conv2d(h_conv1, W_conv1_1) + b_conv1_1) # 64*64*32
h_pool1 = max_pool_2x2(h_conv1_1) # 32*32*32
W_conv2 = weight_variable([3, 3, 32, 48])
b_conv2 = bias_variable([48])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) # 32*32*48
W_conv2_1 = weight_variable([3, 3, 48, 64])
b_conv2_1 = bias_variable([64])
h_conv2_1 = tf.nn.relu(conv2d(h_conv2, W_conv2_1) + b_conv2_1) # 32*32*64
h_pool2 = max_pool_2x2(h_conv2_1) # 16*16*64
W_conv3 = weight_variable([3, 3, 64, 128])
b_conv3 = bias_variable([128])
h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3) # 16*16*128
W_conv3_1 = weight_variable([3, 3, 128, 256])
b_conv3_1 = bias_variable([256])
h_conv3_1 = tf.nn.relu(conv2d(h_conv3, W_conv3_1) + b_conv3_1) # 16*16*256
h_pool3 = max_pool_2x2(h_conv3_1) #8*8*256
W_fc1 = weight_variable([8 * 8 * 256, 2048])
b_fc1 = bias_variable([2048])
h_pool2_flat = tf.reshape(h_pool2, [-1, 8 * 8 * 256])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
keep_prob = tf.placeholder(tf.float32)
h_fc1_dropout = tf.nn.dropout(h_fc1, keep_prob)
W_fc2 = weight_variable([2048, 68])
b_fc2 = bias_variable([68])
y_conv = tf.matmul(h_fc1_dropout, W_fc2) + b_fc2
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
train_step = tf.train.AdamOptimizer(0.0001).minimize(cross_entropy)
accuracy = tf.reduce_mean(
tf.cast(tf.equal(tf.argmax(y_, 1), tf.argmax(y_conv, 1)), tf.float32))
mark = tf.argmax(y_conv, 1)
with tf.Session() as sess:
tf.global_variables_initializer().run()
saver = tf.train.Saver(max_to_keep=100)
# saver = tf.train.import_meta_graph('./my_net/epoch_18.ckpt.meta')
if (mode == 'train'):
batch_size = 32
for epoch in range(30):
get_batch = my_batch(model_x, model_y, batch_size)
for i in range(len(model_x) // batch_size):
x_batch, y_batch = next(get_batch)
x_batch = ImageIO.shift_images(x_batch)
_, myloss, train_accuracy = sess.run(
[train_step, cross_entropy, accuracy],
feed_dict={
x: x_batch,
y_: y_batch,
keep_prob: 0.5
})
if i % 25 == 0:
print(
'epoch {} setp {},the train accuracy: {},the loss: {}'
.format(epoch, i, train_accuracy, myloss))
# train_step.run(feed_dict = {x: x_batch, y_: y_batch, keep_prob: 0.5})
print('*' * 40)
test_correct = 0.0
for i in trange(len(valid_x), ascii=True):
test_correct = test_correct + accuracy.eval(
feed_dict={
x: valid_x[i].reshape((1, 64, 64)),
y_: valid_y[i].reshape((1, 68)),
keep_prob: 1.
})
test_accuracy = round(test_correct / len(test_x), 4)
print('epoch {},the accuracy in valid set:{}'.format(
epoch, test_accuracy))
print('*' * 40)
test_correct = 0.0
for i in trange(len(test_x), ascii=True):
test_correct = test_correct + accuracy.eval(
feed_dict={
x: test_x[i].reshape((1, 64, 64)),
y_: test_y[i].reshape((1, 68)),
keep_prob: 1.
})
test_accuracy = round(test_correct / len(test_x), 4)
print('epoch {},the accuracy in test set:{}'.format(
epoch, test_accuracy))
print('*' * 40)
path = saver.save(sess, './my_net/epoch_{}.ckpt'.format(epoch))
print('save path: {}'.format(path))
elif (mode == 'test'):
ckpt = tf.train.get_checkpoint_state("./my_net")
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('*' * 40)
test_correct = 0
for i in trange(len(test_x), ascii=True):
test_correct = test_correct + accuracy.eval(
feed_dict={
x: test_x[i].reshape((1, 64, 64)),
y_: test_y[i].reshape((1, 28)),
keep_prob: 1.
})
test_accuracy = test_correct / len(test_x)
print('the accuracy in fake test set:{}'.format(test_accuracy))
print('*' * 40)
# Mandatory fields
parser.add_argument("filename", help="The filename of the input picture")
parser.add_argument("output", help="The filename of the output picture")
# Available parameters
parser.add_argument("--brightness", metavar='amount', type=int)
parser.add_argument("--contrast", metavar='amount', type=float)
parser.add_argument("--gamma", metavar='amount', type=float)
parser.add_argument("--histogramEQ", type=bool)
parser.add_argument("--histogramMatch", type=str)
parser.add_argument("--saturation",
metavar='amount',
type=float,
help="From -1 to 1")
args = parser.parse_args()
img_arr = ImageIO.load_image(args.filename)
if args.brightness:
img_arr = change_brightness(img_arr, args.brightness)
if args.contrast:
img_arr = change_contrast(img_arr, args.contrast)
if args.gamma:
img_arr = change_gamma(img_arr, args.gamma)
if args.histogramEQ:
img_arr = histogram_equalization(img_arr)
if args.histogramMatch:
target_arr = ImageIO.load_image(args.histogramMatch)
img_arr = histogram_matching(img_arr, target_arr)
if args.saturation:
img_arr = change_saturation(img_arr, args.saturation)
ImageIO.save_image(args.output, img_arr)
def graphrepresentation(myarray,im):
'''creating a graph and add images in tiff image as nodes of graphs '''
G=nx.Graph()
Size=myarray.shape
a=Size[0]
for i in range(0,a-1):
G.add_node(i,point=myarray[i])
#G.add_nodes_from(im)
#G.add_nodes_from(myarray)
'''after create graph we should add edges and weight to edges by mutual information '''
numberofedges=myarray.shape[0]
for i in range (myarray.shape[0]):
sum=0
path='/Users/Shared/TomosynthesisData/processed/5039/'
fileName='5039.tif'
fileName = fileName.split('.')
fileName = fileName[0] + str(i) + '.tif'
im1 = ImageIO.imReader(path,fileName,'tif',2)
for j in range(myarray.shape[0]):
G.add_edge(i,j)
#im1=im[i]
fileName='5039.tif'
fileName = fileName.split('.')
fileName = fileName[0] + str(j) + '.tif'
im2 = ImageIO.imReader(path,fileName,'tif',2)
'''finding mutual information of different features then add them for finding weight'''
feature1=waveletcLBP.concatinationhist(im1.data[0])
feature2=waveletcLBP.concatinationhist(im2.data[0])
weight=weightinginfo(feature1,feature2,im1,im2)
sum=sum+weight
feature1=RBST.shortrunfacility(im1.data[0],im1.data[0])
feature2=RBST.shortrunfacility(im2.data[0],im2.data[0])
weight=weightinginfo(feature1,feature2,im1,im2)
print len(feature1), len(feature2)
feature1=RBST.shortrunfacility(im1.data[0],im1.data[0])
feature2=RBST.shortrunfacility(im2.data[0],im2.data[0])
weight=weightinginfo(feature1,feature2,im1,im2)
sum=sum+weight
G.add_weighted_edges_from([i,j,sum])
listpath=longest_path(G)
"after finding longest we can combine features with the weighting list and order in list"
lengthlist=len(listpath)
for i in range(lengthlist-1):
a=listpath(i)
b=listpath(i+1)
weightonthelist=G.adjacency_ite(a,b)
weightlist=list.append(weightonthelist)
return weightlist, listpath
def test_cv2grayscale(self):
imgGray = ImageIO.cv2grayscale(self.imageFile)
tmpImgGray = cv2.imread(self.imageFile)
tmpImgGray = cv2.cvtColor(tmpImgGray,cv2.COLOR_BGR2GRAY)
equalityBool = (imgGray == tmpImgGray).all()
self.assertTrue(equalityBool)
this_color += region[r_t, c_t, :] * coefs[r_t, c_t]
this_color = np.minimum(np.maximum(this_color, 0), 255)
output[r, c, :] = this_color
print("\rPlease Wait: %d / %d" % (r, target_r), end='')
return output
if __name__ == '__main__':
parser = argparse.ArgumentParser()
# Mandatory fields
parser.add_argument("filename", help="The filename of the input picture")
parser.add_argument("output", help="The filename of the output picture")
parser.add_argument("method", type=str, help="nn, bi, cu or la")
parser.add_argument("r", type=int, help="height")
parser.add_argument("c", type=int, help="width")
args = parser.parse_args()
img_arr = ImageIO.load_image(args.filename)
if args.method == "nn":
img_arr = nearest_neighbour_resampling(img_arr, args.r, args.c)
elif args.method == "bi":
img_arr = bilinear_resampling(img_arr, args.r, args.c)
elif args.method == "cu":
img_arr = bicubic_resampling(img_arr, args.r, args.c)
elif args.method == "la":
img_arr = lanczos_resampling(img_arr, args.r, args.c)
else:
print("Resampling method not supported. Try nn, bi, cu or la.")
ImageIO.save_image(args.output, img_arr)
def setUp(self):
imageFile = '../test/test.jpg'
self.img = ImageIO.cv2read(imageFile)
for f in temp:
images.append(os.path.join(imgfile, f))
continue
# silently skip the bin files that have the gps data
if imgfile.endswith('bin'):
continue
# alert to other files that were skipped
if not (imgfile.endswith('png') | imgfile.endswith('jpg')):
sys.stderr.write("Skipped file: " + imgfile + "\n")
continue
if args.verbose:
sys.stderr.write("Parsing " + imgfile + "\n")
fout.write( imgfile + "\t" )
img = ImageIO.cv2read(os.path.join(args.directory, imgfile))
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ngray = Normalization.equalizeHistograms(gray)
ngray = cv2.GaussianBlur(ngray, (3,3), 0)
feats.detect_kp_ORB(ngray)
fout.write( str(feats.numberKeyPoints()) + "\t" + str(feats.medianKeyPointSize()) + "\t" + str(feats.meanKeyPointSize()) )
for i in range(15):
fout.write("\t" + str(feats.numKeyPoints(i*10)))
fout.write("\n")
def threshold(self, img):
img = ImageIO.grayscale(img)
ret, thresh = cv2.threshold(gray, 0, 255,
cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
return thresh
