def run_evaluation_boundary_predictions(network_name):
pathPrefix = './AC4_small/'
img_gt_search_string = pathPrefix + 'labels/*.tif'
img_pred_search_string = pathPrefix + 'boundaryProbabilities/'+network_name+'/*.tif'
img_files_gt = sorted( glob.glob( img_gt_search_string ) )
img_files_pred = sorted( glob.glob( img_pred_search_string ) )
allVI = []
allVI_split = []
allVI_merge = []
allRand = []
allRand_split = []
allRand_merge = []
for i in xrange(np.shape(img_files_pred)[0]):
print img_files_pred[i]
im_gt = mahotas.imread(img_files_gt[i])
im_pred = mahotas.imread(img_files_pred[i])
im_pred = im_pred / 255.0
VI_score = []
VI_score_split = []
VI_score_merge = []
Rand_score = []
Rand_score_split = []
Rand_score_merge = []
start_time = time.clock()
for thresh in np.arange(0,1,0.05):
# white regions, black boundaries
im_seg = im_pred>thresh
# connected components
seeds, nr_regions = mahotas.label(im_seg)
result = segmentation_metrics(im_gt, seeds, seq=False)
VI_score.append(result['VI']['F-score'])
VI_score_split.append(result['VI']['split'])
VI_score_merge.append(result['VI']['merge'])
Rand_score.append(result['Rand']['F-score'])
Rand_score_split.append(result['Rand']['split'])
Rand_score_merge.append(result['Rand']['merge'])
print "This took in seconds: ", time.clock() - start_time
allVI.append(VI_score)
allVI_split.append(VI_score_split)
allVI_merge.append(VI_score_merge)
allRand.append(Rand_score)
allRand_split.append(Rand_score_split)
allRand_merge.append(Rand_score_merge)
with open(pathPrefix+network_name+'.pkl', 'wb') as file:
cPickle.dump((allVI, allVI_split, allVI_merge, allRand, allRand_split, allRand_merge), file)
def file_reader(filename, **kwds):
'''Read data from any format supported by PIL or freeimage if mahotas is
installed
Note that only when mahotas and freeimage are installed it is possible
to read 16-bit tiff files.
Parameters
----------
filename: str
By using '*' it is possible to load a collection of images of the same
size into a three dimensional dataset.
'''
if '*' in filename:
from glob import glob
flist=glob(filename)
flist.sort()
imsample = imread(flist[0])
w=imsample.shape[0]
h=imsample.shape[1]
d=len(flist)
dc=np.zeros((w,h,d))
for i in xrange(d):
dc[:,:,i] = imread(flist[i])
else:
dc = imread(filename)
dt = 'image'
return [{'data':dc,
'mapped_parameters': {
'name': filename,
'original_filename' : filename,
'record_by': dt,
'signal' : None,
}
}]
def load_image(f):
'Load the triple (PROTEIN, DNA, ROIS)'
import mahotas as mh
f = DATADIR+f
return mh.imread(f.replace('dna', 'protein')), \
mh.imread(f), \
mh.imread(f.replace('dna', 'rois'))
def compare1(f):
rois = mh.imread(f.replace('rois2', 'rois'))
rois2 = mh.imread(f)
rarea = (rois != 0).ravel()
rarea2 = (rois2 != 0).ravel()
return (rarea.mean(),
rarea2.mean(),
np.corrcoef(rarea, rarea2)[0,1])
def readImages(imgCount, inputpath, labelpath):
"""
reads all the images in the stored file location, as well as generates random pixel coordinates to create patches from
:param imgCount: the number of images used for training the classifier
:param filepath: the file path to the images
"""
input=[]
labels=[]
for i in range(imgCount):
input.append((mahotas.imread(inputpath+str(i)+".tif")))
labels.append((mahotas.imread(labelpath+str(i)+".tif")))
return [input, labels]
def compare_arand(f):
from sklearn import metrics
from scipy.spatial import distance
rois = mh.imread(f.replace('rois2', 'rois'))
rois2 = mh.imread(f)
rois = (rois.ravel() != 0)
rois2 = (rois2.ravel() != 0)
arand = metrics.adjusted_rand_score(rois, rois2)
# Note that scipy returns the Jaccard Distance, which is 1 - Jaccard Index
# sklearn does not really implement jaccard, but an interpretation where
# jaccard is just a synonym for accuracy.
jaccard = 1. - distance.jaccard(rois, rois2)
mcc = metrics.matthews_corrcoef(rois, rois2)
return arand, jaccard, mcc
def open_image_and_gold(image_index, crop_from, crop_size):
path = image_path_format_string.format(image_index)
gold_path = gold_image_path_format_string.format(image_index)
# Open raw image
image = np.float32(normalize_image(mahotas.imread(path)[crop_from[0]:crop_from[0]+crop_size,crop_from[1]:crop_from[1]+crop_size]))
# Open gold standard image
gold_image = mahotas.imread(gold_path)[crop_from[0]:crop_from[0]+crop_size,crop_from[1]:crop_from[1]+crop_size]
# Convert to ids
if len(gold_image.shape) == 3:
gold_image = (np.uint32(gold_image[:,:,0]) * 2**16 + np.uint32(gold_image[:,:,1]) * 2**8 + np.uint32(gold_image[:,:,2])).squeeze()
return (image, gold_image)
def binarization(dirs):
# Create binarization feature:
# if pixel intensity greater than a threshold, assign it as 1, otherwise 0
# This feature robust to light
features = [] # store local feature descriptors
for idir in range(len(dirs)):
files = [name for name in os.listdir(dirs[idir])
if os.path.isfile(os.path.join(dirs[idir], name))]
for ifile in range(len(files)):
if files[ifile][-3:] != 'jpg': # ignore non-image files
continue
image = mh.imread(dirs[idir]+files[ifile]).astype(np.uint8) # read image
if (len(image.shape) == 3): # convert to gray if colored
image = mh.colors.rgb2gray(image, dtype=np.uint8)
# Calculate the binarization threshold using otsu method
threshold = mh.thresholding.otsu(image)
binarized = image > threshold
# Calculate the ratio between area white and area black
nPix = float(image.shape[0]*image.shape[1])
area_ratio = len(binarized[binarized == 1])/nPix
features.append(area_ratio)
features = np.array(features)
return features
def load_data(augmented=True, image_dirs=image_dirs):
X = []
y = []
suff = 'A' if augmented else ''
for i in range(len(image_dirs)):
for pth in (Path.cwd() / image_dirs[i] / ('data' + str(img_rows) + suff)).iterdir():
im = mh.imread(str(pth), True)
X.append(im)
y.append(i)
p = np.random.permutation(len(X))
X = [X[i] for i in p]
y = [y[i] for i in p]
if train_split == 0: # Use everything both to train and validate
X_train = np.array(X, np.uint8)
y_train = np.array(y, np.uint8)
X_test = X_train[::]
y_test = y_train[::]
else:
train_size = int(len(y) * train_split)
X_train = np.array(X[:train_size], np.uint8)
y_train = np.array(y[:train_size], np.uint8)
X_test = np.array(X[train_size:], np.uint8)
y_test = np.array(y[train_size:], np.uint8)
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
return img_to_float(X_train, y_train, X_test, y_test)
def executa_extracao_n(base_treino, metodo, n=1):
inicio = time()
lista_imagens = arq.busca_arquivos(base_treino, "*.png")
n_imgs_treino = len(lista_imagens)
for lado in range(8,n+1,4):
atributos = []
rotulos = []
arq_treino = base_treino + "base_PFTAS_"+str(lado)+"x"+str(lado)+".svm"
## INICIO DO PROCESSO DE EXTRACAO DE ATRIBUTOS
for arq_imagem in lista_imagens:
print("Arquivo: " + arq_imagem)
imagem = mh.imread(arq_imagem)
if (imagem != None):
classe, _ = ex.classe_arquivo(arq_imagem)
print("executa_extracao_n - shape imagem:" + str(imagem.shape))
# Extrai os atributos e gera os arquivos dos patches da base de treino
atrs,rots = extrai_pftas_patches_n(imagem, classe, lado)
atributos += atrs
rotulos += rots
dump_svmlight_file(atributos, rotulos, arq_treino)
log("Extraidos atributos da base " + base_treino + " utilizando " + metodo + "\n para " + str(n_imgs_treino) + "imagens")
# Exibe o tempo de execução
log(str(time()-inicio) + "EXTRAÇÃO")
def test_rgba():
rgba = path.join(
path.dirname(__file__),
'data',
'rgba.png')
rgba = imread(rgba)
assert np.all(np.diff(rgba[:,:,3].mean(1)) < 0 ) # the image contains an alpha gradient
def create_fullContour_labels():
for purpose in ['train','validate','test']:
img_search_string = '/media/vkaynig/Data1/Cmor_paper_data/labels/' + purpose + '/*.tif'
img_files = sorted( glob.glob( img_search_string ) )
for img_index in xrange(np.shape(img_files)[0]):
print 'reading image ' + img_files[img_index] + '.'
label = mahotas.imread(img_files[img_index])
#membranes = np.logical_and(label[:,:,0]==0, label[:,:,1]==255)
boundaries = label == -1
boundaries[0:-1,:] = np.logical_or(boundaries[0:-1,:], np.diff(label, axis=0)!=0)
boundaries[:,0:-1] = np.logical_or(boundaries[:,0:-1], np.diff(label, axis=1)!=0)
membranes = np.logical_or(boundaries, label[:,:]==0)
shrink_radius=5
y,x = np.ogrid[-shrink_radius:shrink_radius+1, -shrink_radius:shrink_radius+1]
disc = x*x + y*y <= (shrink_radius ** 2)
non_membrane = 1-mahotas.dilate(membranes, disc)
img_file_name = os.path.basename(img_files[img_index])[:-4]+ '.tif'
outputPath = '/media/vkaynig/Data1/Cmor_paper_data/labels/'
print 'writing image: ' + img_file_name
mahotas.imsave(outputPath + 'background_fullContour/' + purpose + '/' + img_file_name, np.uint8(non_membrane*255))
mahotas.imsave(outputPath + 'membranes_fullContour/' + purpose + '/' + img_file_name, np.uint8(membranes*255))
def normalize_all_input(img_search_string = '/media/vkaynig/NewVolume/IAE_ISBI2012/images/images/*.tif'):
img_files = sorted( glob.glob( img_search_string ) )
for fileName in img_files:
img = mahotas.imread(fileName)
clahe.clahe(img, img, 2.0)
# img = normalizeImage(img, saturation_level=0.05)
mahotas.imsave(fileName, np.uint8(img))
def load_stack(folder_name, ifrom=None, ito=None):
stack = None
input_files = sorted(glob.glob(os.path.join(folder_name, '*')))
input_files = [i for i in input_files if not i.endswith('.db')]
if ifrom is not None:
if ito is not None:
input_files = input_files[ifrom:ito]
else:
input_files = input_files[ifrom:ifrom+1]
for i, file_name in enumerate(input_files):
if file_name.endswith('h5') or file_name.endswith('hdf5'):
infile = h5py.File(file_name)
im = infile['/labels'][...]
else:
im = mahotas.imread(file_name)
if len(im.shape) == 3 and im.shape[2] == 3:
im = np.int32(im[ :, :, 0 ]) * 2**16 + np.int32(im[ :, :, 1 ]) * 2**8 + np.int32(im[ :, :, 2 ])
elif len(im.shape) == 3 and im.shape[2] == 4:
im = np.int32(im[ :, :, 0 ]) * 2**16 + np.int32(im[ :, :, 1 ]) * 2**8 + np.int32(im[ :, :, 2 ]) + np.int32(im[ :, :, 3 ]) * 2**24
if stack is None:
stack = np.zeros((len(input_files), im.shape[0], im.shape[1]), dtype=im.dtype)
print 'Stack size={0}, dtype={1}.'.format(stack.shape, stack.dtype)
stack[i,:,:] = im
return stack
def __init__(self, path, scale_depth, scale_from=0, step_coeff=3):
"""
Parameters
----------
path : str
path to an image
scale_depth : int
how many levels of blur to create
scale_from : int
from which level to start (0 = no blur at all)
step_coeff : float
"""
self.x, self.y, self.z = (0, 0, 0)
self.filename = os.path.basename(path)
self.image = []
orig_image = mahotas.imread(path, as_grey=True)
self.width = np.size(orig_image, 1)
self.height = np.size(orig_image, 0)
if scale_from == 0:
self.image.append(orig_image)
else:
self.image.append(None)
for i in range(1, scale_depth + 1):
if i < scale_from:
self.image.append(None)
else:
sigma = (step_coeff * i, step_coeff * i)
print("sigma: %s" % (sigma,))
self.image.append(ndimage.gaussian_filter(orig_image, sigma))
def exibe_cria_patches(diretorio, n_divs=3):
lista_imagens = arq.busca_arquivos(diretorio, "*.png")
#converte para escala de cinza
for arquivo in lista_imagens:
img = mh.imread(arquivo)
#patches = bp.patches(img, TAM_PATCH, rgb=True)
img_cinza = cv2.imread(arquivo, cv2.IMREAD_GRAYSCALE)
#img_cinza = bp.limpa_imagem(img_cinza)
#patches_cinza = bp.cria_patches(img_cinza, TAM_PATCH)
#patches_cinza = bp.patches(img_cinza, TAM_PATCH, rgb=False)
# exibe a imagem original
plt.imshow(img)
#patches = cria_patches3(img, n_divs, rgb=True)
patches = cria_patches3(img, 32, rgb=True)
print("Total de patches: %f", len(patches))
print("Tamanho do patch: %i", patches[0].shape)
#y = int(math.sqrt(4**n_divs))
y = int(math.sqrt(len(patches)))
x = y
fig,axes = plt.subplots(x,y)
for i, ax in enumerate(axes.ravel()):
if (i == len(patches)):
break;
ax.xaxis.set_major_formatter(plt.NullFormatter())
ax.yaxis.set_major_formatter(plt.NullFormatter())
im = ax.imshow(patches[i],'gray')
plt.show()
def test_determinant_zero():
img = mahotas.imread(path.join(
path.abspath(path.dirname(__file__)),
'data',
'determinant_zero.png'))
points = surf(img, threshold=.0)
assert type(points) == np.ndarray
def exibe_cria_patches(lista_imagens):
#converte para escala de cinza
for arquivo in lista_imagens:
img = mh.imread(arquivo)
#patches = bp.patches(img, TAM_PATCH, rgb=True)
img_cinza = cv2.imread(arquivo, cv2.IMREAD_GRAYSCALE)
#img_cinza = bp.limpa_imagem(img_cinza)
#patches_cinza = bp.cria_patches(img_cinza, TAM_PATCH)
#patches_cinza = bp.patches(img_cinza, TAM_PATCH, rgb=False)
# exibe a imagem original
plt.imshow(img)
patches = [img]
for n_div in range(1,2):
patches = cria_patches(patches, 1, rgb=True)
print("Total de patches: %f", len(patches))
print("Tamanho do patch: %i", patches[0].shape)
y = int(math.sqrt(4**n_div))
x = y
#fig,axes = plt.subplots(x,y, figsize=(32,32))
fig,axes = plt.subplots(x,y)
for i, ax in enumerate(axes.ravel()):
ax.xaxis.set_major_formatter(plt.NullFormatter())
ax.yaxis.set_major_formatter(plt.NullFormatter())
im = ax.imshow(patches[i],'gray')
plt.show()
def test_slic():
f = mahotas.imread('mahotas/demos/data/luispedro.jpg')
segmented, n = mahotas.segmentation.slic(f)
assert segmented.shape == (f.shape[0], f.shape[1])
assert segmented.max() == n
segmented2, n2 = mahotas.segmentation.slic(f, 128)
assert n2 < n
def handle_gfx_slice(offset, data):
"""
Determine the image type, as indicated by its magic numer, of the slice.
Create a image file with correct extension.
Display the image using pylab.
"""
print("\n=== ", offset, " ===", sep='')
filtered_data = []
for i in xrange(offset, len(data), 5):
filtered_data.append(data[i])
magic = ''.join("{:02x}".format(ord(c)) for c in filtered_data[:8:])
if magic[0:8] == 'ffd8ffe0':
ext = 'jpg'
elif magic[0:16] == '89504e470d0a1a0a':
ext = 'png'
elif magic[0:12] == '474946383761' or magic[0:12] == '474946383961':
ext = 'gif'
else:
ext = 'fail'
print('magic:', magic)
print('ext:', ext)
# fixme: Factor this into a function
with open('%s.%s' % (offset, ext), 'w') as out_file:
for item in filtered_data:
out_file.write(item)
img = mh.imread("%s.%s" % (offset, ext))
pylab.imshow(img)
pylab.show()
def processAttributes_surf(filePattern): targets_data = [] surf_features = [] counter = 0 for f in glob.glob(filePattern): counter+=1 print 'Reading image: ', counter, f target = 1 if 'cat' in f else 0 targets_data.append(target) image = mh.imread(f, as_grey=True) surf_features.append(surf.surf(image)[:, 5:]) X_train_surf_features = np.concatenate(surf_features) # Clusters n_clusters = 300 print 'Clustering', len(X_train_surf_features), 'features' estimator = MiniBatchKMeans(n_clusters=n_clusters) estimator.fit_transform(X_train_surf_features) x_data = [] for instance in surf_features: clusters = estimator.predict(instance) features = np.bincount(clusters) if len(features) < n_clusters: features = np.append(features, np.zeros((1, n_clusters-len(features)))) x_data.append(features) return x_data, targets_data
def extrai_haralick(lista_imgs, usa_descarte=False):
atributos = []
rotulos = []
ref = patch_referencia()
hist_ref = bp.histograma(bp.aplica_lbp(ref))
descartados = []
for arquivo in lista_imgs:
# recupera do nome do arquivo a sua classe
classe, _ = classe_arquivo(arquivo)
#converte para escala de cinza
img_cinza = mh.imread(arquivo, as_grey=True)
if (usa_descarte):
img_cinza = limpa_imagem(img_cinza)
patches = bp.cria_patches(img_cinza, TAM_PATCH)
# calcula o histograma de cada um dos patches
for patch in patches:
if (usa_descarte):
lbp_patch = bp.aplica_lbp(patch)
hist = bp.histograma(lbp_patch)
if (patch_valido(hist, hist_ref)):
glcm = mh.features.haralick(np.asarray(patch, dtype=np.uint8))
glcm = np.asarray(glcm).flatten()
atributos.append(glcm)
rotulos.append(CLASSES[classe])
else:
glcm = mh.features.haralick(np.asarray(patch, dtype=np.uint8))
glcm = np.asarray(glcm).flatten()
atributos.append(glcm)
rotulos.append(CLASSES[classe])
return (atributos,rotulos)
def method2(image, sigma):
image = mh.imread(image)[:, :, 0]
image = mh.gaussian_filter(image, sigma)
image = mh.stretch(image)
binimage = image > mh.otsu(image)
labeled, _ = mh.label(binimage)
return labeled
def load(image_name, as_grey=None):
'''
Loads a demo image
Parameters
----------
image_name : str
Name of one of the demo images
as_grey : bool, optional
Whether to convert to greyscale
Returns
-------
im : ndarray
Image
'''
from os import path
import mahotas as mh
_demo_images = {
'wally' : 'DepartmentStore.jpg',
'departmentstore' : 'DepartmentStore.jpg',
'lenna' : 'lena.jpg',
'lena' : 'lena.jpg',
'luispedro' : 'luispedro.jpg',
'nuclear' : 'nuclear.png',
}
if image_name.lower() not in _demo_images:
raise KeyError('mahotas.demos.load: Unknown demo image "{}", known images are {}'.format(image_name, list(_demo_images.keys())))
image_name = image_path(_demo_images[image_name.lower()])
return mh.imread(image_name, as_grey=as_grey)
def load_stack(folder_name):
stack = None
input_files = sorted(glob.glob(os.path.join(folder_name, '*')))
for i, file_name in enumerate(input_files):
print file_name
if file_name.endswith('h5') or file_name.endswith('hdf5'):
infile = h5py.File(file_name)
im = infile['/probabilities'][...]
else:
im = mahotas.imread(file_name)
if len(im.shape) == 3:
im = np.uint32(im[ :, :, 0 ]) + np.uint32(im[ :, :, 1 ]) * 2**8 + np.uint32(im[ :, :, 2 ]) * 2**16
if im.shape[0] > 400:
im = im[60:60+400, 210:210+400]
if rot != 0:
im = np.rot90(im, rot)
if stack is None:
stack = np.zeros((len(input_files), im.shape[0], im.shape[1]), dtype=im.dtype)
print 'Stack size={0}, dtype={1}.'.format(stack.shape, stack.dtype)
stack[i,:,:] = im
#print file_name
return stack
def createMasterList():
masterfile = open("metadata/master-data.txt",'w')
f = []
mypath = "images/1fps"
f = []
for i in range(309):
f.append('x'+str(i+1)+'.jpg')
print "Reading Files..."
for image in f:
imgname = 'images/1fps/'+image
img = mahotas.imread(imgname, as_grey=True) # input image
#extract description of all points of interest
spoints = surf.surf(img, nr_octaves=4, nr_scales=6, initial_step_size=1, threshold=0.1, max_points=30, descriptor_only=True)
info = "" #string for each image information
newList = [sum(attr)/len(attr) for attr in zip(*spoints)]
for i in range(len(newList)):
info+=str(i+1)+":"+str(newList[i])+" "
info+="\n"
masterfile.write(info)
masterfile.close()
print "Completed master feature list..."
def test_gaussian_filter():
from scipy import ndimage
f = mahotas.imread('mahotas/demos/data/luispedro.jpg', 1)
for s in (4.,8.,12.):
g = gaussian_filter(f, s)
n = ndimage.gaussian_filter(f, s)
assert np.max(np.abs(n - g)) < 1.e-5
def faces():
from os import walk,path
import numpy as np
import mahotas as mh
from sklearn.cross_validation import train_test_split
from sklearn.cross_validation import cross_val_score
from sklearn.preprocessing import scale
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
X = []
y = []
for dir_path,dir_names,file_names in walk('./data/att_faces'):
for fn in file_names:
if fn[-3:] == 'pgm':
image_filename = path.join(dir_path,fn)
X.append(scale(mh.imread(image_filename,as_grey=True).reshape(10304).astype('float32')))
y.append(dir_path)
X = np.array(X)
X_train,X_test,y_train,y_test = train_test_split(X,y)
pca = PCA(n_components = 150)
X_train_reduced = pca.fit_transform(X_train)
X_test_reduced = pca.transform(X_test)
print 'original data were',X_train.shape
print 'reduced is ',X_train_reduced.shape
classifier = LogisticRegression()
accuracies = cross_val_score(classifier,X_train_reduced,y_train)
print 'cross val: ',np.mean(accuracies),accuracies
classifier.fit(X_train_reduced,y_train)
predictions = classifier.predict(X_test_reduced)
print classification_report(y_test,predictions)
def extractFeatV2(image_file):
region_feat = extractFeatV1(image_file)
image = imread(image_file, as_grey=True)
image = image.copy()
# global features
idx = np.nonzero(255-image)
nonzero = image[idx]
global_feat = [
np.mean(nonzero),
np.std(nonzero),
kurtosis(nonzero),
skew(nonzero),
gini(nonzero,image_file),
]
global_feat = np.asarray(global_feat, dtype='float32' )
# concat all the features
image2 = mh.imread(image_file, as_grey=True)
haralick = mh.features.haralick(image2, ignore_zeros=False, preserve_haralick_bug=False, compute_14th_feature=False)
lbp = mh.features.lbp(image2, radius=20, points=7, ignore_zeros=False)
pftas = mh.features.pftas(image2)
zernike_moments = mh.features.zernike_moments(image2, radius=20, degree=8)
#surf_feat = surf.surf(image2)
haralick = np.reshape(haralick,(np.prod(haralick.shape)))
#surf_feat = np.reshape(surf_feat,(np.prod(surf_feat.shape)))
#mh_feat = np.hstack((haralick, lbp, pftas, zernike_moments, surf_feat))
mh_feat = np.hstack((haralick, lbp, pftas, zernike_moments))
feat = np.hstack((global_feat, region_feat, mh_feat))
return feat
def imread(input_file_name):
image = mahotas.imread(input_file_name)
#Check if it is on a 0-255 scale
if image[0][0][0]<1 and image[0][0][0]>0:
image=image*255
image = image.astype('uint8')
return image
def test_as_grey():
filename = path.join(path.dirname(__file__), '..', 'demos', 'data',
'luispedro.jpg')
im = mh.imread(filename, as_grey=1)
assert im.ndim == 2
from pylab import imshow
import numpy as np
import mahotas
wally = mahotas.imread('DepartmentStore.jpg')
wfloat = wally.astype(float)
r,g,b = wfloat.transpose((2,0,1))
w = wfloat.mean(2)
pattern = np.ones((24, 16), float)
for i in xrange(2):
pattern[i::4] = -1
v = mahotas.convolve(r-w, pattern)
mask = (v == v.max())
mask = mahotas.dilate(mask, np.ones((48, 24)))
# wally -= .8*wally * ~mask[:,:,None]
imshow(wally)
import numpy as np
import mahotas as mh
from . import regions
from . import pixel
histone = mh.imread('data/image_00_00_protein.png')
dna = mh.imread('data/image_00_00_dna.png')
rois = mh.imread('data/image_00_00_rois.png')
def test_rois_None():
def test_function(f):
features, labels = f(histone, dna, rois)
features2 = f(histone, dna, None)
assert np.all(features == features2)
assert np.all(features == features2)
assert len(features) == len(labels)
assert np.abs(np.mean(rois > 0) - np.dot(features.T[0],labels)/np.sum(features.T[0])) < .05
yield test_function, regions.hypersegmented_features
yield test_function, pixel.pixel_features
yield test_function, (lambda h,d,r : pixel.surf_grid(h,d,r,1.0))
# Set HoG parameters, number of bins, maximum angle, and number of pyramid levels
bins = 9
angle = 180
L = 3
num_spatial_bins = 3
phog_times = []
vhog_times = []
triggs_times = []
gpu_keypoint_times = []
gpu_patch_times = []
num_plots = 5
# Get timing info for each of the patch-based CPU versions
print "Timing the CPU versions ..."
for indx in range(len(img_sizes)):
cur_image = imread(img_prefix + img_names[indx])
if len(cur_image.shape) == 3:
cur_image = clr.rgb2gray(cur_image)
height, width = cur_image.shape
st_time = time.time()
p = phog.phog(img_prefix + img_names[indx], bins, angle, L,
[0, height, 0, width])
ed_time = time.time() - st_time
phog_times.append(ed_time)
st_time = time.time()
v = vhog.hog(cur_image, bins, num_spatial_bins, angle,
[0, height, 0, width])
ed_time = time.time() - st_time
vhog_times.append(ed_time)
def lowestCountourSnowDepth(imglist, datetimelist, mask, settings, logger,
objsize, light_threshold, sigma, bias):
try:
sigma = int(sigma)
objsize = float(objsize)
bias = float(bias)
light_threshold = float(light_threshold)
except:
logger.set('Parameter error. Aborting.')
if len(imglist) == 0:
return False
mask, pgs, th = mask
if (isinstance(pgs[0], list)
and len(pgs) != 1) or (not isinstance(pgs[0], list)
and map(sum, [pgs]) == 0.0):
logger.set(
'Only and only one polygon should be defined for this analysis. Aborting.'
)
return False
pgsx = []
pgsy = []
for i, c in enumerate(pgs):
if i % 2 == 0:
pgsx.append(c)
else:
pgsy.append(c)
pbox = [min(pgsy), max(pgsy), min(pgsx), max(pgsx)]
sd = []
time = []
for i, imgf in enumerate(imglist):
try:
img = mahotas.imread(imgf, as_grey=True)
mbox = [
pbox[0] * img.shape[0], pbox[1] * img.shape[0],
pbox[2] * img.shape[1], pbox[3] * img.shape[1]
]
mbox = map(int, map(np.rint, mbox))
# mahotas.imsave(path.join('/home/tanisc',str(datetimelist[i].day)+str(datetimelist[i].hour)+str(datetimelist[i].minute)+'1.jpg'),(img[mbox[0]:mbox[1],mbox[2]:mbox[3]]).astype(np.uint8))
if sigma != 0:
img = mahotas.gaussian_filter(img, sigma)
# mahotas.imsave(path.join('/home/tanisc',str(datetimelist[i].day)+str(datetimelist[i].hour)+str(datetimelist[i].minute)+'2.jpg'),(img[mbox[0]:mbox[1],mbox[2]:mbox[3]]).astype(np.uint8))
img = (img <= light_threshold)
# mahotas.imsave(path.join('/home/tanisc',str(datetimelist[i].day)+str(datetimelist[i].hour)+str(datetimelist[i].minute)+'3.jpg'),(img[mbox[0]:mbox[1],mbox[2]:mbox[3]]*255).astype(np.uint8))
img = img[mbox[0]:mbox[1], mbox[2]:mbox[3]]
bottom = mbox[1] - mbox[0]
# mahotas.imsave(path.join('/home/tanisc',str(datetimelist[i].day)+str(datetimelist[i].hour)+str(datetimelist[i].minute)+'4.jpg'),img.astype(np.uint8)*255)
labeled, n = mahotas.label(img)
bboxes = mahotas.labeled.bbox(labeled)
bbheig = []
if n == 0:
height = np.nan
else:
for j, bbox in enumerate(bboxes[1:]):
height = objsize - objsize * bbox[1] / float(bottom)
height += bias
height = np.round(height * 100) / 100.0
bbheig.append(height)
if bbheig == []:
height = np.nan
else:
height = min(bbheig)
time = np.append(time, (str(datetimelist[i])))
sd = np.append(sd, height)
logger.set('Image: |progress:4|queue:' + str(i + 1) + '|total:' +
str(len(imglist)))
except Exception as e:
print(e)
logger.set("Processing " + imgf + " failed.")
output = [["Snow Depth", ["Time", time, "Snow Depth", sd]]]
return output
def salvatoriSnowCover(img_imglist, datetimelist, mask, settings, logger, red,
green, blue, middata, rectsw, extent, extent_proj, res,
dem, C, C_proj, Cz, hd, td, vd, f, w, interpolate, flat,
origin, ax, ay):
rectsw = bool(float(rectsw))
middata = bool(float(middata))
dummyImg = False
for img in img_imglist:
try:
mahotas.imread(img)
dummyImg = img
break
except:
pass
if not dummyImg:
logger.set("All images invalid.")
return False
if rectsw:
logger.set("Obtaining weight mask...")
params = map(np.copy, [
extent, extent_proj, res, dem, C, C_proj, Cz, hd, td, vd, f, w,
interpolate, flat, origin, ax, ay
])
auxfilename = False
from definitions import AuxDir, TmpDir
readydata = False
for hdf in os.listdir(AuxDir):
if "SNOWCOV001" in hdf:
try:
auxF = h5py.File(os.path.join(AuxDir, hdf), 'r')
readyfile = True
for i in range(len(params)):
attr = auxF['metadata'].attrs["param" + str(i)]
if np.prod(np.array([attr]).shape) == 1:
if (attr != params[i]):
readyfile = False
else:
if (attr != params[i]).any():
readyfile = False
if readyfile:
logger.set(
"Calculation has done before with same parameters, auxillary info is being read from file..."
)
tiles = np.copy(auxF['metadata'][...]).tolist()
for d in auxF:
if str(d) == 'metadata':
continue
varname = str(d).split()[0]
tilename = str(d).split()[1]
if len(tiles) == 1:
exec(varname + "= np.copy(auxF[d])")
else:
if varname not in locals():
exec(varname + '=None')
exec(varname + "=writeData(np.copy(auxF[d])," +
varname +
",map(int,tilename.split('-')))[0]")
auxF.close()
logger.set("\tRead.")
readydata = True
auxfilename = hdf
break
auxF.close()
except:
try:
auxF.close()
except:
continue
if not readydata:
Wp = Georectify1([dummyImg], [datetimelist[0]], mask, settings,
logger, extent, extent_proj, res, dem, C, C_proj,
Cz, hd, td, vd, f, w, interpolate, flat, origin,
ax, ay)[0][1][5]
logger.set('Writing results for next run...')
auxfilename = 'SNOWCOV001_' + str(uuid4()) + '.h5'
auxF = h5py.File(os.path.join(AuxDir, auxfilename), 'w')
tiles = [[0, 0, Wp.shape[0], Wp.shape[1]]]
auxF.create_dataset('metadata', data=np.array(tiles))
for i, p in enumerate(params):
auxF['metadata'].attrs.create("param" + str(i), p)
for i, tile in enumerate(tiles):
Wp_ = readData(Wp, tile)[0]
auxF.create_dataset('Wp ' + str(tile).replace(
', ', '-').replace('[', '').replace(']', ''),
Wp_.shape,
data=Wp_)
Wp_ = None
auxF.close()
Wp = Wp[::-1]
else:
Wp = np.ones(mahotas.imread(dummyImg).shape[:2])
mask, pgs, th = mask
mask = LensCorrRadial(mask, '0', logger, origin, ax, ay, 0)[0][1][1]
Wp *= (mask.transpose(2, 0, 1)[0] == 1)
if np.mean(mask) == 1:
logger.set("Weightmask quality: " + str(
np.sum(Wp[-100:, Wp.shape[1] / 2 - 50:Wp.shape[1] / 2 + 50] != 0) /
10000))
else:
logger.set("Weightmask quality: " +
str(1 - np.sum((Wp == 0) *
(mask.transpose(2, 0, 1)[0] == 1)) /
float(np.sum((mask.transpose(2, 0, 1)[0] == 1)))))
logger.set("Calculating snow cover fractions...")
scr = []
ssr = []
snr = []
mar = []
scn = []
ssn = []
snn = []
man = []
time = []
thr = []
thg = []
thb = []
Wp_full = deepcopy(Wp)
for i_img, imgf in enumerate(img_imglist):
try:
snow = 0
nosnow = 0
img = mahotas.imread(imgf)
if mask.shape != img.shape:
mask = maskers.polymask(img, pgs, logger)
Wp = mahotas.imresize(Wp_full, img.shape[:2])
(img,
thv) = salvatoriSnowDetect(img, mask * maskers.thmask(img, th),
settings, logger, red, green, blue)
# mimg = np.dstack((img==1,img==0,img==2)).astype(np.uint8)*255
if -1 in thv:
continue
time = np.append(time, (str(datetimelist[i_img])))
img = LensCorrRadial(img, str(datetimelist[i_img]), logger, origin,
ax, ay, 0)[0][1][1]
snow = np.sum(((img == 1) * Wp).astype(int))
nosnow = np.sum(((img == 0) * Wp).astype(int))
masked = np.sum(((img == 2) * Wp).astype(int))
scr = np.append(scr, snow / float(snow + nosnow))
if middata:
ssr = np.append(ssr, snow)
snr = np.append(snr, nosnow)
mar = np.append(mar, masked)
snow = np.sum(((img == 1)).astype(int))
nosnow = np.sum(((img == 0)).astype(int))
masked = np.sum(((img == 2)).astype(int))
scn = np.append(scn, snow / float(snow + nosnow))
ssn = np.append(ssn, snow)
snn = np.append(snn, nosnow)
man = np.append(man, masked)
thr = np.append(thr, thv[0])
thg = np.append(thg, thv[1])
thb = np.append(thb, thv[2])
except Exception as e:
print(e)
logger.set("Processing " + imgf + " failed.")
logger.set('Image: |progress:4|queue:' + str(i_img + 1) + '|total:' +
str(len(img_imglist)))
scr = np.round(scr * 100).astype(np.int32)
scn = np.round(scn * 100).astype(np.int32)
if middata:
return [[
"Snow Cover Fraction",
[
"Time", time, "Snow Cover Fraction", scr,
"Snow Cover Fraction - Non-Rectified", scn, "Threshold - Red",
thr, "Threshold - Green", thg, "Threshold - Blue", thb,
"Snow - Rectified", ssr, "Nosnow - Rectified", snr,
"Masked - Rectified", mar, "Snow - Non-Rectified", ssn,
"Nosnow - Non-Rectified", snn, "Masked - Non-Rectified", man
]
]]
else:
return [[
"Snow Cover Fraction", ["Time", time, "Snow Cover Fraction", scr]
]]
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
X = []
y = []
for dir_path, dir_names, file_names in walk(
'data/att-faces/orl_faces'
): # This path is incorrect so the code doesnt execute
for fn in file_names:
if fn[-3:] == 'pgm':
image_filename = path.join(dir_path, fn)
X.append(
scale(
mh.imread(image_filename,
as_grey=True).reshape(10304).astype('float32')))
y.append(dir_path)
X = np.array(X)
X_train, X_test, y_train, y_test = train_test_split(X, y)
pca = PCA(n_components=150)
X_train_reduced = pca.fit_transform(X_train)
X_test_reduced = pca.transform(X_test)
print 'The original dimenstions of the training data were ', X_train.shape
print 'The reduced dimenstion of the training data are ', X_train_reduced.shape
classifier = LogisticRegression()
accuracies = cross_val_score(classifier, X_train_reduced, y_train)
print("Cross validation accuracy: ", np.mean(accuracies))
import mahotas
import numpy as np
from pylab import imshow, gray, show, subplot
from os import path
luispedro_image = path.join(path.dirname(path.abspath(__file__)), 'data',
'luispedro.jpg')
photo = mahotas.imread(luispedro_image, as_grey=True)
photo = photo.astype(np.uint8)
gray()
subplot(131)
imshow(photo)
T_otsu = mahotas.otsu(photo)
print T_otsu
subplot(132)
imshow(photo > T_otsu)
T_rc = mahotas.rc(photo)
print T_rc
subplot(133)
imshow(photo > T_rc)
show()
import numpy as np
import pylab
import mahotas as mh
dna = mh.imread('images/dna.jpeg')
pen = mh.imread('images/Penguins.jpg')
#pylab.imshow(pen)
#pylab.show()
# dnaf = mh.gaussian_filter(dna, 8)
#change type to int for otsu to work
# dnaf = dnaf.astype('uint8')
# T = mh.thresholding.otsu(dnaf)
# pylab.imshow(dnaf > T)
# pylab.show()
dnaf = mh.gaussian_filter(dna, 8)
rmax = mh.regmax(dnaf)
pylab.imshow(mh.overlay(dna, rmax))
pylab.show()
pylab.imshow(dnaf)
pylab.show()
# labeled, nr_objects = mh.label(dnaf > T)
# print "nr_objects: {}".format(nr_objects)
# pylab.imshow(labeled)
# pylab.jet()
# pylab.show()
segmentation_files = sorted(glob.glob(imagedir + '/*.png'))
print 'Found {0} segmentations in directory {1}.'.format(
len(segmentation_files), di)
if pi == 0 and di == 0:
out_hdf5 = h5py.File(output_path, 'w')
segmentations = out_hdf5.create_dataset(
'segmentations', (imshape[0], imshape[1],
len(segmentation_files), len(seg_dirs)),
dtype=np.bool,
chunks=(256, 256, 1, 1),
compression='gzip')
for fi in range(len(segmentation_files)):
seg = mahotas.imread(segmentation_files[fi]) == 0
segmentations[input_areas[pi][0]:input_areas[pi][1],
input_areas[pi][2]:input_areas[pi][3], fi,
di] = seg
figure(figsize=(20, 20))
imshow(segmentations[:, :, 10, 10], cmap=cm.gray)
out_hdf5.close()
print "Success"
except Exception as e:
print e
raise
"""No linter no cry."""
import numpy
import pylab
import mahotas as mh
image1 = mh.imread('i1.jpg')
image2 = mh.imread('i2.jpg')
bcg1 = mh.imread('b1.jpg')
bcg2 = mh.imread('b2.jpg')
# TODO gauss does make pictures gray. why?
# p = 4
# image1 = mh.gaussian_filter(image1, p)
# image2 = mh.gaussian_filter(image2, p)
# bcg1 = mh.gaussian_filter(bcg1, p)
# bcg2 = mh.gaussian_filter(bcg2, p)
assert len(image1) == len(image2) == len(bcg1) == len(bcg2)
assert len(image1[0]) == len(image2[0]) == len(bcg1[0]) == len(bcg2[0])
numLines = len(image1)
numPixel = len(image1[0])
result = []
for line in range(0, numLines):
result.append([])
for pix in range(0, numPixel):
i1 = image1[line][pix]
i2 = image2[line][pix]
b1 = bcg1[line][pix]
b2 = bcg2[line][pix]
def edginess_sobel_from_fname(fname):
from edginess import edginess_sobel
return edginess_sobel(mh.imread(fname, as_grey=True))
def features_for(im):
im = mh.imread(im, as_grey=True).astype(np.uint8)
return mh.features.haralick(im).mean(0)
output = T.addbroadcast(output, 0)
output = output.squeeze()
output = output.flatten(2)
output = T.nnet.softmax(output.T).T
return output.reshape((2, output_shape[2], output_shape[3]))
if __name__ == '__main__':
rng = numpy.random.RandomState(929292)
import mahotas
import matplotlib.pyplot as plt
#CPU
#image = mahotas.imread('ac3_input_0141.tif')
image = mahotas.imread('test-input-1.tif')
imageSize = 1024
image = image[0:imageSize, 0:imageSize]
start_time = time.clock()
image = normalizeImage(image) - 0.5
#GPU
image_shared = theano.shared(
np.float64(image)) #theano.shared(np.float64(image))
image_shared = image_shared.reshape((1, 1, imageSize, imageSize))
x = T.matrix('x')
classifier = CNN(input=x,
batch_size=imageSize,
haralicks = []
labels = []
chists = []
print(
'This script will test (with cross-validation) classification of the simple 3 class dataset'
)
print('Computing features...')
# Use glob to get all the images
images = glob('{}/*.jpg'.format(basedir))
# We sort the images to ensure that they are always processed in the same order
# Otherwise, this would introduce some variation just based on the random
# ordering that the filesystem uses
for fname in sorted(images):
imc = mh.imread(fname)
haralicks.append(texture(mh.colors.rgb2grey(imc)))
chists.append(color_histogram(imc))
# Files are named like building00.jpg, scene23.jpg...
labels.append(fname[:-len('xx.jpg')])
print('Finished computing features.')
haralicks = np.array(haralicks)
labels = np.array(labels)
chists = np.array(chists)
haralick_plus_chists = np.hstack([chists, haralicks])
# We use Logistic Regression because it achieves high accuracy on small(ish) datasets
import scipy.ndimage
import scipy.misc
import numpy as np
import gzip
import cPickle
import glob
import os
import h5py
import partition_comparison
#param_path = 'D:/dev/Rhoana/membrane_cnn/results/good3/'
#param_path = 'D:/dev/Rhoana/membrane_cnn/results/stumpin/'
param_path = 'D:/dev/Rhoana/membrane_cnn/results/stump_combo/'
param_files = glob.glob(param_path + "*.h5")
target_boundaries = mahotas.imread(param_path + 'boundaries.png') > 0
offset_max = 32
target_boundaries = target_boundaries[offset_max:-offset_max,
offset_max:-offset_max]
target_segs = np.uint32(mahotas.label(target_boundaries)[0])
param_files = [x for x in param_files if x.find('.ot.h5') == -1]
blur_radius = 3
y, x = np.ogrid[-blur_radius:blur_radius + 1, -blur_radius:blur_radius + 1]
disc = x * x + y * y <= blur_radius * blur_radius
for remove_i in range(len(param_files) + 1):
basedir = './SimpleImageDataset/'
haralicks = []
sobels = []
labels = []
print('This script will test (with cross-validation) classification of the simple 3 class dataset')
print('Computing features...')
# Use glob to get all the images
images = glob('{}/*.jpg'.format(basedir))
# We sort the images to ensure that they are always processed in the same order
# Otherwise, this would introduce some variation just based on the random
# ordering that the filesystem uses
for fname in sorted(images):
im = mh.imread(fname, as_grey=True)
haralicks.append(texture(im))
sobels.append(edginess_sobel(im))
# Files are named like building00.jpg, scene23.jpg...
labels.append(fname[:-len('xx.jpg')])
print('Finished computing features.')
haralicks = np.array(haralicks)
sobels = np.array(sobels)
labels = np.array(labels)
# We use logistic regression because it is very fast.
# Feel free to experiment with other classifiers
scores = cross_validation.cross_val_score(LogisticRegression(), haralicks, labels, cv=5)
def prediction_full_patch_spine(patchSize=572,
patchSize_out=388,
patchZ=23,
patchZ_out=1,
writeImage=True,
returnValue=True):
start_time = time.time()
pathPrefix = 'DIR_PATH/'
img_search_string_grayImages = pathPrefix + 'images/validate/*.png'
img_search_string_membraneImages = pathPrefix + 'spinemasks/validate/*.png'
img_files_gray = sorted(glob.glob(img_search_string_grayImages))
img_files_membrane = sorted(glob.glob(img_search_string_membraneImages))
#load model
print 'Read the model for evaluation'
model = model_from_json(open('3d_unet_spine.json').read())
model.load_weights('3d_unet_spine_weights.h5')
cropSize = (patchSize - patchSize_out) / 2
csZ = (patchZ - patchZ_out) / 2
img = mahotas.imread(
img_files_gray[0]
) #read the first image to get imformation about the shape
grayImages = np.zeros(
(np.shape(img_files_gray)[0], img.shape[0], img.shape[1]))
labelImages = np.zeros(
(np.shape(img_files_gray)[0], img.shape[0], img.shape[1]),
dtype=np.int8)
probImages = np.zeros(
(np.shape(img_files_gray)[0] - 2 * csZ, img.shape[0] - 2 * cropSize,
img.shape[1] - 2 * cropSize))
print 'Total number of full size test images:', np.shape(img_files_gray)[0]
read_order = range(np.shape(img_files_gray)[0])
for img_index in read_order:
img = mahotas.imread(img_files_gray[img_index])
img = normalizeImage(img)
img = img - 0.5
grayImages[img_index, :, :] = img
img_label = mahotas.imread(img_files_membrane[img_index]) / 255
labelImages[img_index, :, :] = np.int8(img_label)
numSample_axis = int((img.shape[0] - 2 * cropSize) / patchSize_out) + 1
numSample_patch = numSample_axis**2
numZ = float(len(img_files_gray) - 2 * csZ) / float(patchZ_out)
numZ = int(math.ceil(numZ))
nsamples = numSample_patch * numZ
print 'Number of inputs for this block:', nsamples
grayImg_set = np.zeros((nsamples, patchZ, patchSize, patchSize))
membrane_set = np.zeros(
(nsamples, patchZ_out, patchSize_out, patchSize_out))
print 'Total number of probability maps:', len(img_files_gray) - 2 * csZ
numProb = len(img_files_gray) - 2 * csZ
num_total = 0
for zIndex in range(numZ):
if zIndex == numZ - 1:
zStart = numProb - patchZ_out
else:
zStart = patchZ_out * zIndex
for xIndex in range(numSample_axis - 1):
xStart = patchSize_out * xIndex
for yIndex in range(numSample_axis - 1):
yStart = patchSize_out * yIndex
grayImg_set[num_total] = grayImages[zStart:zStart + patchZ,
xStart:xStart + patchSize,
yStart:yStart + patchSize]
num_total += 1
xStart = img.shape[0] - patchSize
for yIndex in range(numSample_axis - 1):
yStart = patchSize_out * yIndex
grayImg_set[num_total] = grayImages[zStart:zStart + patchZ,
xStart:xStart + patchSize,
yStart:yStart + patchSize]
num_total += 1
yStart = img.shape[1] - patchSize
for xIndex in range(numSample_axis - 1):
xStart = patchSize_out * xIndex
grayImg_set[num_total] = grayImages[zStart:zStart + patchZ,
xStart:xStart + patchSize,
yStart:yStart + patchSize]
num_total += 1
xStart = img.shape[0] - patchSize
yStart = img.shape[1] - patchSize
grayImg_set[num_total] = grayImages[zStart:zStart + patchZ,
xStart:xStart + patchSize,
yStart:yStart + patchSize]
num_total += 1
for val_ind in range(num_total):
data_x = grayImg_set[val_ind].astype(np.float32)
data_x = np.reshape(data_x, [-1, 1, patchZ, patchSize, patchSize])
im_pred = model.predict(x=data_x, batch_size=1)
membrane_set[val_ind] = np.reshape(
im_pred, (patchZ_out, patchSize_out, patchSize_out))
num_total = 0
for zIndex in range(numZ):
if zIndex == numZ - 1:
zStart = numProb - patchZ_out
else:
zStart = patchZ_out * zIndex
for xIndex in range(numSample_axis - 1):
xStart = patchSize_out * xIndex
for yIndex in range(numSample_axis - 1):
yStart = patchSize_out * yIndex
probImages[zStart:zStart + patchZ_out,
xStart:xStart + patchSize_out, yStart:yStart +
patchSize_out] = membrane_set[num_total]
num_total += 1
xStart = (numSample_axis - 1) * patchSize_out
for yIndex in range(numSample_axis - 1):
yStart = patchSize_out * yIndex
probImages[zStart:zStart + patchZ_out, xStart:, yStart:yStart +
patchSize_out] = membrane_set[num_total, :,
xStart - img.shape[0] +
2 * cropSize:, :]
num_total += 1
yStart = (numSample_axis - 1) * patchSize_out
for xIndex in range(numSample_axis - 1):
xStart = patchSize_out * xIndex
probImages[zStart:zStart + patchZ_out,
xStart:xStart + patchSize_out,
yStart:] = membrane_set[num_total, :, :, yStart -
img.shape[0] + 2 * cropSize:]
num_total += 1
xStart = (numSample_axis - 1) * patchSize_out
yStart = (numSample_axis - 1) * patchSize_out
probImages[zStart:zStart + patchZ_out, xStart:,
yStart:] = membrane_set[num_total, :, xStart -
img.shape[0] + 2 * cropSize:,
yStart - img.shape[0] +
2 * cropSize:]
num_total += 1
if writeImage:
print 'Store images'
for imgIndex in range(numProb):
scipy.misc.imsave(
pathPrefix + "result/prediction_" + str("%04d" % imgIndex) +
".tif", probImages[imgIndex])
end_time = time.time()
total_time = (end_time - start_time)
print 'Running time: ', total_time / 60.
print 'finished the prediction'
if returnValue:
newMembrane = np.zeros((numProb, (img.shape[0] - 2 * cropSize)**2))
newProb_set = np.zeros((numProb, (img.shape[0] - 2 * cropSize)**2))
for i in range(numProb):
newMembrane[i] = crop_image_layer(labelImages[i + csZ, :, :],
cropSize).flatten()
newProb_set[i] = probImages[i].flatten()
newMembrane = newMembrane.astype(np.int)
return newProb_set, newMembrane
def salvatoriSnowOnCanopy(img_imglist, datetimelist, mask, settings, logger,
threshold, middata):
middata = bool(float(middata))
threshold = float(threshold)
mask, pgs, th = mask
logger.set("Calculating snow on canopy...")
scr = []
ssr = []
snr = []
mar = []
time = []
thb = []
for i_img, imgf in enumerate(img_imglist):
try:
snow = 0
nosnow = 0
img = mahotas.imread(imgf)
if mask.shape != img.shape:
mask = maskers.polymask(img, pgs, logger)
(img, thv) = salvatoriSnowDetect2(img,
mask * maskers.thmask(img, th),
settings, logger)
mimg = np.dstack(
(img == 1, img == 0, img == 2)).astype(np.uint8) * 255
if thv is -1:
continue
time = np.append(time, (str(datetimelist[i_img])))
snow = np.sum(((img == 1)).astype(int))
nosnow = np.sum(((img == 0)).astype(int))
masked = np.sum(((img == 2)).astype(int))
scr = np.append(scr, snow / float(snow + nosnow))
if middata:
ssr = np.append(ssr, snow)
snr = np.append(snr, nosnow)
mar = np.append(mar, masked)
thb = np.append(thb, thv)
except Exception as e:
print(e)
logger.set("Processing " + imgf + " failed.")
logger.set('Image: |progress:4|queue:' + str(i_img + 1) + '|total:' +
str(len(img_imglist)))
scr = np.round(scr * 100).astype(np.int32)
if middata:
return [[
"Snow Cover Fraction",
[
"Time", time, "Snow on canopy",
(scr > threshold).astype(np.int32), "Snow Cover Fraction", scr,
"Threshold", thb, "Snow", ssr, "Nosnow", snr, "Masked", mar
]
]]
else:
return [[
"Snow Cover Fraction",
[
"Time", time, "Snow on canopy",
(scr > threshold).astype(np.int32)
]
]]
import numpy as np
import mahotas as mh
image = mh.imread('scene00.jpg')
from matplotlib import pyplot as plt
plt.imshow(image)
plt.show()
image = mh.colors.rgb2grey(image, dtype=np.uint8)
plt.imshow(image) # Display the image
plt.gray()
thresh = mh.thresholding.otsu(image)
print('Otsu threshold is {}.'.format(thresh))
# Otsu threshold is 138.
plt.imshow(image > thresh)
im16 = mh.gaussian_filter(image, 16)
im = mh.demos.load('lenna')
r, g, b = im.transpose(2, 0, 1)
r12 = mh.gaussian_filter(r, 12.)
g12 = mh.gaussian_filter(g, 12.)
b12 = mh.gaussian_filter(b, 12.)
im12 = mh.as_rgb(r12, g12, b12)
h, w = r.shape # height and width
Y, X = np.mgrid[:h, :w]
Y = Y - h / 2. # center at h/2
Y = Y / Y.max() # normalize to -1 .. +1
X = X - w / 2.
X = X / X.max()
C = np.exp(-2. * (X**2 + Y**2))
import numpy as np
import scipy
import pylab
import pymorph
import mahotas
from scipy import ndimage
dna = mahotas.imread('dna.jpeg')
#pylab.imshow(dna)
#pylab.show()
print dna.shape
print dna.dtype
print dna.max()
print dna.min()
#pylab.imshow(dna // 2)
#pylab.show()
dnaf = ndimage.gaussian_filter(dna,16)
T = mahotas.thresholding.otsu(dnaf)
#pylab.imshow(dnaf>T)
#pylab.gray()
#pylab.show()
# label cells
labeled,nr_objects = ndimage.label(dnaf>T)
print nr_objects
#pylab.imshow(labeled)
#pylab.jet()
#pylab.show()
import numpy as np
import mahotas as mh
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.cross_validation import train_test_split
from sklearn.grid_search import GridSearchCV
from sklearn.metrics import classification_report
if __name__ == '__main__':
X = []
y = []
for path, subdirs, files in os.walk('data/English/Img/GoodImg/Bmp/'):
for filename in files:
f = os.path.join(path, filename)
target = filename[3:filename.index('-')]
img = mh.imread(f, as_grey=True)
if img.shape[0] <= 30 or img.shape[1] <= 30:
continue
img_resized = mh.imresize(img, (30, 30))
if img_resized.shape != (30, 30):
img_resized = mh.imresize(img_resized, (30, 30))
X.append(img_resized.reshape((900, 1)))
y.append(target)
X = np.array(X)
X = X.reshape(X.shape[:2])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.1)
pipeline = Pipeline([('clf', SVC(kernel='rbf', gamma=0.01, C=100))])
parameters = {
'clf__gamma': (0.01, 0.03, 0.1, 0.3, 1),
'clf__C': (0.1, 0.3, 1, 3, 10, 30),
}
from os import walk
from sklearn.preprocessing import scale
import os
print 'Loading the images...'
# TODO change path
X = []
y = []
for (dirpath, dirnames, filenames) in walk(
'/home/gavin/PycharmProjects/mastering-machine-learning/ch-reduction/data/faces94/male'
):
for fn in filenames:
if fn[-3:] == 'jpg':
image_filename = os.path.join(dirpath, fn)
X.append(
scale(mh.imread(image_filename, as_grey=True).reshape(36000)))
y.append(fn[:fn.index('.')])
X = np.array(X)
X_train, X_test, y_train, y_test = train_test_split(X, y)
n_components = 150
print 'Reducing the dimensions...'
pca = PCA(n_components=n_components)
X_train_reduced = pca.fit_transform(X_train)
X_test_reduced = pca.transform(X_test)
print X_train_reduced.shape
print X_test_reduced.shape
print 'Training the classifier...'
classifier = LogisticRegression()
X, kmeans_model.labels_, metric='euclidean')))
plt.show()
## Image Compression
# image quantization
# a lossy compression method that replaces a range
# similar colors (within-cluster members) in an image
# with a single color. it reduces the size of the image file.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.utils import shuffle
import mahotas as mh
# import utilities
original_img = np.array(mh.imread('image_quantization.png'),
dtype=np.float64) / 255
original_dimensions = tuple(original_img.shape)
width, height, depth = tuple(original_img.shape)
image_flattened = np.reshape(original_img, (width * height, depth))
# flatten image
image_array_sample = shuffle(image_flattened, random_state=0)[:1000]
estimator = KMeans(n_clusters=64, random_state=0)
estimator.fit(image_array_sample)
# create 64 clusters from a sample of 1000 randomly
# selected colors.
cluster_assignments = estimator.predict(image_flattened)
compressed_palette = estimator.cluster_centers_
compressed_img = np.zeros((width, height, compressed_palette.shape[1]))
label_idx = 0
for i in range(width):
# This code is supporting material for the book
# Building Machine Learning Systems with Python
# by Willi Richert and Luis Pedro Coelho
# published by PACKT Publishing
#
# It is made available under the MIT License
import numpy as np
import mahotas as mh
image = mh.imread('../1400OS_10_01.jpeg')
image = mh.colors.rgb2gray(image, dtype=np.uint8)
thresh = mh.thresholding.otsu(image)
print(thresh)
otsubin = (image > thresh)
mh.imsave('otsu-threshold.jpeg', otsubin.astype(np.uint8) * 255)
otsubin = ~mh.close(~otsubin, np.ones((15, 15)))
mh.imsave('otsu-closed.jpeg', otsubin.astype(np.uint8) * 255)
thresh = mh.thresholding.rc(image)
print(thresh)
mh.imsave('rc-threshold.jpeg', (image > thresh).astype(np.uint8) * 255)
import mahotas
import numpy as np
from pylab import imshow, show
f = mahotas.imread('mahotas/demos/data/nuclear.png')
f = f[:,:,0]
imshow(f)
show()
f = mahotas.gaussian_filter(f, 4)
f = (f> f.mean())
imshow(f)
show()
labeled, n_nucleus = mahotas.label(f)
print('Found {} nuclei.'.format(n_nucleus))
imshow(labeled)
show()
sizes = mahotas.labeled.labeled_size(labeled)
too_big = np.where(sizes > 10000)
labeled = mahotas.labeled.remove_regions(labeled, too_big)
imshow(labeled)
show()
labeled = mahotas.labeled.remove_bordering(labeled)
imshow(labeled)
show()
relabeled, n_left = mahotas.labeled.relabel(labeled)
print('After filtering and relabeling, there are {} nuclei left.'.format(n_left))
imshow(relabeled)
import numpy as np
import mahotas as mh
text = mh.imread("../Dataset/simple-dataset/text21.jpg")
scene = mh.imread("../Dataset/simple-dataset/scene00.jpg")
h, w, _ = text.shape
canvas = np.zeros((h, 2 * w + 128, 3), np.uint8)
canvas[:, -w:] = scene
canvas[:, :w] = text
canvas = canvas[::4, ::4]
mh.imsave('../charts/1400OS_10_10.jpg', canvas)
sorted_image = np.sort(np.uint8(original_image).ravel())
minval = np.float32(sorted_image[len(sorted_image) *
(saturation_level / 2)])
maxval = np.float32(sorted_image[len(sorted_image) *
(1 - saturation_level / 2)])
norm_image = np.float32(original_image - minval) * (255 /
(maxval - minval))
norm_image[norm_image < 0] = 0
norm_image[norm_image > 255] = 255
if invert:
norm_image = 255 - norm_image
return np.uint8(norm_image)
input_image = np.float32(
normalize_image(mahotas.imread(input_image_path),
invert=(not image_inverted)))
if image_downsample_factor != 1:
input_image = mahotas.imresize(input_image, image_downsample_factor)
average_image = combo_net.apply_combo_net(input_image)
def write_image(output_path, data, image_num=0, downsample=1):
if downsample != 1:
data = np.float32(mahotas.imresize(data, downsample))
maxdata = np.max(data)
mindata = np.min(data)
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path, np.uint16(normdata * 65535))
basedir = 'simple-dataset/'
def features_for(im):
im = mh.imread(im, as_grey=True).astype(np.uint8)
return mh.features.haralick(im).mean(0)
features = []
sobels = []
labels = []
images = glob('{}/*.jpg'.format(basedir))
for im in images:
features.append(features_for(im))
sobels.append(edginess_sobel(mh.imread(im, as_grey=True)))
labels.append(im[:-len('00.jpg')])
features = np.array(features)
labels = np.array(labels)
n = features.shape
nl = labels.shape
print('features=' + str(n))
print(str(features))
print('labels=' + str(nl))
print(str(labels))
scores = cross_validation.cross_val_score(LogisticRegression(),
features,
# 3 Class
#class_colors = [[255,0,0], [0,255,0], [0,0,255]]
#class_colors = [[255,85,255], [255,255,0], [0,255,255]]
# class_colors = [0, 1]
nclass = len(class_colors)
training_x = np.zeros((0,0), dtype=np.float32)
training_y = np.zeros((0,1), dtype=np.int32)
print 'Found {0} training images.'.format(len(files))
# Loop through all images
for file in files:
training_image = mahotas.imread(file)
for classi in range(nclass):
this_color = class_colors[classi]
# Find pixels for this class
# class_indices = np.nonzero(np.logical_and(
# training_image[:,:,this_color] > training_image[:,:,(this_color + 1) % 3],
# training_image[:,:,this_color] > training_image[:,:,(this_color + 2) % 3]))
class_indices = np.nonzero(np.logical_and(
training_image[:,:,0] == this_color[0],
training_image[:,:,1] == this_color[1],
training_image[:,:,2] == this_color[2]))
