def image_train(self, indir, outdir):
''' image_train(self)
convert image to patch for all images in imdir
'''
# loop for every images in directory
mytime = timeLog('../timelogs/image_train')
make_dir(outdir)
for k, data in enumerate(self.data):
try:
print 'Image-Train:', data[0], k,'/',len(self.data)
imgname = data[0]
coor = data[1]
img = image_load(imgname, indir)
mytime.start(imgname)
patch_stack, label_stack = self.multiscale_patch_ext(img, coor)
patch_stack, label_stack = stack2array(patch_stack, label_stack)
data_save(patch_stack, label_stack,
os.path.splitext(imgname)[0], outdir)
except:
continue
finally:
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, image_train_finished')
mytime.final('image train finished')
return
def geneHotmap(self, indir, outdir):
'''geneHotmap(self, indir, outdir)
convert stacks from image_test to hotmaps
'''
mytime = timeLog('../timelogs/testHotmap')
make_dir(outdir)
for k, data in enumerate(self.data):
try:
print 'Generate hotmaps:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
imgname = os.path.splitext(imgname)[0]
s = pickle_load(imgname, indir)
pnt = stack2image(s[0])
blk = stack2image(s[1])
image_save(pnt, 'point'+imgname+'.png', outdir)
image_save(blk, 'block'+imgname+'.png', outdir)
except:
continue
finally:
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, hotmap generation finished')
mytime.final('hotmap generation finished')
return
def seed2image(self, roidir, imdir, rawdir, outdir):
'''seed2image(self, indir, outdir)
convert roi detection to image
'''
mytime = timeLog('../timelogs/regionOfInterest')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate region of interests:', data[0], k, '/', len(
self.data)
imgname = data[0]
mytime.start(imgname)
basename = os.path.splitext(imgname)[0]
blkname = 'block' + basename + '.png' # use block plot as hotmap
roi = pickle_load(os.path.splitext(imgname)[0], roidir)
raw = image_load(imgname, rawdir)
img = image_load(blkname, imdir)
bb = image2bb(img)
bb = bbenlarge(bb, img.shape)
img = roi2image(roi, bb, img.shape)
image_save(img, imgname, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, roi generation finished')
mytime.final('roi generation finished')
return
def geneROI(self, imdir, indir, outdir, thre = 128):
''' geneROI(self, indir, outdir)
crop the region of interest from the hotmap
'''
mytime = timeLog('../timelogs/regionOfInterest')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate region of interests:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
basename = os.path.splitext(imgname)[0]
blkname = 'block' + basename + '.png'
raw = image_load(imgname, imdir)
img = image_load(blkname, indir)
bb = image2bb(img, thre)
bb = bbenlarge(bb, img.shape)
roi_stack = image2roi(raw, bb)
pickle_save(roi_stack, basename, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, roi generation finished')
mytime.final('roi generation finished')
return
def seed2image(self, roidir, imdir, rawdir, outdir):
'''seed2image(self, indir, outdir)
convert roi detection to image
'''
mytime = timeLog('../timelogs/regionOfInterest')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate region of interests:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
basename = os.path.splitext(imgname)[0]
blkname = 'block' + basename + '.png' # use block plot as hotmap
roi = pickle_load(os.path.splitext(imgname)[0], roidir)
raw = image_load(imgname, rawdir)
img = image_load(blkname, imdir)
bb = image2bb(img)
bb = bbenlarge(bb, img.shape)
img = roi2image(roi, bb, img.shape)
image_save(img, imgname, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, roi generation finished')
mytime.final('roi generation finished')
return
def geneROI(self, imdir, indir, outdir, thre=128):
''' geneROI(self, indir, outdir)
crop the region of interest from the hotmap
'''
mytime = timeLog('../timelogs/regionOfInterest')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate region of interests:', data[0], k, '/', len(
self.data)
imgname = data[0]
mytime.start(imgname)
basename = os.path.splitext(imgname)[0]
blkname = 'block' + basename + '.png'
raw = image_load(imgname, imdir)
img = image_load(blkname, indir)
bb = image2bb(img, thre)
bb = bbenlarge(bb, img.shape)
roi_stack = image2roi(raw, bb)
pickle_save(roi_stack, basename, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, roi generation finished')
mytime.final('roi generation finished')
return
def clf_test(self):
''' clf_test(self, clfname)
test the classifier the features generated
clfname:_string_ contains filename of the classifier
Return (pred, label) 1D_numpy_arrays for prediction and labels '''
mytime = timeLog('../timelogs/clf_test')
mytime.start()
print 'Testing Classifier ...'
plotdir = '../plot/' + time.ctime()
make_dir(plotdir)
# write classifier name to txt file
open(os.path.join(plotdir, self.mode), 'a').close()
if not 'decision_function' in dir(self.classifier):
self.classifier.decision_function = self.classifier.predict
self.prediction = self.classifier.decision_function(self.feature_test)
#plot.pplot(self.prediction, self.label_test, plotdir)
#if self.mode == 'adaboost':
# test_score = []
# train_score = []
# for pred in self.classifier.staged_decision_function(self.feature_test):
# test_score.append(self.classifier.loss_(self.label_test, pred))
# for pred in self.classifier.staged_decision_function(self.feature):
# train_score.append(self.classifier.loss_(self.label, pred))
# plot.eplot(test_score, train_score, plotdir)
# report
mail(MAIL_REC, '<Coding Message!!!>, clf_test_finished')
mytime.end()
mytime.final()
return
def geneHotmap(self, indir, outdir):
'''geneHotmap(self, indir, outdir)
convert stacks from image_test to hotmaps
'''
mytime = timeLog('../timelogs/testHotmap')
make_dir(outdir)
for k, data in enumerate(self.data):
try:
print 'Generate hotmaps:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
imgname = os.path.splitext(imgname)[0]
s = pickle_load(imgname, indir)
pnt = stack2image(s[0])
blk = stack2image(s[1])
image_save(pnt, 'point' + imgname + '.png', outdir)
image_save(blk, 'block' + imgname + '.png', outdir)
except:
continue
finally:
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, hotmap generation finished')
mytime.final('hotmap generation finished')
return
def image_train(self, indir, outdir):
''' image_train(self)
convert image to patch for all images in imdir
'''
# loop for every images in directory
mytime = timeLog('../timelogs/image_train')
make_dir(outdir)
for k, data in enumerate(self.data):
try:
print 'Image-Train:', data[0], k, '/', len(self.data)
imgname = data[0]
coor = data[1]
img = image_load(imgname, indir)
mytime.start(imgname)
patch_stack, label_stack = self.multiscale_patch_ext(img, coor)
patch_stack, label_stack = stack2array(patch_stack,
label_stack)
data_save(patch_stack, label_stack,
os.path.splitext(imgname)[0], outdir)
except:
continue
finally:
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, image_train_finished')
mytime.final('image train finished')
return
def clf_test(self):
''' clf_test(self, clfname)
test the classifier the features generated
clfname:_string_ contains filename of the classifier
Return (pred, label) 1D_numpy_arrays for prediction and labels '''
mytime = timeLog('../timelogs/clf_test')
mytime.start()
print 'Testing Classifier ...'
plotdir = '../plot/'+time.ctime()
make_dir(plotdir)
# write classifier name to txt file
open(os.path.join(plotdir, self.mode), 'a').close()
if not 'decision_function' in dir(self.classifier):
self.classifier.decision_function = self.classifier.predict
self.prediction = self.classifier.decision_function(self.feature_test)
#plot.pplot(self.prediction, self.label_test, plotdir)
#if self.mode == 'adaboost':
# test_score = []
# train_score = []
# for pred in self.classifier.staged_decision_function(self.feature_test):
# test_score.append(self.classifier.loss_(self.label_test, pred))
# for pred in self.classifier.staged_decision_function(self.feature):
# train_score.append(self.classifier.loss_(self.label, pred))
# plot.eplot(test_score, train_score, plotdir)
# report
mail(MAIL_REC, '<Coding Message!!!>, clf_test_finished')
mytime.end()
mytime.final()
return
def data_load(self, datadir):
mytime = timeLog('../timelogs/data_load')
mytime.start()
print 'Loading data ....',
P, L = data_load(datadir)
P = numpy.uint8(P)
L = numpy.uint8(L)
P_train, P_test, L_train, L_test = train_test_split(P, L, train_size = 0.8, test_size = 0.2, random_state = 22)
self.feature = P_train
self.label = L_train
self.feature_test = P_test
self.label_test = L_test
mytime.end()
mytime.final()
def data_load(self, datadir):
mytime = timeLog('../timelogs/data_load')
mytime.start()
print 'Loading data ....',
P, L = data_load(datadir)
P = numpy.uint8(P)
L = numpy.uint8(L)
P_train, P_test, L_train, L_test = train_test_split(P,
L,
train_size=0.8,
test_size=0.2,
random_state=22)
self.feature = P_train
self.label = L_train
self.feature_test = P_test
self.label_test = L_test
mytime.end()
mytime.final()
def imageprocess(self, indir, outdir, clf):
mytime = timeLog('../timelogs/image_test')
make_dir(outdir)
# loop for every images in directory
if not 'decision_function' in dir(clf):
clf.decision_function = clf.predict
print 'decision function created!'
for k, data in enumerate(self.data):
print 'Image-Process:', data[0], k, '/', len(self.data)
imgname = data[0]
image = data[1]
mytime.start(imgname)
img = image_load(imgname, indir)
res_stack = self.multiscale_test2(img, image)
pickle_save(res_stack, os.path.splitext(imgname)[0], outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, image_test_finished!')
mytime.final('image test finished')
return
def clf_train(self):
''' clf_train(self, clfname, mode = 'adaboost')
train the classifier with feature generated
clfname: _string_ contains filename of the classifier to save
mode: {'adaboost', 'SVM', 'vjcascade', 'gridSearch'} _string_,
classifier type, where gridSearch is searched over
different types of SVM classifiers. '''
mytime = timeLog('../timelogs/clf_train')
mytime.start()
print 'Training Classifier on ',
print len(self.label), 'Samples'
self.classifier = self.classifier.fit(self.feature, self.label)
mail(MAIL_REC, '<Coding Message!!!>, clf_train_finished')
mytime.end()
mytime.final()
return
def imageprocess(self, indir, outdir, clf):
mytime = timeLog('../timelogs/image_test')
make_dir(outdir)
# loop for every images in directory
if not 'decision_function' in dir(clf):
clf.decision_function = clf.predict
print 'decision function created!'
for k, data in enumerate(self.data):
print 'Image-Process:', data[0], k,'/',len(self.data)
imgname = data[0]
image = data[1]
mytime.start(imgname)
img = image_load(imgname, indir)
res_stack = self.multiscale_test2(img, image)
pickle_save(res_stack, os.path.splitext(imgname)[0], outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, image_test_finished!')
mytime.final('image test finished')
return
def clf_train(self):
''' clf_train(self, clfname, mode = 'adaboost')
train the classifier with feature generated
clfname: _string_ contains filename of the classifier to save
mode: {'adaboost', 'SVM', 'vjcascade', 'gridSearch'} _string_,
classifier type, where gridSearch is searched over
different types of SVM classifiers. '''
mytime = timeLog('../timelogs/clf_train')
mytime.start()
print 'Training Classifier on ',
print len(self.label), 'Samples'
self.classifier = self.classifier.fit(self.feature, self.label)
mail(MAIL_REC, '<Coding Message!!!>, clf_train_finished')
mytime.end()
mytime.final()
return
def roi_test2(self, indir, outdir, clf):
''' roi_test2(self, indir, outdir, clf)
apply detection on region of interest
'''
mytime = timeLog('../timelogs/image_test')
make_dir(outdir)
# loop for every images in directory
if not 'decision_function' in dir(clf):
clf.decision_function = clf.predict
print 'decision function created!'
for k, data in enumerate(self.data):
print 'Image-Test:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
roiname = os.path.splitext(imgname)[0]
roistack = pickle_load(roiname, indir)
predpnt_stack = []
predblk_stack = []
for img in roistack:
patch = self.image2feat(img,
self.psize,
self.ssize,
self.nob,
self.codebook,
target=self.featureMode,
edgeMode=self.edgeMode)
pred = self.feat2pred(img, patch, clf)
predpnt = self.label2image(img, pred, mode='point')
predblk = self.label2image(img, pred, mode='block')
predpnt_stack.append(predpnt)
predblk_stack.append(predblk)
pickle_save((predpnt_stack, predblk_stack),
os.path.splitext(imgname)[0], outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, image_test_finished!')
mytime.final('image test finished')
return
def prepareImg(self, dataStack, indir, outdir):
''' image_pretest(self)
test and show the ground truth label images from the training and testing data
before we start the training process.
'''
mytime = timeLog('../timelogs/prepare_img')
make_dir(outdir)
# loop for every images in directory
for k, data in enumerate(dataStack):
imgname, coor = data
print imgname, str(k), '/', len(dataStack)
mytime.start(imgname)
img = image_load(imgname, indir)
img, coor = imsize_reduce((1400, 1400), img, coor)
image_save(img, imgname, outdir)
dataStack[k] = (imgname, coor)
mytime.end()
mail(MAIL_REC, '<Coding Message!!!>, image_pretest_finished')
mytime.final('prepare images finished.')
return dataStack
def roi_test2(self, indir, outdir, clf):
''' roi_test2(self, indir, outdir, clf)
apply detection on region of interest
'''
mytime = timeLog('../timelogs/image_test')
make_dir(outdir)
# loop for every images in directory
if not 'decision_function' in dir(clf):
clf.decision_function = clf.predict
print 'decision function created!'
for k, data in enumerate(self.data):
print 'Image-Test:', data[0], k,'/',len(self.data)
imgname = data[0]
mytime.start(imgname)
roiname = os.path.splitext(imgname)[0]
roistack = pickle_load(roiname, indir)
predpnt_stack = []
predblk_stack = []
for img in roistack:
patch = self.image2feat(img,
self.psize, self.ssize,
self.nob, self.codebook,
target = self.featureMode,
edgeMode = self.edgeMode)
pred = self.feat2pred(img, patch, clf)
predpnt = self.label2image(img, pred, mode = 'point')
predblk = self.label2image(img, pred, mode = 'block')
predpnt_stack.append(predpnt)
predblk_stack.append(predblk)
pickle_save((predpnt_stack, predblk_stack), os.path.splitext(imgname)[0], outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, image_test_finished!')
mytime.final('image test finished')
return
def geneTxt(self, indir, outdir, thre=128):
'''geneTxt(self, indir, outdir)
generate csv file from the hotmaps to be in ICDAR standard format
'''
mytime = timeLog('../timelogs/testTxtFile')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate txt files:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
basename = os.path.splitext(imgname)[0]
blkname = 'block' + basename + '.png' # use block plot as hotmap
txtname = 'res_img_' + basename + '.txt'
img = image_load(blkname, indir)
bb = image2bb(img, thre)
s = bb2string(bb)
txt_save(s, txtname, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, txt generation finished')
mytime.final('txt file generation finished')
return
def geneROI2(self, imdir, indir, outdir, thre = 128):
''' geneROI2(self, indir, outdir)
crop the region of interest from the stack
'''
mytime = timeLog('../timelogs/testHotmap')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate roi:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
imgname = os.path.splitext(imgname)[0]
s = pickle_load(imgname, indir)[1]
roi_stack = []
for layer in s:
bb = image2bb(img, thre)
bb = bbenlarge(bb, img.shape)
roi_stack.append(image2roi(raw, bb))
pickle_save(roi_stack, basename, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, hotmap generation finished')
mytime.final('hotmap generation finished')
return
def geneROI2(self, imdir, indir, outdir, thre=128):
''' geneROI2(self, indir, outdir)
crop the region of interest from the stack
'''
mytime = timeLog('../timelogs/testHotmap')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate roi:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
imgname = os.path.splitext(imgname)[0]
s = pickle_load(imgname, indir)[1]
roi_stack = []
for layer in s:
bb = image2bb(img, thre)
bb = bbenlarge(bb, img.shape)
roi_stack.append(image2roi(raw, bb))
pickle_save(roi_stack, basename, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, hotmap generation finished')
mytime.final('hotmap generation finished')
return
def geneTxt(self, indir, outdir, thre = 128):
'''geneTxt(self, indir, outdir)
generate csv file from the hotmaps to be in ICDAR standard format
'''
mytime = timeLog('../timelogs/testTxtFile')
make_dir(outdir)
for k, data in enumerate(self.data):
print 'Generate txt files:', data[0], k, '/', len(self.data)
imgname = data[0]
mytime.start(imgname)
basename = os.path.splitext(imgname)[0]
blkname = 'block'+basename+'.png' # use block plot as hotmap
txtname = 'res_img_'+basename+'.txt'
img = image_load(blkname, indir)
bb = image2bb(img, thre)
s = bb2string(bb)
txt_save(s, txtname, outdir)
mytime.end()
mail(self.mail_rec, '<Coding Message!!!>, txt generation finished')
mytime.final('txt file generation finished')
return
def roi_test(self, indir, rawdir, outdir, clf):
''' roi_test(self, indir, outdir, clf)
apply detection on region of interest
'''
mytime = timeLog('../timelogs/image_test')
make_dir(outdir)
# loop for every images in directory
if not 'decision_function' in dir(clf):
clf.decision_function = clf.predict
print 'decision function created!'
for k, data in enumerate(self.data):
try:
print 'ROI test:', data[0], k, '/', len(self.data)
imgname = data[0]
img = data[2]
mytime.start(imgname)
raw = image_load(imgname, rawdir)
stackname = os.path.splitext(imgname)[0]
s = pickle_load(stackname, indir)[1]
layer_stack = []
for layer in s:
bb = image2bb(layer)
#bb = bbenlarge(bb, layer.shape)
raw = img_resize(raw, layer.shape)
rois = image2roi(raw, bb)
predpnt_stack = []
#predblk_stack = []
for rimg00 in rois:
rimg0 = imreduce(64, rimg00)
predpnt = numpy.zeros_like(rimg0)
for ang in [-6, -4, -2, 0, 2, 4, 6]:
rimg = rotate(rimg0, ang)
patch = self.image2feat(rimg,
self.psize, self.ssize,
self.nob, self.codebook,
target = self.featureMode,
edgeMode = self.edgeMode)
pred = self.feat2pred(rimg, patch, clf)
predpnt0 = self.label2image(rimg, pred, mode = 'point')
predpnt = predpnt + rotate(predpnt0, -ang)
for asp in [0.6, 0.8, 1, 1.2, 1.4]:
rimg = img_resize(rimg0, [int(rimg0.shape[0]*asp), rimg0.shape[1]])
patch = self.image2feat(rimg,
self.psize, self.ssize,
self.nob, self.codebook,
target = self.featureMode,
edgeMode = self.edgeMode)
pred = self.feat2pred(rimg, patch, clf)
predpnt0 = self.label2image(rimg, pred, mode = 'point')
predpnt = predpnt+img_resize(predpnt0, rimg0.shape)
predcc = pnt2cc(rimg0, predpnt)
predcc = img_resize(predcc, rimg00.shape)
#predblk = self.label2image(img, pred, mode = 'block')
predpnt_stack.append(predcc)
#predblk_stack.append(predblk)
layer_stack.append(roi2image(predpnt_stack, bb, layer.shape))
img = stack2image(layer_stack, img)
pickle_save(layer_stack, stackname, outdir)
image_save(img, imgname.split('.')[0]+'.png', outdir)
mytime.end()
except:
mytime.end()
continue
mail(self.mail_rec, '<Coding Message!!!>, hotmap generation finished')
mytime.final('hotmap generation finished')
return
def roi_test(self, indir, rawdir, outdir, clf):
''' roi_test(self, indir, outdir, clf)
apply detection on region of interest
'''
mytime = timeLog('../timelogs/image_test')
make_dir(outdir)
# loop for every images in directory
if not 'decision_function' in dir(clf):
clf.decision_function = clf.predict
print 'decision function created!'
for k, data in enumerate(self.data):
try:
print 'ROI test:', data[0], k, '/', len(self.data)
imgname = data[0]
img = data[2]
mytime.start(imgname)
raw = image_load(imgname, rawdir)
stackname = os.path.splitext(imgname)[0]
s = pickle_load(stackname, indir)[1]
layer_stack = []
for layer in s:
bb = image2bb(layer)
#bb = bbenlarge(bb, layer.shape)
raw = img_resize(raw, layer.shape)
rois = image2roi(raw, bb)
predpnt_stack = []
#predblk_stack = []
for rimg00 in rois:
rimg0 = imreduce(64, rimg00)
predpnt = numpy.zeros_like(rimg0)
for ang in [-6, -4, -2, 0, 2, 4, 6]:
rimg = rotate(rimg0, ang)
patch = self.image2feat(rimg,
self.psize,
self.ssize,
self.nob,
self.codebook,
target=self.featureMode,
edgeMode=self.edgeMode)
pred = self.feat2pred(rimg, patch, clf)
predpnt0 = self.label2image(rimg,
pred,
mode='point')
predpnt = predpnt + rotate(predpnt0, -ang)
for asp in [0.6, 0.8, 1, 1.2, 1.4]:
rimg = img_resize(
rimg0,
[int(rimg0.shape[0] * asp), rimg0.shape[1]])
patch = self.image2feat(rimg,
self.psize,
self.ssize,
self.nob,
self.codebook,
target=self.featureMode,
edgeMode=self.edgeMode)
pred = self.feat2pred(rimg, patch, clf)
predpnt0 = self.label2image(rimg,
pred,
mode='point')
predpnt = predpnt + img_resize(
predpnt0, rimg0.shape)
predcc = pnt2cc(rimg0, predpnt)
predcc = img_resize(predcc, rimg00.shape)
#predblk = self.label2image(img, pred, mode = 'block')
predpnt_stack.append(predcc)
#predblk_stack.append(predblk)
layer_stack.append(
roi2image(predpnt_stack, bb, layer.shape))
img = stack2image(layer_stack, img)
pickle_save(layer_stack, stackname, outdir)
image_save(img, imgname.split('.')[0] + '.png', outdir)
mytime.end()
except:
mytime.end()
continue
mail(self.mail_rec, '<Coding Message!!!>, hotmap generation finished')
mytime.final('hotmap generation finished')
return
