def fond(premiere, derniere, pas=1):
image = misc.imread(fichiers[premiere])
fond = numpy.zeros(image.shape)
for n in range(premiere,derniere,pas):
image = misc.imread(fichiers[n])
fond = (image < fond)*fond + (image >= fond)*image
return Image.fromarray(fond).convert('L')
def build(path,pathdir,files,labels,all_count,ratio,size):
if not label_fixed:
train_labels=random.sample(labels,int(ratio*len(labels)))
else:
train_labels=labels[:int(ratio*len(labels))]
print train_labels[:20]
for i in train_labels:
labels.remove(i)
test_labels=labels
assert len(train_labels)+len(test_labels)==all_count
train_dates={label:[] for label in train_labels}
test_dates={label:[] for label in test_labels}
for file in files:
label=file[-11:-7]
if label in train_labels:
train_dates[label].append(0.001*(255-np.float32(imresize(imread(file,1),size))))
else:
test_dates[label].append(0.001*(255-np.float32(imresize(imread(file,1),size))))
train_rank_dates={}
for i in range(len(train_dates)):
train_rank_dates[i]=train_dates[train_dates.keys()[i]]
if cnn_only:
return train_rank_dates
x_train,y_train=get_sequence_images(train_rank_dates,train_labels,path_length,total_labels_per_seq,size,total_roads)
# x_train,y_train=get_sequence_images(train_dates,train_labels,path_length,total_labels_per_seq,size,total_roads)
x_test,y_test=get_sequence_images_cover(train_dates,test_dates,train_labels,test_labels,path_length,total_labels_per_seq,size,total_roads)
return x_train,y_train,x_test,y_test,train_labels,test_labels
def _load_datum(self, index, type):
"""Get inputs with global index (global means self.ids[index] works)"""
max_size = 500 * 500
roi = self.rois[index]
img = imread(self.img_files[index], mode='RGB')
if roi is not None:
(y_min, x_min), (y_max, x_max) = roi
img = img[y_min:y_max, x_min:x_max]
img, _ = fcn.util.resize_img_with_max_size(img, max_size=max_size)
label = np.zeros(img.shape[:2], dtype=np.int32) # bg_label is 0
height, width = img.shape[:2]
translation = (int(0.1 * np.random.random() * height),
int(0.1 * np.random.random() * width))
tform = skimage.transform.SimilarityTransform(translation=translation)
img = skimage.transform.warp(
img, tform, mode='constant', preserve_range=True).astype(np.uint8)
for label_value, mask_file in enumerate(self.mask_files[index]):
if mask_file is None:
continue
mask = imread(mask_file, mode='L')
if roi is not None:
(y_min, x_min), (y_max, x_max) = roi
mask = mask[y_min:y_max, x_min:x_max]
mask, _ = fcn.util.resize_img_with_max_size(mask, max_size)
mask = skimage.transform.warp(
mask, tform, mode='constant',
preserve_range=True).astype(np.uint8)
label[mask == 255] = label_value
return img, label
def batch_predict(filenames, net):
"""
Get the features for all images from filenames using a network
Inputs:
filenames: a list of names of image files
Returns:
an array of feature vectors for the list of files given
"""
N, C, H, W = net.blobs[net.inputs[0]].data.shape
F = net.blobs[net.outputs[0]].data.shape[1]
Nf = len(filenames)
Hi, Wi, _ = imread(filenames[0]).shape
allftrs = np.zeros((Nf, F))
for i in range(0, Nf, N):
in_data = np.zeros((N, C, H, W), dtype=np.float32)
batch_range = range(i, min(i+N, Nf))
batch_filenames = [filenames[j] for j in batch_range]
Nb = len(batch_range)
batch_images = np.zeros((Nb, 3, H, W))
for j,fname in enumerate(batch_filenames):
im = imread(fname)
# change grayscale to RGB
if len(im.shape) == 2:
im = np.tile(im[:,:,np.newaxis], (1,1,3))
# lots of steps here to convert a scipy imread image to
# the dimensions and channel ordering that caffe expects
# Briefly, scipy.io.imread returns a HxWxC array in RGB channel order,
# whereas we need a CxHxW array in BGR order and subtract the mean
# RGB -> BGR
# im = im[:,:,(2,1,0)]
# mean subtraction
#im = im - np.array([103.939, 116.779, 123.68])
# resize
im = imresize(im, (H, W))
MEAN_FILE = '/afs/cs.stanford.edu/u/anenberg/scr/CS231N/examples/UCFff/mean.npy'
# get channel in correct dimension
im = np.transpose(im, (2, 0, 1))
im = im - np.load(MEAN_FILE)
batch_images[j,:,:,:] = im
# insert into correct place
in_data[0:len(batch_range), :, :, :] = batch_images
# predict features
ftrs = predict(in_data, net)
for j in range(len(batch_range)):
allftrs[i+j,:] = ftrs[j,:]
print 'Done %d/%d files' % (i+len(batch_range), len(filenames))
return allftrs
def computeDiff(file1, file2):
# read images as 2D arrays (convert to grayscale for simplicity)
img1 = to_grayscale(imread(file1).astype(float))
img2 = to_grayscale(imread(file2).astype(float))
# compare
n_m, n_0 = compare_images(img1, img2)
return n_m*1.0/img1.size
def main():
image_file_name_0 = '/local/data/2014_07/TXM_commissioning/test/rotation_axis_twicking/Pin_0deg.tif'
image_file_name_180 = '/local/data/2014_07/TXM_commissioning/test/rotation_axis_twicking/Pin_180deg.tif'
# image_0 = read_tiff(image_file_name_0)
# image_180 = read_tiff(image_file_name_180)
image_0 = misc.imread(image_file_name_0)
image_180 = misc.imread(image_file_name_180)
image_180 = np.fliplr(image_180)
image_0 = image_0[400:700, 300:1000]
image_180 = image_180[400:700, 300:1000]
print image_180.shape
im2, scale, angle, t = similarity(image_0, image_180)
print "Scale: ", scale, "Angle: ", angle, "Transformation Matrix: ", t
rot_axis_shift_x = -t[0]/2.0
rot_axis_tilt = -t[1]/1.0
print "Rotation Axis Shift (x, y):", "(", rot_axis_shift_x, ",", rot_axis_tilt,")"
plt.subplot(2,2,1)
plt.imshow(image_0, cmap=plt.cm.hot)
plt.title('0^o image'), plt.colorbar()
plt.subplot(2,2,2)
plt.imshow(image_180, cmap=plt.cm.hot)
plt.title('180^o image flipped left - right'), plt.colorbar()
plt.subplot(2,2,3)
plt.imshow(im2, cmap=plt.cm.hot)
plt.title('Im2 shifted'), plt.colorbar()
plt.show()
def searchPic():
searchTerm = kwords.get()
searchTerm = searchTerm.replace(' ','%20')
url = ('https://ajax.googleapis.com/ajax/services/search/images?v=1.0&q=' +
searchTerm+ '&userip=INSERT-USER-IP')
request = urllib2.Request(url)
response = urllib2.urlopen(request)
# Process the JSON string.
results = simplejson.load(response)
imgURL = results['responseData']['results'][0]['unescapedUrl']
imgName = imgURL.split('/')[-1]
img_temp = urllib.URLopener().retrieve(imgURL, imgName)
img_array = imread(img_temp[0])
url_label.config(text=imgURL)
imgLF.image = imread(imgName, flatten=True)
imgLF.image_clr = imread(imgName)
ax1.imshow(imgLF.image, cmap=plt.cm.gray)
canvas.show()
refresh.config(state=NORMAL, command=refresh_func)
blur.config(state=NORMAL, command=blur_func)
sharpen.config(state=NORMAL, command=sharpen_func)
smooth.config(state=NORMAL, command=smooth_func)
edge.config(state=NORMAL, command=edge_func)
#contrast.config(state=NORMAL, command=contrast_func)
color.config(state=NORMAL, command=color_func)
decolor.config(state=NORMAL, command=decolor_func)
brighten.config(state=NORMAL, command=brighten_func)
darken.config(state=NORMAL, command=darken_func)
def fond(premiere, derniere, pas=1):
image = misc.imread(fichiers[premiere])
fond = numpy.ones(image.shape)*255
for n in range(premiere,derniere,pas):
image = misc.imread(fichiers[n])
fond = (image > fond)*fond + (image <= fond)*image
return fond
def copy_incorrect(in_folder, out_folder, incorrect_files="snapshotVGG1-5-test.txt"):
from scipy.misc import imread, imsave, imrotate
print(incorrect_files)
if os.path.exists(incorrect_files):
f = open(incorrect_files, "r")
print("File found")
else:
f = open(os.path.join(in_folder, "stats", incorrect_files), "r")
page = f.read()
sources = page.split('\n')
print(sources)
print(len(sources))
count = 0
for source in sources:
if source.find("jpg") >= 0:
fileinfo = source
if source.find(",") >= 0:
fileinfo = source.split(", ")[0]
rotation = source.split(", ")[1]
image = imread(fileinfo)
image = imrotate(image, int(rotation))
else:
image = imread(fileinfo)
if count == 0:
print(fileinfo)
count += 1
destination = os.path.split(fileinfo.replace(in_folder, out_folder))[0]
if not os.path.exists(destination):
os.makedirs(destination)
filename = os.path.split(fileinfo)[1]
# print(os.path.join(destination, filename))
imsave(os.path.join(destination, filename), image)
print("Moved " + str(count) + " files")
def run_example( size = 64 ):
"""
Run this file and result will be saved as 'rsult.jpg'
Buttle neck: map
"""
modes = """
normal
add substract multiply divide
dissolve overlay screen pin_light
linear_light soft_light vivid_light hard_light
linear_dodge color_dodge linear_burn color_burn
light_only dark_only lighten darken
lighter_color darker_color
"""
top = misc.imresize( misc.imread('./imgs/top.png')[:,:,:-1], (size,size,3) )
base = misc.imresize( misc.imread('./imgs/base.png')[:,:,:-1], (size,size,3) )
modes = modes.split()
num_of_mode = len( modes )
result = np.zeros( [ size*2, size*(num_of_mode//2+2), 3 ])
result[:size:,:size:,:] = top
result[size:size*2:,:size:,:] = base
for index in xrange( num_of_mode ):
y = index // 2 + 1
x = index % 2
tmp= blends.blend( top, base, modes[index] )
result[ x*size:(x+1)*size, y*size:(y+1)*size, : ] = tmp
# random blend
result[-size::,-size::,:] = blends.random_blend( top, base )
misc.imsave('result.jpg',result)
def getHaar (filepath, row, col, Npos, Nneg): Nimg = Npos + Nneg Nfeatures = 295936 #change this number if you need to use more/less features features = np.zeros((Nfeatures, Nimg)) files = glob.glob(filepath+ "faces/*.jpg") for i in xrange (Npos): print "\nComputing Haar Face ",i imgGray = misc.imread (files[i], flatten=1) #array of floats, gray scale image if (i < Npos): # convert to integral image intImg = np.zeros((row+1,col+1)) intImg [1:row+1,1:col+1] = np.cumsum(cumsum(imgGray,axis=0),axis=1) # compute features features [:,i] = computeFeature(intImg,row,col,Nfeatures) files = glob.glob(filepath+ "background/*.jpg") for i in xrange (Nneg): print "\nComputing Haar Background ",i imgGray = misc.imread (files[i], flatten=1) #array of floats, gray scale image if (i < Nneg): # convert to integral image intImg = np.zeros((row+1,col+1)) intImg [1:row+1,1:col+1] = np.cumsum(cumsum(imgGray,axis=0),axis=1) # print intImg.shape # import pdb pdb.set_trace() # compute features features[:,i+Npos] = computeFeature(intImg,row,col,Nfeatures) # print "feat ", features[1000,:] return features
def resize_and_save(df, img_name, true_idx, size='80x50', fraction=0.125):
'''
INPUT: (1) Pandas DF
(2) string: image name
(3) integer: the true index in the df of the image
(4) string: to append to filename
(5) float: fraction to scale images by
OUTPUT: None
Resize and save the images in a new directory.
Try to read the image. If it fails, download it to the raw data directory.
Finally, read in the full size image and resize it.
'''
try:
img = imread(img_name)
except:
cardinal_dir = img_name[-5:-4]
cardinal_translation = {'N': 0, 'E': 90, 'S': 180, 'W': 270}
coord = (df.ix[true_idx]['lat'], df.ix[true_idx]['lng'])
print 'Saving new image...'
print coord, cardinal_dir, cardinal_translation[cardinal_dir]
save_image(coord, cardinal_translation[cardinal_dir], loc='newdata')
finally:
img_name_to_write = ('newdata_' + size + '/' +
img_name[8:-4] + size + '.png')
if os.path.isfile(img_name_to_write) == False:
img = imread(img_name)
resized = imresize(img, fraction)
print 'Writing file...'
imsave(img_name_to_write, resized)
def __init__(self, folder, im_type='tif'):
"""
Load a previously acquired series of projections for analysis and
reconstruction.
# folder: Path to folder where projections are stored. Reconstructed
slices will also be saved here.
"""
self.folder = os.path.split(os.path.abspath(folder))[0]
self.p0 = 0
self.cor_offset = 0
self.crop = None, None, None, None
self.num_images = None
self.angles = None
files = [f for f in os.listdir(folder) if f[-4:] == '.%s' % im_type]
im_shape = imread(os.path.join(folder, files[0])).shape
self.im_stack = np.zeros(im_shape + (len(files), ))
for idx, fname in enumerate(files):
sys.stdout.write('\rProgress: [{0:20s}] {1:.0f}%'.format('#' *
int(20*(idx + 1) / len(files)),
100*((idx + 1)/len(files))))
sys.stdout.flush()
f = os.path.join(folder, fname)
self.im_stack[:, :, idx] = imread(f)
self.height = self.im_stack.shape[0]
self.width = self.im_stack.shape[1]
def example():
# todo: read the example image from the papers source directory
image1=imread(wrapper.source_directory+'/examples/gobelet.png')
image2=imread(wrapper.source_directory+'/examples/gobelet2.png')
# todo: call the wrapped function(s) with a valid set of arguments
#keys1=wrapper.
keys1=wrapper.extract_surf(image1)
keys2=wrapper.extract_surf(image2)
matches=wrapper.match_surf(keys1,keys2)
# todo: display the results
fig = plt.figure(figsize=(10,5))
ax1 = fig.add_subplot(121)
plt.imshow(image1)
ax2 = fig.add_subplot(122)
plt.imshow(image2)
for x1,y1,x2,y2 in matches:
con = ConnectionPatch(xyA=(x2, y2), xyB=(x1,y1), coordsA="data", coordsB="data" ,
axesA=ax2, axesB=ax1,
shrinkB=5,color='r')
ax2.add_artist(con)
plt.draw()
plt.show()
print 'done'
def play_color_likeness(df):
'''
INPUT: (1) Pandas DF
OUTPUT: None
Pull 20 images and show the most similar images
as found by euclidean distance from their color histograms.
'''
some_random_files = [random_file_pull(df, yield_all_info=True).next()
for _ in range(20)]
for img_info_tuple in some_random_files:
source_idx = img_info_tuple[0]
direction = img_info_tuple[1]
filename = img_info_tuple[2]
column_direction = 'nearest_10_neighbors_euclidean_' + direction
nearest_image_idx = df[column_direction][source_idx][0]
nearest_image = (df['base_filename'][nearest_image_idx] +
direction + '.png')
print "original image location is {}, {}".format(
df['lat'][source_idx], df['lng'][source_idx])
print "new image location is {}, {}".format(
df['lat'][nearest_image_idx], df['lng'][nearest_image_idx])
print "the indices in the df are {} and {}".format(
source_idx, nearest_image_idx)
print "\n"
fig = plt.figure(figsize=(16, 8))
# Show search image and most similar image in database #
ax = fig.add_subplot(2, 2, 1)
ax.imshow(imread(filename))
ax2 = fig.add_subplot(2, 2, 2)
ax2.imshow(imread(nearest_image))
ax.set_xticks([])
ax.set_yticks([])
ax2.set_xticks([])
ax2.set_yticks([])
# Plot scatter of nearest 10 and a sampling of all datapoints #
# See plot_nearest_10 for a better visualization #
ax3 = fig.add_subplot(2, 2, 3)
nearest_10 = find_locations_nearest_10(source_idx, direction)
true_loc = df['lat'][source_idx], df['lng'][source_idx]
ax3.scatter(nearest_10[2:, 1], nearest_10[2:, 0])
ax3.scatter(true_loc[1], true_loc[0], color='#33FFFF',
label='true loc', s=30)
ax3.scatter(nearest_10[0][1], nearest_10[0][0],
color='#00FF00', label='best guess', s=30)
ax3.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2,
mode="expand", borderaxespad=0.)
ax4 = fig.add_subplot(2, 2, 4)
ax4.scatter(df['lng'][::10], df['lat'][::10])
ax3.set_xlabel("Longitude")
ax4.set_xlabel("Longitude")
ax4.set_ylabel("Latitude")
ax3.set_ylabel("Latitude")
ax3.set_xlim(-109.5, -102.5)
ax4.set_xlim(-109.5, -102.5)
ax4.set_ylim(37, 41)
ax3.set_ylim(37, 41)
plt.show()
def run_build_model():
import glob
from scipy import io, misc
DATA_DIR = '../others/icaam/examples/cootes'
training_files = sorted(glob.glob(DATA_DIR + '/*.bmp.mat'))
fst_im = misc.imread(training_files[0][:-4])
ni, nj, nc = fst_im.shape
ns = len(training_files)
np, nd = io.loadmat(training_files[0])['annotations'].shape
appearances = zeros((ns, ni, nj, nc))
shapes = zeros((ns, np, nd))
for i in range(ns):
name = training_files[i]
app = misc.imread(name[:-4])
appearances[i, :, :, :] = app
d = io.loadmat(name)
annotations = d['annotations']
shapes[i, :, :] = xy2ij(annotations, ni)
AAM = build_model(shapes, appearances)
def match(pic1,pic2):
file1 = Image.open(pic1)
file2 = Image.open(pic2)
#img1 = file1.crop((100, 0, 500, 550))
img1 = file1.crop((327, 219, 615, 576))
img1.save("img1.jpg")
# w = file2.size
#h = file2.size
#img2 = file2.crop((100, 0, 500, 550))
img2 = file2.crop((327, 219, 615, 576))
img2.save("img2.jpg")
# read images as 2D arrays (convert to grayscale for simplicity)
img1 = to_grayscale(imread("img1.jpg").astype(float))
img2 = to_grayscale(imread("img2.jpg").astype(float))
#img1 = to_grayscale(img1.astype(float))
#img2 = to_grayscale(img2.astype(float))
# compare
n_m, n_0 = compare_images(img1, img2)
if n_m/img1.size <= 45 and n_0*1.0/img1.size <=45:
return True
else:
return False
def main():
k = 0.5
pan = scm.imread('assets/scale/taipei_pan.jpg')
mul = scm.imread('assets/scale/taipei_mul.jpg')
r = mul[:, :, 0]
g = mul[:, :, 1]
b = mul[:, :, 2]
time_start = time.time()
i = (r*0.171 +g*0.2+b*0.171)/0.632
kx__pan_minus_iii = k*(pan-i)
coe = pan/(i+kx__pan_minus_iii)
nr = coe * (r+kx__pan_minus_iii)
ng = coe * (g+kx__pan_minus_iii)
nb = coe * (b+kx__pan_minus_iii)
finish_time = time.time() - time_start
print("finish time:", finish_time, " s")
output_img = np.empty_like(mul)
output_img[:, :, 0] = nr
output_img[:, :, 1] = ng
output_img[:, :, 2] = nb
scm.imsave("output.jpg", output_img)
def file_reader(filename, **kwds):
'''Read data from any format supported by PIL.
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((d,w,h))
for i in xrange(d):
dc[i,:,:] = imread(flist[i])
else:
dc = imread(filename)
dt = 'image'
return [{'data':dc,
'mapped_parameters': {
'original_filename' : filename,
'record_by': dt,
'signal_type' : None,
}
}]
def build(path,pathdir,files,files_eval,labels,labels_eval,all_count,size):
train_labels=labels
test_labels=labels_eval
assert len(train_labels)+len(test_labels)==all_count
train_dates={label:[] for label in train_labels}
test_dates={label:[] for label in test_labels}
for file in (files+files_eval):
label=file[-11:-7]
if label in train_labels:
train_dates[label].append(0.001*(255-np.float32(imresize(imread(file,1),size))))
else:
test_dates[label].append(0.001*(255-np.float32(imresize(imread(file,1),size))))
train_rank_dates={}
for i in range(len(train_dates)):
train_rank_dates[i]=train_dates[train_dates.keys()[i]]
if cnn_only:
return train_rank_dates
print '\ntrain keys:',train_dates.keys()
# print train_rank_dates.keys()
print 'test keys:',test_dates.keys(),'\n'
x_train,y_train=get_sequence_images(train_rank_dates,train_labels,path_length,total_labels_per_seq,size,total_roads)
# x_train,y_train=get_sequence_images(train_dates,train_labels,path_length,total_labels_per_seq,size,total_roads)
x_test,y_test=get_sequence_images(test_dates,test_labels,path_length,total_labels_per_seq,size,total_roads)
return x_train,y_train,x_test,y_test
def example():
from matplotlib import pyplot as plt
import numpy as np
# todo: read the example image from the papers source directory
image1=imread(os.path.join(wrapper.source_directory,'data','tsukuba0.png'))
image2=imread(os.path.join(wrapper.source_directory,'data','tsukuba1.png'))
output=wrapper.stereoGuidedFilter(image1,image2,dmin=-15,dmax=0)
print 'found disparities :'
v,c=np.unique(output['disparity'],return_counts=True)
plt.plot(v,c)
plt.title('nb pixel per disparity')
# todo: display the results
plt.figure()
plt.subplot(2,2,1)
plt.imshow(output['disparity'].astype(np.float),cmap='Greys_r')
plt.subplot(2,2,2)
plt.imshow(output['occlusion'].astype(np.float),cmap='Greys_r')
plt.subplot(2,2,3)
plt.imshow(output['occlusion_filled'].astype(np.float),cmap='Greys_r')
plt.subplot(2,2,4)
plt.imshow(output['occlusion_filled_smoothed'].astype(np.float),cmap='Greys_r')
plt.show()
print 'done'
def distTest(net1):
myImage1 = '/Users/shkejriwal/Documents/personal/data/myPics/small_full_face.jpg'
myImage2 = '/Users/shkejriwal/Documents/personal/data/myPics/small_full_face_no_glass.jpg'
#myImage2 = myImage1
img1 = scipyMisc.imread(myImage1)
#X1 = prepare1DImage(img1)
X1 = prepare2DImage(img1)
y1 = net1.predict(X1)
img2 = scipyMisc.imread(myImage2)
#X2 = prepare1DImage(img2)
X2 = prepare2DImage(img2)
#X2 = load2d(test=True)[0][6:7]
#X2 = load2d(test=True)[0][15]
y2 = net1.predict(X2)
#dist = HausdorffDist(y1[0],y2[0])
dist = distanceBetweenCurves(y1[0],y2[0])
print dist
def initialize(self, filename):
# read filename
with open(filename) as f:
for line in f:
cline = re.split('\s',line)
# tuple (rgb_filename, gt_filename)
self.flist.append((cline[0], cline[1]))
self.N = len(self.flist)
# get sizes
(rgbname, gtname) = self.flist[0]
rgb = misc.imread(rgbname)
if(gtname.endswith('.png')):
gt = misc.imread(gtname)
else:
gt = np.loadtxt(gtname)
(self.H, self.W, self.CH) = rgb.shape
gtshape = gt.shape
self.HL = gtshape[0]
self.WL = gtshape[1]
if(len(gtshape) == 2):
self.CHL = 1
else:
self.CHL = gtshape[2]
# just retrieve the new sizes
if( (self.data_transformer is not None) and self.data_transformer.isResized() ):
(self.H, self.W) = self.data_transformer.getNewDims()
self.HL = self.H
self.WL = self.W
def image_compare(df, IMAGES_DIR='/home/ryan/asi_images/'):
'''
takes a list of n image ids and returns sum(n..n-1) n comparisons of r2 difference, r2(fft) difference, and average number of thresholded pixels
'''
img_buffer = {}
return_list = []
artdf = df[['_id', 'images']].copy()
artdf.images = artdf.images.apply(getpath)
paths = artdf[['_id','images']].dropna()
paths.index = paths._id
paths = paths.images
if paths.shape[0] < 2:
return DataFrame([])
for id_pair in combinations(paths.index, 2):
if id_pair[0] in img_buffer:
img1 = img_buffer[id_pair[0]]
else:
img_buffer[id_pair[0]] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + paths[id_pair[0]]), (300,300))))
img1 = img_buffer[id_pair[0]]
if id_pair[1] in img_buffer:
img2 = img_buffer[id_pair[1]]
else:
img_buffer[id_pair[1]] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + paths[id_pair[1]]), (300,300))))
img2 = img_buffer[id_pair[1]]
return_list.append(
[id_pair[0], id_pair[1], \
norm(img1 - img2), \
norm(fft2(img1) - fft2(img2)), \
#mean([sum(img1 > threshold_otsu(img1)), sum(img2 > threshold_otsu(img2))])]
#mean([sum(img1 > 0.9), sum(img2 > 0.9)])]
std(img1)+std(img2)/2.]
)
return DataFrame(return_list, columns=['id1','id2','r2diff', 'fftdiff', 'stdavg'])
def getBatch_(self, indices):
# format NxCHxWxH
batchRGB = np.zeros((len(indices), self.CH, self.W, self.H), dtype='float32')
batchLabel = np.zeros((len(indices), self.W, self.H), dtype='int32')
k = 0
for i in indices:
(rgbname, gtname) = self.flist[i]
# format: HxWxCH
rgb = misc.imread(rgbname)
if(gtname.endswith('.png')):
gt = misc.imread(gtname)
else:
gt = np.loadtxt(gtname)
gt = gt.astype('uint8')
if(self.data_transformer is not None):
rgb = self.data_transformer.transformData(rgb)
gt = self.data_transformer.transformLabel(gt)
#^ data_transformer outputs in format HxWxCH
# convertion from HxWxCH to CHxWxH
batchRGB[k,:,:,:] = rgb.astype(np.float32).transpose((2,1,0))
batchLabel[k,:,:] = gt.astype(np.int32).transpose((1,0))
k += 1
#ipdb.set_trace()
if(self.weights_classes_flag):
return (batchRGB, batchLabel, self.weights_classes)
else:
return (batchRGB, batchLabel)
def test_imsave(self):
picdir = os.path.join(datapath, "data")
for png in glob.iglob(picdir + "/*.png"):
with suppress_warnings() as sup:
# PIL causes a Py3k ResourceWarning
sup.filter(message="unclosed file")
img = misc.imread(png)
tmpdir = tempfile.mkdtemp()
try:
fn1 = os.path.join(tmpdir, 'test.png')
fn2 = os.path.join(tmpdir, 'testimg')
with suppress_warnings() as sup:
# PIL causes a Py3k ResourceWarning
sup.filter(message="unclosed file")
misc.imsave(fn1, img)
misc.imsave(fn2, img, 'PNG')
with suppress_warnings() as sup:
# PIL causes a Py3k ResourceWarning
sup.filter(message="unclosed file")
data1 = misc.imread(fn1)
data2 = misc.imread(fn2)
assert_allclose(data1, img)
assert_allclose(data2, img)
assert_equal(data1.shape, img.shape)
assert_equal(data2.shape, img.shape)
finally:
shutil.rmtree(tmpdir)
def repeated_sales(df, artistname, artname, r2thresh=7000, fftr2thresh=10000, IMAGES_DIR='/home/ryan/asi_images/'):
"""
Takes a dataframe, artistname and artname and tries to decide, via image matching, if there is a repeat sale. Returns a dict of lot_ids, each entry a list of repeat sales
"""
artdf = df[(df['artistID']==artistname) & (df['artTitle']==artname)]
artdf.images = artdf.images.apply(getpath)
paths = artdf[['_id','images']].dropna()
id_dict = {}
img_buffer = {}
already_ordered = []
for i, path_i in paths.values:
id_dict[i] = []
img_buffer[i] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + path_i), (300,300))))
for j, path_j in paths[paths._id != i].values:
if j > i and j not in already_ordered:
if j not in img_buffer.keys():
img_buffer[j] = img_as_float(rgb2gray(resize(imread(IMAGES_DIR + path_j), (300,300))))
if norm(img_buffer[i] - img_buffer[j]) < r2thresh and\
norm(fft2(img_buffer[i]) - fft2(img_buffer[j])) < fftr2thresh:
id_dict[i].append(j)
already_ordered.append(j)
for key in id_dict.keys():
if id_dict[key] == []:
id_dict.pop(key)
return id_dict
def doMyTest(net1):
#myImage = '/Users/shkejriwal/Documents/personal/data/myPics/small_no_glasses.jpg'
#myImage = '/Users/shkejriwal/Documents/personal/data/myPics/small.jpg'
#myImage = '/Users/shkejriwal/Documents/personal/data/myPics/small_sk_closeup.jpg'
myImage1 = '/Users/shkejriwal/Documents/personal/data/myPics/small_full_face.jpg'
myImage2 = '/Users/shkejriwal/Documents/personal/data/myPics/small_full_face_no_glass.jpg'
img1 = scipyMisc.imread(myImage1)
#X1 = prepare1DImage(img1)
X1 = prepare2DImage(img1)
sample1 = load(test=True)[0][6:7]
img2 = scipyMisc.imread(myImage2)
#X2 = prepare1DImage(img2)
X2 = prepare2DImage(img2)
y1 = net1.predict(X1)
y2 = net1.predict(X2)
fig = pyplot.figure(figsize=(6, 3))
ax = fig.add_subplot(1, 2, 1, xticks=[], yticks=[])
plot_sample(X1[0], y1[0],ax)
ax = fig.add_subplot(1, 2, 2, xticks=[], yticks=[])
plot_sample(X2[0], y2[0],ax)
pyplot.show()
def testsift(image1, image2, maxd=1000, distthresh=0.4):
im1 = imread(image1)
print im1[:, :]
im2 = imread(image2)
print im2.shape
kdt = [[], [], []]
d1 = [[], [], []]
d2 = [[], [], []]
C = 3
for channel in range(C):
if C == 1:
_, d1[channel] = sift.descriptors(im1, maxd)
else:
_, d1[channel] = sift.descriptors(im1[:, :, channel], maxd)
print channel, d1[channel].shape
if C == 1:
_, d2[channel] = sift.descriptors(im2, maxd)
else:
_, d2[channel] = sift.descriptors(im2[:, :, channel], maxd)
print channel, d2[channel].shape
kdt[channel] = KDTree(d1[channel])
for desc in d2[channel]:
dist, index = kdt[channel].query(desc)
if distthresh >= dist:
print dist, index
def example():
from matplotlib import pyplot as plt
import numpy as np
# todo: read the example image from the papers source directory
image1=imread(wrapper.source_directory+'/adam1.png')
image2=imread(wrapper.source_directory+'/adam2.png')
# todo: call the wrapped function(s) with a valid set of arguments
matches,keys1,keys2=wrapper.asift(image1,image2)
# todo: display the results
fig = plt.figure(figsize=(10,5))
ax1 = fig.add_subplot(121)
plt.imshow(image1,cmap='Greys_r')
ax2 = fig.add_subplot(122)
plt.imshow(image2,cmap='Greys_r')
for x1,y1,x2,y2 in matches[::1,:]:
con = ConnectionPatch(xyA=(x2, y2), xyB=(x1,y1), coordsA="data", coordsB="data" ,
axesA=ax2, axesB=ax1,
shrinkB=5,color='r')
ax2.add_artist(con)
plt.draw()
plt.show()
print 'done'
def align_data(input_dir='./input_dir/', output_dir='./out_dir'):
output_dir_path = output_dir
output_dir = os.path.expanduser(output_dir_path)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
datadir = input_dir
dataset = facenet.get_dataset(datadir)
startTime = datetime.now()
print('Creating networks and loading parameters')
with tf.Graph().as_default():
# sess = tf.Session(config=tf.ConfigProto(log_device_placement=False)) #Removed gpu_options since commented out above
# with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(
None) # From https://github.com/davidsandberg/facenet/issues/412
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
image_size = 182
# Add a random key to the filename to allow alignment using multiple processes
random_key = np.random.randint(0, high=99999)
bounding_boxes_filename = os.path.join(
output_dir, 'bounding_boxes_%05d.txt' % random_key)
print('Goodluck')
with open(bounding_boxes_filename, "w") as text_file:
nrof_images_total = 0
nrof_successfully_aligned = 0
for cls in dataset:
output_class_dir = os.path.join(output_dir, cls.name)
if not os.path.exists(output_class_dir):
os.makedirs(output_class_dir)
for image_path in cls.image_paths:
nrof_images_total += 1
filename = os.path.splitext(os.path.split(image_path)[1])[0]
output_filename = os.path.join(output_class_dir,
filename + '.png')
print(image_path)
if not os.path.exists(output_filename):
try:
img = misc.imread(image_path)
print('read data dimension: ', img.ndim)
except (IOError, ValueError, IndexError) as e:
errorMessage = '{}: {}'.format(image_path, e)
print(errorMessage)
else:
if img.ndim < 2:
print('Unable to align "%s"' % image_path)
# text_file.write('%s\n' % (output_filename))
continue
if img.ndim == 2:
img = facenet.to_rgb(img)
print('to_rgb data dimension: ', img.ndim)
img = img[:, :, 0:3]
print('after data dimension: ', img.ndim)
bounding_boxes, _ = detect_face.detect_face(
img, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('detected_face: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(img.shape)[0:2]
if nrof_faces > 1:
bounding_box_size = (det[:, 2] - det[:, 0]) * (
det[:, 3] - det[:, 1])
img_center = img_size / 2
offsets = np.vstack([
(det[:, 0] + det[:, 2]) / 2 -
img_center[1],
(det[:, 1] + det[:, 3]) / 2 - img_center[0]
])
offset_dist_squared = np.sum(
np.power(offsets, 2.0), 0)
index = np.argmax(
bounding_box_size - offset_dist_squared *
2.0) # some extra weight on the centering
det = det[index, :]
det = np.squeeze(det)
bb_temp = np.zeros(4, dtype=np.int32)
bb_temp[0] = det[0]
bb_temp[1] = det[1]
bb_temp[2] = det[2]
bb_temp[3] = det[3]
try:
cropped_temp = img[bb_temp[1]:bb_temp[3],
bb_temp[0]:bb_temp[2], :]
scaled_temp = misc.imresize(
cropped_temp, (image_size, image_size),
interp='bilinear')
nrof_successfully_aligned += 1
misc.imsave(output_filename, scaled_temp)
# text_file.write('%s %d %d %d %d\n' % (output_filename, bb_temp[0], bb_temp[1], bb_temp[2], bb_temp[3]))
except Exception as e:
os.remove(image_path)
else:
print('Unable to align "%s"' % image_path)
os.remove(image_path)
print('removed file %s' % image_path)
# text_file.write('%s\n' % (output_filename))
print('Total number of images: %d' % nrof_images_total)
print('Number of successfully aligned images: %d' %
nrof_successfully_aligned)
os.remove(bounding_boxes_filename)
print(datetime.now() - startTime)
import matplotlib.pyplot as plt
import itertools
#################
#load validation images
#################
ValidationPath = 'E:/Eslam/Data Science/Nile University/CIT-690-A Selected Topics in Machine Learning/Assignment 1 - Perceptron/Validation'
os.chdir(ValidationPath)
Validation_Lables = np.loadtxt('Validation Labels.txt')
filesvalid = os.listdir(ValidationPath)
filesvalid.pop()
filesvalid = sorted(filesvalid, key=lambda x: int(os.path.splitext(x)[0]))
all_validation = []
for i in filesvalid:
imgvalidation = misc.imread(i)
type(imgvalidation)
imgvalidation.shape
#change dimention to 1 dimentional array instead of (28x28)
imgvalidation = imgvalidation.reshape(784, )
imgvalidation = np.append(imgvalidation, 1)
all_validation.append(imgvalidation)
############################
#Load Wieght Vector per eta
############################
Weightpath = 'E:/Eslam/Data Science/Nile University/CIT-690-A Selected Topics in Machine Learning/Assignment 1 - Perceptron/Training Wieght Vectors'
os.chdir(Weightpath)
#Wx is wieght matrix (10X785) computed for different eta
W0 = np.loadtxt('w_eta_0.txt')
import matplotlib.pyplot as plt #importing matplotlib
from scipy import misc
from skimage import transform
imsize = 512
img = misc.imread("contents/content7.jpg", mode='RGB').astype(float)
img = transform.resize(img, (imsize, imsize))
print(img)
plt.figure()
plt.hist(img.ravel(), bins=256, range=(0, 256), fc='k', ec='k')
plt.savefig("content_hist.jpg")
img = misc.imread("chol.jpg", mode='RGB')
plt.figure()
plt.hist(img.ravel(), bins=256, range=(0, 256), fc='k', ec='k')
plt.savefig("chol_hist.jpg")
img = misc.imread("chol.jpg", mode='RGB')
plt.figure()
plt.hist(img.ravel(), bins=256, range=(0, 256), fc='k', ec='k')
plt.savefig("pca_hist.jpg")
from scipy.misc import imread
from caffe_classes import class_names
from alexnet import AlexNet
x = tf.placeholder(tf.float32, (None, 32, 32, 3))
resized = tf.image.resize_images(x, size=(227, 227))
probs = AlexNet(resized)
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# Read Images
im1 = imread("construction.jpg").astype(np.float32)
im1 = im1 - np.mean(im1)
im2 = imread("stop.jpg").astype(np.float32)
im2 = im2 - np.mean(im2)
# Run Inference
t = time.time()
output = sess.run(probs, feed_dict={x: [im1, im2]})
# Print Output
for input_im_ind in range(output.shape[0]):
inds = np.argsort(output)[input_im_ind, :]
print("Image", input_im_ind)
for i in range(5):
print("%s: %.3f" %
from scipy.misc import imread, imsave
import numpy as np
def ycbcr2rgb(im):
xform = np.array([[1, 0, 1.402], [1, -0.34414, -.71414], [1, 1.772, 0]])
rgb = im.astype(np.float)
rgb[:, :, [1, 2]] -= 128
return rgb.dot(xform.T)
gt = imread('butterfly_GT.bmp')
gt = ycbcr2rgb(gt)
gt = gt[:, :, 0]
gt = gt[6:231, 6:231, :]
imsave('ground_true_Y.png', gt)
test = imread('sr.bmp')
test = ycbcr2rgb(test)
test = test[:, :, 0]
#imsave('test.png', test)
name='weights')
fc3b = tf.Variable(tf.constant(1.0, shape=[1000],
dtype=tf.float32),
trainable=True,
name='biases')
self.fc3l = tf.nn.bias_add(tf.matmul(self.fc2, fc3w), fc3b)
self.parameters += [fc3w, fc3b]
def load_weights(self, weight_file, sess):
weights = np.load(weight_file)
keys = sorted(weights.keys())
self.layers = keys[:-6]
self.layers = [x[:-2] for x in self.layers]
for i, k in enumerate(keys):
print i, k, np.shape(weights[k])
sess.run(self.parameters[i].assign(weights[k]))
if __name__ == '__main__':
sess = tf.Session()
imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
vgg = vgg16(imgs, 'vgg16_weights.npz', sess)
img1 = imread('boston_terrier.jpg', mode='RGB')
img1 = imresize(img1, (224, 224))
prob = sess.run(vgg.probs, feed_dict={vgg.imgs: [img1]})[0]
preds = (np.argsort(prob)[::-1])[0:5]
for p in preds:
print class_names[p], prob[p]
def loadImg(arg):
return misc.imread(arg)
import numpy as np
import keras.models
from keras.models import model_from_json
from scipy.misc import imread, imresize,imshow
json_file = open('model.json','r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights("model.h5")
print("Loaded Model from disk")
loaded_model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
x = imread('output.png',mode='L')
x = np.invert(x)
x = imresize(x,(28,28))
imshow(x)
x = x.reshape(1,28,28,1)
out = loaded_model.predict(x)
print(out)
print(np.argmax(out,axis=1))
return x
caffe.set_mode_gpu()
caffe.set_device(0)
print "Load net..."
net = caffe.Net('/your path/test.prototxt',
'/your path/pdb-convlstm.caffemodel', caffe.TEST)
with open('/your path/davis_path.txt') as f:
lines = f.readlines()
for idx in range(len(lines) / 5):
print "Run net..."
net.forward()
for i in xrange(5):
all = net.blobs['conv7_sm'].data
out = all[i][0]
line = lines[idx * 5 + i].replace(" 0\n", "")
dir, file = os.path.split(line)
file = file.replace(".jpg", '.png')
video = dir.split("/")[-1]
img = misc.imread(line)
out = misc.imresize(out, img.shape)
out = out.astype('float')
out = MaxMinNormalization(out, out.max(), out.min())
savePath = '/your save path/' + video + '/'
if not os.path.exists(savePath):
os.makedirs(savePath)
misc.imsave(savePath + file, out)
print 'Save the ' + str(idx * 5 + i) + ' Image: ' + savePath + file
def create_data(contour, translation, img_path_0, img_path_1, osvos_model, k):
"""Returns a torch_geometric.data object.
The data object consists of:
* x: Node feature matrix of shape [num_nodes, num_node_features]. The feature
of each node are the concatenated OSVOS feature vectors of the current
and the next frame.
* edge_index: Graph connectivity in COO format of shape (2, num_edges) and type torch.long
Each node should be connected to its K nearest neighbours
* edge_attr: Edge feature matrix with shape [num_edges, num_edge_features]
The feature of each edge is the inverse distance between the two nodes it connects
* y, optianl: The target of each node is the displacement of the node between the current
and the next frame
Parameters
----------
contour : ndarray
Array of shape (num_contour_points, 2) containing contour points
translation : ndarray of shape (num_contour_points, 2)
Array of shape (num_contour_points, 2) containing translations from current to next contour point
img_path_0 : str
Path to current image
img_path_0 : str
Path to next image
osvos_model : torch.nn.Sequential
OSVOS model from which feature vectors can be extracted
k : int
Number of neighbours to compute KNN graph of contour points
Returns
-------
data : torch_geometric.data
Data object containing consisting of x, edge_index, edge_attr, and y
"""
contour = torch.from_numpy(contour)
img_0 = np.moveaxis(imread(img_path_0), 2, 0).astype(np.float64)
img_0 = np.expand_dims(img_0, axis=0)
img_0 = torch.from_numpy(img_0)
img_1 = np.moveaxis(imread(img_path_1), 2, 0).astype(np.float64)
img_1 = np.expand_dims(img_1, axis=0)
img_1 = torch.from_numpy(img_1)
# x: Node feature matrix
x_1 = get_OSVOS_feature_vectors(contour, img_0, osvos_model)
x_2 = get_OSVOS_feature_vectors(contour, img_1, osvos_model)
x = torch.cat((x_1, x_2), 1)
# edge_index: Graph connectivity in COO format
edge_index = knn_graph(contour, k)
edge_index = to_undirected(edge_index)
# edge_attr: Edge feature matrix
edge_attr = get_edge_attribute(contour, edge_index)
# Create data object
if translation is None:
data = Data(x=x,
edge_index=edge_index,
edge_attr=edge_attr,
contour=contour)
else:
# The target of each node is the displacement of the node between the current and the next frame
y = torch.from_numpy(translation.astype(np.float64))
data = Data(x=x,
edge_index=edge_index,
edge_attr=edge_attr,
y=y,
contour=contour)
return data
def TPS_image(**kwargs):
"""
Application of the 'g' function on an image. This function applies
the reverting-methodology: an estimation of the reverse function
(backward projection) is estimated using a grid, which is projected
by the 'g' function. This projected grid is then used as source,
and the coordinates on the original image as destination. The
TPSCy.image can not be called with a forward 'g' TPS function!
Required:
:param infile: URI to the input file
:type infile: python string
:param inimg: numpy array with the input image
:type inimg: numpy.array
.. note::
`infile` and `inimg` are mutially exclusive. `inimg` has prioritary
:param gfile: URI to the TPS parameters file
:type gfile: python string
:param g: TPS parameters
:type g: python dictionary
.. note::
`gile` and `g` are mutially exclusive. `gfile` has prioritary
Optional:
:param res: Resolution of the input and output image
:type res: float
:param outfile: URI to the output image file
:type outfile: string
:param reverseFullGrid: Use the full-grid to revert the 'g' function (SLOW !)
:type reverseFullGrid: boolean
:param useWeights: Use the weights to selects the optimal grid to revert the 'g' function
:type useWeights: boolean
:param gridSize: Size of the grid to caculate the revert function
:type gridSize: float
:param cx: x coordinate of the center
:type cx: float
:param cy: y coordinate of the center
:type cy: float
:param ncores: Number of cores used to do the projection of the input image.
:type ncores: int
Return:
:return: Distorted image or successuly-written image
:rtype: numpy.array or bool
"""
if TPSModule.lang() == "Python":
raise NotImplementedError
else:
infile = kwargs.pop("infile", None)
inimg = kwargs.pop("inimg", None)
gfile = kwargs.pop("gfile", None)
g = kwargs.pop("g", None)
g2 = deepcopy(g)
reverseFullGrid = kwargs.pop("reverseFullGrid", False)
gridSize = kwargs.pop("gridSize", CONF_gridSize)
cx = kwargs.pop("cx", 0)
cy = kwargs.pop("cy", 0)
res = kwargs.pop("res", CONF_res)
outfile = kwargs.pop("outfile", None)
ncores = kwargs.pop("ncores", CONF_ncores)
############################################################################
# Image loading and conversion
# Loading the image in 'image coordinate' (top left) and flip in
# 'ANSI/NIST 2007 coordinates' (bottom left)
############################################################################
if infile != None:
indata = misc.imread(infile)
elif inimg != None:
indata = np.asarray(inimg)
else:
raise Exception("No input data (infile or image object)")
indata = indata.astype(np.int32)
indata = np.flipud(indata)
indata = indata.T
############################################################################
# Distorsion parameters
# The g file must be calculated in milimeters and not in pixels !
# The center is in "NIST coordinates" (mm from the bottom left)
############################################################################
if gfile != None:
g2 = TPS_loadFromFile(gfile)
elif g2 != None:
pass
else:
raise Exception("No TPS parameters of file")
if cx != 0 and cy != 0:
g2 = TPS_recenter(g=g2, cx=cx, cy=cy)
maxx, maxy = indata.shape
maxx = maxx / float(res) * 25.4
maxy = maxy / float(res) * 25.4
############################################################################
# Range calculation
# Because the borders could be in negative coordinate
############################################################################
r = kwargs.get('r', None)
if r == None:
r = TPSModule.r(g2, 0, int(maxx), 0, int(maxy))
size = [
int(float(res) / 25.4 * (r['maxx'] - r['minx'])),
int(float(res) / 25.4 * (r['maxy'] - r['miny']))
]
outimg = np.ones(size, dtype=np.int32)
############################################################################
# Calculation of the "inverse" function (approximation)
# The real inverse function of g is not calculable (the g function
# is not bijective). My approximation here is to project a grid of
# size gridSize with the g, and use this projected grid as source for
# the g2 projection function. This function is used by the
# TPSCy.image function.
############################################################################
if reverseFullGrid:
g2 = TPSModule.revert(g2, 0, maxx, 0, maxy, gridSize)
else:
g2 = TPS_revertDownSampling(g=g2,
minx=0,
maxx=maxx,
miny=0,
maxy=maxy,
gridSize=gridSize,
**kwargs)
############################################################################
# Distorsion of the image
# Reverse calculation of the distorted image. The g2 function allow
# the TPSCy.image function to calculate the x, y coordinates on the
# original image. This methodoloy allow to have a continuous image.
############################################################################
TPSModule.image(indata, g2, r, float(res), outimg, ncores)
############################################################################
# Preparation of the output image (file or image object return)
############################################################################
outimg = np.flipud(outimg.T)
outimg = misc.toimage(outimg, cmin=0, cmax=255)
if outfile != None:
outimg.save(outfile, dpi=(int(res), int(res)))
return os.path.isfile(outfile)
else:
return outimg
# plt.axis('off')
# plt.imshow(noisy)
# plt.show()
wavelet_family_label_list = [
'haar',
'db2',
'db3',
'db4',
'dmey',
'sym2',
'sym3',
'bior1.3',
]
image1 = imread('C:\img\zz.jpg')
image_noise = imread('C:\img\zz_noise.jpg')
img = img_as_float(image1)
img_noise = img_as_float(image_noise)
mse_noise = compare_mse(img, img_noise) * 255
psnr_noise = compare_psnr(img, img_noise)
print(mse_noise, psnr_noise)
#sigma = estimate_sigma(image_noise)
print('threshloding mode', 'Wavelet', 'sigma', 'MSE', 'PSNR', 'delta_MSE_%',
'delta_PSNR_%')
for x in wavelet_family_label_list:
#mse = compare_mse(img, img_as_float(denoising_image('C:\img\lena_noise.png', x, 'hard')[0]))*255
#psnr = compare_psnr(img, img_as_float(denoising_image('C:\img\lena_noise.png', x, 'hard')[0]))
sigma_est = estimate_sigma(
img_noise, multichannel=True, average_sigmas=True) * 255
def get_car_notcar_scaled_feature_vectors(cars_dataset, notcars_dataset, cspace, bin_params, color_params, hog_params,
display_sample=False):
car_features = extract_features_imgs(cars_dataset, cspace=cspace, bin_params=bin_params,
color_params=color_params, hog_params=hog_params)
notcar_features = extract_features_imgs(notcars_dataset, cspace=cspace, bin_params=bin_params,
color_params=color_params, hog_params=hog_params)
example_fig_filename = 'im_feature_norm.png'
# Normalize the features
if len(car_features) > 0:
# Create an array stack of feature vectors
X = np.vstack((car_features, notcar_features)).astype(np.float64)
# Fit a per-column scaler
X_scaler = StandardScaler().fit(X)
# Apply the scaler to X
scaled_X = X_scaler.transform(X)
### For display
if display_sample:
car_ind = np.random.randint(0, len(cars_dataset))
notcar_ind = np.random.randint(0, len(notcars_dataset))
img = imread(cars_dataset[car_ind])
notcar_img = imread(notcars_dataset[notcar_ind])
# Plot an example of raw and scaled features
fig = plt.figure(figsize=(12, 4))
plt.subplot(131)
plt.imshow(img)
plt.title('Original Image')
plt.subplot(132)
plt.plot(X[car_ind])
plt.title('Raw Features')
plt.subplot(133)
plt.plot(scaled_X[car_ind])
plt.title('Normalized Features')
fig.tight_layout()
plt.savefig(example_fig_filename)
# show corresponding HoG image
vis_hog_params = hog_params
vis_hog_params['visualize'] = True
vis_hog_params['feature_vector'] = False
_, hog_img = hog_features(img, **vis_hog_params)
plt.figure()
plt.imshow(hog_img)
plt.gray()
plt.title('HoG Features')
plt.savefig('hog_image.png')
plt.figure()
plt.subplot(121)
plt.imshow(img)
plt.title('Car')
plt.subplot(122)
plt.imshow(notcar_img)
plt.title('Not Car')
plt.savefig('car_notcar.png')
else:
ValueError('Empty feature vector')
return {'X': X, 'scaled_X': scaled_X, 'X_scaler': X_scaler,
'car_features': car_features, 'notcar_features': notcar_features}
import matplotlib.pyplot as plt
import numpy as np
from scipy.misc import imread
a = imread("placa.png")
#a.shape
#plt.imshow(a, cmap= "gray")
#plt.imshow(a[:,:,0])
#plt.show()
#plt.imshow(a[:,:,1])
#plt.show()
#plt.imshow(a[:,:,1], cmap= "gray")
#plt.show()
#b=a[:,:,1]
#plt.imshow(b, cmap= "gray")
#plt.show()
#b.shape
#c=b.reshape([b.shape[0]*b.shape[1]])
#c.shape
#plt.imshow(c)
if "content" in args.init_image or "gray" in args.init_image:
x = preprocess_image(base_image_path, True, read_mode=read_mode)
elif "noise" in args.init_image:
x = np.random.uniform(0, 255, (1, img_width, img_height, 3)) - 128.
if K.image_dim_ordering() == "th":
x = x.transpose((0, 3, 1, 2))
else:
print("Using initial image : ", args.init_image)
x = preprocess_image(args.init_image, read_mode=read_mode)
# We require original image if we are to preserve color in YCbCr mode
if preserve_color:
content = imread(base_image_path, mode="YCbCr")
content = imresize(content, (img_width, img_height))
if color_mask_present:
if K.image_dim_ordering() == "th":
color_mask_shape = (None, None, img_width, img_height)
else:
color_mask_shape = (None, img_width, img_height, None)
color_mask = load_mask(args.color_mask, color_mask_shape, return_mask_img=True)
else:
color_mask = None
else:
color_mask = None
num_iter = args.num_iter
def get_labels(self, files):
"""Process and save label images."""
labels = {}
new_files = {}
for k, images in files.iteritems():
# Replace extension and path with labels
label_vec = []
file_vec = []
fold = images[0].split(os.path.sep)[-2]
# New label dir
proc_dir = os.path.join(images[0].split(fold)[0], fold,
self.processed_labels)
py_utils.make_dir(proc_dir)
# New image dir
proc_image_dir = os.path.join(self.config.data_root, self.name,
self.images_dir, fold,
self.processed_images)
py_utils.make_dir(proc_image_dir)
ims = []
for im in tqdm(images, total=len(images), desc=k):
it_label = im.split(os.path.sep)[-1]
it_label_path = '%s%s' % (im.split('.')[0], self.lab_extension)
it_label_path = it_label_path.replace(self.images_dir,
self.labels_dir)
# Process every label and duplicate images for each
label_data = io.loadmat(it_label_path)['groundTruth'].reshape(
-1)
im_data = misc.imread(im)
transpose_labels = False
if not np.all(self.im_size == list(im_data.shape)):
im_data = np.swapaxes(im_data, 0, 1)
# im_data = im_proc.pad_square(im_data)
transpose_labels = True
assert np.all(
self.im_size == list(im_data.shape)), \
'Mismatched dimensions.'
ims += [im_data]
if self.fold_options[k] == 'duplicate':
# Loop through all labels
for idx, lab in enumerate(label_data):
# Process labels
ip_lab = lab.item()[1].astype(np.float32)
if transpose_labels:
ip_lab = np.swapaxes(ip_lab, 0, 1)
# ip_lab = im_proc.pad_square(ip_lab)
it_im_name = 'image_%s_%s.npy' % (idx, it_label)
it_lab_name = 'label_%s.npy' % it_im_name.split('.')[0]
out_lab = os.path.join(proc_dir, it_lab_name)
np.save(out_lab, ip_lab)
label_vec += [out_lab]
# Process images
proc_im = os.path.join(proc_image_dir, it_im_name)
np.save(proc_im, im_data)
file_vec += [proc_im]
elif self.fold_options[k] == 'mean':
mean_labs = []
for idx, lab in enumerate(label_data):
# Process labels
ip_lab = lab.item()[1].astype(np.float32)
if transpose_labels:
ip_lab = np.swapaxes(ip_lab, 0, 1)
# ip_lab = im_proc.pad_square(ip_lab)
mean_labs += [ip_lab]
mean_lab = np.asarray(mean_labs).mean(0)
out_lab = os.path.join(
proc_dir, 'label_%s.npy' % it_label.split('.')[0])
np.save(out_lab, mean_lab)
label_vec += [out_lab]
# Process images
proc_im = os.path.join(proc_image_dir, it_label)
np.save(proc_im, im_data)
# misc.imsave(proc_im, im_data)
file_vec += ['%s.npy' % proc_im]
else:
raise NotImplementedError
labels[k] = label_vec
new_files[k] = file_vec
ims = np.array(ims)
np.savez(os.path.join(self.config.data_root, self.name,
self.images_dir, fold, 'file_paths'),
labels=labels,
files=new_files,
mean=np.mean(ims, axis=(0, 1, 2), keepdims=True),
stds=np.std(ims, axis=(0, 1, 2), keepdims=True))
return labels, new_files
SUPPORT_SIZE = 320
POOL = ['85.jpg', '44.jpg', '61.jpg', '73.jpg', '94.jpg']
CWD = os.getcwd()
for TEST_SHOT in [1, 3, 5]:
model_dir = os.path.join(CWD,
'models/simu_finetuned/train/checkpoints')
load_path = os.path.join(
model_dir, 'faster_rcnn_{}_{}_{}.pth'.format(1, 27, 1248))
model = get_model(load_path, TEST_SHOT)
query_name = '002468.jpg'
file_path = os.path.join(
CWD, 'data/simulated/images/simulated2020/' + query_name)
im_data = imread(file_path)[:, :, ::-1].copy() # rgb -> bgr
im2show = copy.deepcopy(im_data)
target_size = cfg.TRAIN.SCALES[0]
im_data, im_scale = prep_im_for_blob(im_data, cfg.PIXEL_MEANS,
target_size, cfg.TRAIN.MAX_SIZE)
im_data = torch.from_numpy(im_data)
info = np.array([[im_data.shape[0], im_data.shape[1], im_scale]],
dtype=np.float32)
info = torch.from_numpy(info)
dets = torch.from_numpy(np.array([0]))
n_boxes = torch.from_numpy(np.array([0]))
query = im_data.permute(2, 0, 1).contiguous().unsqueeze(0)
support_data_all = np.zeros((TEST_SHOT, 3, SUPPORT_SIZE, SUPPORT_SIZE),
dtype=np.float32)
for i in range(TEST_SHOT):
# # Collect metadata
subdirs = list(os.walk(dir_train))[1:]
# collect train metadata
train_metadata = []
for dir_path, _, files in tqdm(subdirs):
dir_name = dir_path.split('/')[-1]
for file_name in files:
if not file_name.startswith('.'):
# read image
temp = misc.imread(os.path.join(dir_path, file_name))
# collect image metadata
image_metadata = []
image_metadata.extend([dir_name, file_name])
image_metadata.extend(
list(temp.shape) if len(temp.shape) ==
3 else [temp.shape[0], temp.shape[1], 1])
image_metadata.extend([temp.nbytes, temp.dtype])
# append image metadata to list
train_metadata.append(image_metadata)
# # Explore metadata
M = pd.DataFrame(train_metadata)
M.columns = [
'directory', 'img_name', 'height', 'width', 'channels', 'byte_size',
dist_2 = [int(raw_input("Y dist: "))]
dist_3 = [int(raw_input("Z dist: "))]
compute = raw_input(
"Compute? Y/n :"
) ##Enter distance in mellimeters, result = coordinates
if compute.lower() != 'y':
break
X = rf_xx.predict(
np.array([dist_1, dist_2, dist_3]).reshape(1, -1)
) ##Random Forest predictiion from datasets rfc_x.sav, rfc_y.sav,rfc_z.sav
Y = rf_yy.predict(np.array([dist_1, dist_2, dist_3]).reshape(1, -1))
Z = rf_zz.predict(np.array([dist_1, dist_2, dist_3]).reshape(1, -1))
print(X, Y, Z)
datafile = cbook.get_sample_data(
'C:\python\map_1.jpg') ##Load from file bitmap on plot
img = imread(datafile)
ax.set_xlim([0, 25])
ax.set_ylim([0, 50])
plt.imshow(img, zorder=0, extent=[0, 25, 0, 50]) ##Show picture centered
plt.scatter(X, Y, c=Z, s=50) ##Point options
plt.clim(0, 10) ##Colorbar range (0-10)
plt.gray() ##Depends where it can be placed(color of point may vary)
plt.grid() ##Show grid
plt.colorbar() ##Show colorbar
#z_mass[X,Y] = Z
#plt.colorbar(Z)
ax.set_xlabel("X label")
# -*- coding: utf-8 -*-
import os, sys
import scipy.misc as misc
import cv2
import matplotlib.pyplot as plt
from pycontour import DATA_DIR
from pycontour import cv_cnt_to_np_arr, np_arr_to_cv_cnt
from .extract_cv2_cnts import extract_cnt_using_cv2
def test_cv_np_transfom(tmp_cnt):
# convert cv2 contour to numpy array
np_arr = cv_cnt_to_np_arr(tmp_cnt)
# convert numpy arrary to cv2 contour
cv_cnt = np_arr_to_cv_cnt(np_arr)
return cv_cnt
if __name__ == "__main__":
img_path = os.path.join(DATA_DIR, "images", "brain.jpg")
img = misc.imread(img_path)
cnts = extract_cnt_using_cv2(img_path)
test_cnt = cnts[1]
cv_cnt = test_cv_np_transfom(test_cnt)
draw_img = cv2.drawContours(img, [cv_cnt], 0, 255, 3)
entrada = 'img_entrada.tif'
try:
saida = sys.argv[2]
except IndexError:
saida = 'img_saida.tif'
try:
T_ini = sys.argv[3]
except IndexError:
T_ini = 0.5
T_ini = float(T_ini)
# Faz a leitura da imagem
img_entrada = misc.imread(entrada)
# Converte os pixels em float, com valores entre 0 e 1
img_entrada = img_as_float(img_entrada.astype(np.uint8))
# Chama a função para cálculo do limiar global iterativo
valor_T = limiar_global_simples(img_entrada, T_ini)
# Segmenta a imagem com o limiar T
img_saida = img_entrada > valor_T
misc.imsave(saida, img_saida.astype(np.uint8))
# Organiza o plote das imagens
plt.figure()
plt.subplot(221)
plt.imshow(img_entrada, cmap='gray', interpolation='nearest')
def read_style_image(filename, batch_size=64): img = imread(filename)
def procimage(self, picture, threadid):
filelist = {}
max = 60
if not self.options.silent: print "[", threadid, "] open: ", picture
for i in range(max):
try:
image = misc.imread(picture)
except KeyboardInterrupt:
return
except IOError as e:
try:
print "cannot open ", picture, ", lets wait.", max - i, " s"
print e.message, sys.exc_info()[0]
time.sleep(1)
continue
except KeyboardInterrupt:
return
except:
print "############"
print sys.exc_info()
continue
if image.shape == tuple(
self.cals[0].config["Geometry"]["Imagesize"]):
break
print "cannot open ", picture, ", lets wait.", max - i, " s"
time.sleep(1)
else:
print "image ", picture, " has wrong format"
return
if self.options.outdir != "":
basename = self.options.outdir + os.sep + ('_'.join(
picture.replace('./', '').split(os.sep))[:-3]).replace(
'/', "_")
basename = basename.replace(':', '').replace('.', '')
else:
reldir = os.path.join(os.path.dirname(picture),
self.options.relpath)
if not os.path.isdir(reldir):
os.mkdir(reldir)
basename = os.path.join(reldir, os.path.basename(picture)[:-4])
data = []
for calnum, cal in enumerate(self.cals):
filename = basename + "_c" + cal.kind[0] + str(calnum)
chifilename = filename + ".chi"
filelist[cal.kind + str(calnum)] = chifilename
if not self.options.resume or not os.path.isfile(chifilename):
result = cal.integratechi(image, chifilename, picture)
result["Image"] = picture
data.append(result)
if threadid == 0 and self.options.plotwindow:
# this is a hack it really schould be a proper GUI
cal.plot(image, fig=self.fig)
plt.draw()
if self.options.writesvg:
if not self.options.resume or not os.path.isfile(filename +
'.svg'):
cal.plot(image, filename + ".svg", fig=self.fig)
if self.options.writepng:
if not self.options.resume or not os.path.isfile(filename +
'.svg'):
misc.imsave(filename + ".png", image)
if self.options.silent:
if np.mod(self.allp.value, 100) == 0:
print "[", threadid, "] ", self.allp.value
else:
print "[", threadid, "] write: ", filename + ".chi"
with self.allp.get_lock():
self.allp.value += 1
json.dump(data, open(basename + ".json", "w"))
filelist["JSON"] = basename + ".json"
self.histqueue.put({
"Time": time.time(),
"FileList": filelist,
"BaseName": basename
})
return basename, data
def caption_image_beam_search(encoder,
decoder,
image_path,
word_map,
gt_word,
beam_size=1):
"""
Reads an image and captions it with beam search.
:param encoder: encoder model
:param decoder: decoder model
:param image_path: path to image
:param word_map: word map
:param beam_size: number of sequences to consider at each decode-step
:return: caption, weights for visualization
"""
k = beam_size
vocab_size = len(word_map)
# Keep track of the raw score for each predicted words
img_scores = []
# Read image and process
img = imread(image_path)
if len(img.shape) == 2:
img = img[:, :, np.newaxis]
img = np.concatenate([img, img, img], axis=2)
img = imresize(img, (256, 256))
img = img.transpose(2, 0, 1)
img = img / 255.
img = torch.FloatTensor(img).to(device)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([normalize])
image = transform(img) # (3, 256, 256)
# Encode
image = image.unsqueeze(0) # (1, 3, 256, 256)
encoder_out = encoder(
image) # (1, enc_image_size, enc_image_size, encoder_dim)
enc_image_size = encoder_out.size(1)
encoder_dim = encoder_out.size(3)
# Flatten encoding
encoder_out = encoder_out.view(1, -1,
encoder_dim) # (1, num_pixels, encoder_dim)
num_pixels = encoder_out.size(1)
# We'll treat the problem as having a batch size of k
encoder_out = encoder_out.expand(
k, num_pixels, encoder_dim) # (k, num_pixels, encoder_dim)
# Tensor to store top k previous words at each step; now they're just <start>
k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(
device) # (k, 1)
# Tensor to store top k sequences; now they're just <start>
seqs = k_prev_words # (k, 1)
# Tensor to store top k sequences' scores; now they're just 0
top_k_scores = torch.zeros(k, 1).to(device) # (k, 1)
# Tensor to store top k sequences' alphas; now they're just 1s
seqs_alpha = torch.ones(k, 1, enc_image_size, enc_image_size).to(
device) # (k, 1, enc_image_size, enc_image_size)
# Lists to store incompleted sequences, their alphas and scores
complete_seqs = list()
complete_seqs_alpha = list()
complete_seqs_scores = list()
incomplete_seqs = list()
incomplete_seqs_alpha = list()
incomplete_seqs_scores = list()
# Start decoding
step = 1
h, c = decoder.init_hidden_state(encoder_out)
# s is a number less than or equal to k, because sequences are removed from this process once they hit <end>
while True:
embeddings = decoder.embedding(k_prev_words).squeeze(
1) # (s, embed_dim)
awe, alpha = decoder.attention(encoder_out,
h) # (s, encoder_dim), (s, num_pixels)
alpha = alpha.view(
-1, enc_image_size,
enc_image_size) # (s, enc_image_size, enc_image_size)
gate = decoder.sigmoid(
decoder.f_beta(h)) # gating scalar, (s, encoder_dim)
awe = gate * awe
# Hidden and cell state
h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1),
(h, c)) # (s, decoder_dim)
# Probability for each token
scores = decoder.fc(h) # (s, vocab_size)
scores = F.softmax(scores, dim=1)
# Add
#scores = top_k_scores.expand_as(scores) + scores # (s, vocab_size)
img_scores.append(scores.cpu().detach().numpy())
# For the first step, all k points will have the same scores (since same k previous words, h, c)
if step == 1:
top_k_scores, top_k_words = scores[0].topk(k, 0, True, True) # (s)
else:
# Unroll and find top scores, and their unrolled indices
top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True,
True) # (s)
# Convert unrolled indices to actual indices of scores
prev_word_inds = top_k_words / vocab_size # (s)
next_word_inds = top_k_words % vocab_size # (s)
# Add new words to sequences, alphas
seqs = torch.cat([seqs[prev_word_inds],
next_word_inds.unsqueeze(1)],
dim=1) # (s, step+1)
seqs_alpha = torch.cat(
[seqs_alpha[prev_word_inds], alpha[prev_word_inds].unsqueeze(1)],
dim=1) # (s, step+1, enc_image_size, enc_image_size)
# Break if things have been going on too long
if step > len(gt_word.split(" ")):
break
step += 1
seq = seqs[0].tolist()
alphas = seqs_alpha[0].tolist()
return img_scores, seq, alphas
# _*_ coding:utf-8 _*_
__author__ = 'Xbc'
import matplotlib as mpl
mpl.use('TkAgg')
from os import path
from scipy.misc import imread
import matplotlib.pyplot as plt
import jieba
from wordcloud import WordCloud
f = open('./jd_comment.txt', 'rb')
text = f.read()
cut_text = ''.join(jieba.lcut(text))
print(cut_text)
color_mask = imread("iphone.jpg")
cloud = WordCloud(
font_path='ziti.TTF', # 字体最好放在与脚本相同的目录下，而且必须设置
background_color='white',
mask=color_mask,
max_words=500,
max_font_size=3000)
word_cloud = cloud.generate(cut_text)
plt.imshow(word_cloud)
plt.axis('off')
plt.show()
from glob import glob
from scipy.misc import imread, imsave
from skimage.filters import threshold_otsu
from skimage.color import rgb2gray
from skimage.morphology import square, erosion
files = glob('*.jpg')
for i in files:
image = rgb2gray(imread(i))
try:
global_thresh = threshold_otsu(image)
binary_global = image < global_thresh
binary_global = erosion(binary_global, square(3))
except Exception as e:
binary_global = image
print e, i
imsave('bw/' + i[:-4] + '__' + '.jpg', binary_global)
print i, i[:-4] + '__' + '.jpg'
def test_seg_accuracy(self,
image_type='.jpg',
seg_type='.png',
bbox_type='.xml',
use_bbox_gt=True):
test_file = self.test_file
image_folder = self.image_folder
bbox_folder = self.bbox_folder
seg_folder = self.seg_folder
f = open(test_file, 'r')
lines = f.readlines()
intersection_class_compare = np.zeros(voc_classes.shape)
union_class_compare = np.zeros(voc_classes.shape)
for line in lines:
name = line.split('\n')[0]
image_file = image_folder + name + image_type
seg_file = seg_folder + name + seg_type
bbox_file = bbox_folder + name + bbox_type
object_names, object_attr = parseXmlVoc(bbox_file)
im = imread(image_file)
im_shape = im.shape
if use_bbox_gt:
detect = []
for i in range(len(object_attr)):
attr = object_attr[i]
object_name = object_names[i]
label = np.argwhere(voc_classes == object_name)[0][0] + 1
xmin = float(attr['xmin']) / im_shape[1]
ymin = float(attr['ymin']) / im_shape[0]
xmax = float(attr['xmax']) / im_shape[1]
ymax = float(attr['ymax']) / im_shape[0]
detect.append(
[xmin, ymin, xmax, ymax, label, 1, object_name])
else:
detect = self.detect(image_file)
# print len(detect)
num_detect = len(detect)
if num_detect > 0:
bbox, all_diff_cls_labels = self.detect2bbox(detect)
seg_prob = self.seg(bbox,
all_diff_cls_labels,
image_file,
key_type='label',
nocls=True)
mask = self.merge_seg_prob(seg_prob, bbox, all_diff_cls_labels)
seg_label = imread(seg_file)
# object_index = list(set(mask[np.where(mask!=0)].flatten()))
object_index = list(
set(seg_label[np.where(seg_label != 0)].flatten()))
for idx_c in object_index:
if idx_c == 255:
continue
seg_anno_c = np.single(seg_label == idx_c)
seg_mask_c = np.single(mask == idx_c)
# erase the ignore label
# seg_mask_c[np.where(seg_label == 255)] = 0
intersection_class_compare[idx_c - 1] += len(
np.argwhere((seg_anno_c * seg_mask_c) > 0))
union_class_compare[idx_c - 1] += len(
np.argwhere((seg_anno_c + seg_mask_c) > 0))
if True:
plt.figure(1)
plt.imshow(im)
ax = plt.gca()
for item in detect:
xmin = int(round(item[0] * im_shape[1]))
ymin = int(round(item[1] * im_shape[0]))
xmax = int(round(item[2] * im_shape[1]))
ymax = int(round(item[3] * im_shape[0]))
bbox_weight = xmax - xmin
bbox_height = ymax - ymin
coords = (xmin, ymin), bbox_weight, bbox_height
ax.add_patch(
plt.Rectangle(*coords,
fill=False,
edgecolor='g',
linewidth=3))
ax.text(xmin,
ymin,
item[-1] + str(item[-2]),
bbox={
'facecolor': 'b',
'alpha': 0.5
})
color_map = np.random.randint(0, 256,
[256, 3]).astype(np.uint8)
mask_color = color_map[mask]
seg_label_color = color_map[seg_label]
plt.figure(666)
plt.imshow(mask_color)
plt.figure(888)
plt.imshow(seg_label_color)
plt.show()
pass
else:
object_index = list(
set(seg_label[np.where(seg_label != 0)].flatten()))
for idx_c in object_index:
if idx_c == 255:
continue
seg_anno_c = np.single(seg_label == idx_c)
intersection_class_compare[idx_c - 1] += 0
union_class_compare[idx_c - 1] += len(
np.argwhere((seg_anno_c) > 0))
print intersection_class_compare / union_class_compare
print(intersection_class_compare / union_class_compare).mean()
words_df = pandas.DataFrame({'segment': segment})
words_df.head()
stopwords = pandas.read_csv("/hwj/dorahacks/stopwords.txt",
index_col=False,
quoting=3,
sep="\t",
names=['stopword'],
encoding="utf8")
#去掉我们不需要的高频语气词等
words_df = words_df[~words_df.segment.isin(stopwords.stopword)]
words_stat = words_df.groupby(by=['segment'])['segment'].agg(
{"计数": numpy.size})
words_stat = words_stat.reset_index().sort_values(by="计数", ascending=False)
from scipy.misc import imread
import matplotlib.pyplot as plt
from wordcloud import WordCloud, ImageColorGenerator
#%matplotlib inline
bimg = imread('/hwj/dorahacks/1.jpg')
wordcloud = WordCloud(background_color="black",
mask=bimg,
font_path='/hwj/dorahacks/STFANGSO.ttf')
#wordcloud=wordcloud.fit_words(words_stat.head(4000).itertuples(index=False))
words = words_stat.set_index("segment").to_dict()
wordcloud = wordcloud.fit_words(words["计数"])
bimgColors = ImageColorGenerator(bimg)
plt.axis("off")
plt.imshow(wordcloud.recolor(color_func=bimgColors))
plt.show()
def main(
image_direc='image',
nPixels_on_side=15,
i_std=15, # std dev for color Gaussian
imgs_of_the_same_size=None):
if image_direc is None:
raise ValueError("image_direc cannot be None")
image_direc = os.path.expanduser(image_direc)
image_direc = os.path.abspath(image_direc)
FilesDirs.raise_if_dir_does_not_exist(image_direc)
imgs = get_list_of_all_imgs_dir(image_direc)
if not imgs:
raise Exception(
"\n\nDirectory \n{}\ncontains no images.\n".format(image_direc))
# Results will be saved in the /results folder under input directory. You can change it.
save_path_root = os.path.join(image_direc, 'result')
print "I am going to save results into", save_path_root
FilesDirs.mkdirs_if_needed(save_path_root)
# Part 1: Specify the parameters:
prior_count_const = 5 # the weight of Inverse-Wishart prior of space covariance(ex:1,5,10)
use_hex = True # toggle between hexagons and squares (for the init)
prior_weight = 0.5 # in the segmentation,
# we do argmax w * log_prior + (1-w) *log_likelihood.
# Keeping w (i.e., prior_weight) at 0.5 means we are trying
# to maximize the true posterior.
# We keep the paramter here in case the user will like
# to tweak it.
calc_s_cov = True # If this is False, then we avoid estimating the spatial cov.
num_EM_iters = nPixels_on_side
num_inner_iters = 10
sp_size = nPixels_on_side * nPixels_on_side
for i, img_filename in enumerate(imgs):
# Part 2 : prepare for segmentation
print img_filename
fullfilename = os.path.join(image_direc, img_filename)
FilesDirs.raise_if_file_does_not_exist(fullfilename)
img = misc.imread(fullfilename)
dimx = img.shape[1]
dimy = img.shape[0]
if not ((img.ndim in [1, 3]) and (img.shape[2] in [1, 3])):
raise ValueError(
"\n\nProblem with {0}\n\nI was expecting 3 channels, but img.shape = {1}\n\n"
.format(fullfilename, img.shape))
tic = time.clock()
if (imgs_of_the_same_size and i != 0):
sw.initialize_seg()
# you can use the same SuperpixelsWrapper object with different imgs and/or,
# i_std, s_std, prior_count.
# Just call sw.set_img(new_img), sw.initialize_seg(), and/or
# sw.set_superpixels(i_std=..., s_std = ..., prior_count = ...)
# again and recompute the seg.
else:
sw = SuperpixelsWrapper(dimy=dimy,
dimx=dimx,
nPixels_in_square_side=nPixels_on_side,
i_std=i_std,
s_std=nPixels_on_side,
prior_count=prior_count_const * sp_size,
use_hex=use_hex)
toc = time.clock()
print 'init time = ', toc - tic
print 'nSuperpixels =', sw.nSuperpixels
sw.set_img(img)
# Part 3: Do the superpixel segmentation
tic = time.clock()
#actual work
sw.calc_seg(nEMIters=num_EM_iters,
nItersInner=num_inner_iters,
calc_s_cov=calc_s_cov,
prior_weight=prior_weight)
# Copy the parameters from gpu to cpu
sw.gpu2cpu()
toc = time.clock()
print 'superpixel calculation time = ', toc - tic
# Part 4: Save the mean/boundary image and the resulting parameters
img_overlaid = sw.get_img_overlaid() # get the boundary image
img_cartoon = sw.get_cartoon() # get the cartoon image
grid = ['square', 'hex'][sw.use_hex]
root_slash_img_num = os.path.splitext(img_filename)[0]
img_num = os.path.split(root_slash_img_num)[1]
#fname_res_border = '_'.join([img_num , 'std', str(i_std), 'border', grid+'.png'])
#fname_res_cartoon = '_'.join([img_num , 'std', str(i_std), 'mean', grid+'.png'])
fname_res_border = '_'.join([
img_num, 'n', '{0:03}'.format(nPixels_on_side), 'std',
'{0:02}'.format(i_std), 'border', grid + '.png'
])
fname_res_cartoon = '_'.join([
img_num, 'n', '{0:03}'.format(nPixels_on_side), 'std',
'{0:02}'.format(i_std), 'mean', grid + '.png'
])
fname_res_border = os.path.join(save_path_root, fname_res_border)
fname_res_cartoon = os.path.join(save_path_root, fname_res_cartoon)
print 'saving', fname_res_border
misc.imsave(fname_res_border, img_overlaid)
print 'saving', fname_res_cartoon
misc.imsave(fname_res_cartoon, img_cartoon)
#save the resulting parameters to MATLAB .mat file
#mat_filename = os.path.join(save_path_root , img_num + '_std_'+str(i_std)+'.mat')
mat_filename = os.path.join(
save_path_root #, img_num + '_std_'+str(i_std)+'.mat')
,
'_'.join([
img_num, 'n', '{0:03}'.format(nPixels_on_side), 'std',
'{0:02}'.format(i_std) + '.mat'
]))
print 'Saving params to ', mat_filename
pm = sw.superpixels.params
sio.savemat(
mat_filename, {
'pixel_to_super': sw.seg.cpu,
'count': pm.counts.cpu,
'mu_i': pm.mu_i.cpu,
'mu_s': pm.mu_s.cpu,
'sigma_s': pm.Sigma_s.cpu,
'sigma_i': pm.Sigma_i.cpu
})
if (not imgs_of_the_same_size):
del sw
#
# TODO: Write a for-loop that iterates over the images in the
# Module4/Datasets/ALOI/32/ folder, appending each of them to
# your list. Each .PNG image should first be loaded into a
# temporary NDArray, just as shown in the Feature
# Representation reading.
#
# Optional: Resample the image down by a factor of two if you
# have a slower computer. You can also convert the image from
# 0-255 to 0.0-1.0 if you'd like, but that will have no
# effect on the algorithm's results.
#
# .. your code here ..
path = 'Datasets/ALOI/32/'
for filename in os.listdir(path):
samples.append((misc.imread(path + filename)[::2,::2]/ 255.0).reshape(-1, 3))
#print(samples)
#print(misc.imread('Datasets/ALOI/32/32_r0.png'))
#print('---')
#print(misc.imread('Datasets/ALOI/32/32_r0.png').reshape(-1, 3))
#print((misc.imread('Datasets/ALOI/32/32_r0.png')/ 255.0).reshape(-1, 3))
#
# TODO: Once you're done answering the first three questions,
# right before you converted your list to a dataframe, add in
# additional code which also appends to your list the images
# in the Module4/Datasets/ALOI/32_i directory. Re-run your
# assignment and answer the final question below.
#
# .. your code here ..
