def overlay_rois(im, subject, name=None, height=1024, labels=True, **kwargs):
import shlex
import subprocess as sp
from matplotlib.pylab import imsave
if name is None:
name = 'png:-'
key = (subject, labels)
if key not in rois:
print("loading %s" % subject)
rois[key] = utils.get_roipack(subject).get_texture(height,
labels=labels)
cmd = "composite {rois} - {name}".format(rois=rois[key].name, name=name)
proc = sp.Popen(shlex.split(cmd), stdin=sp.PIPE, stdout=sp.PIPE)
fp = io.StringIO()
imsave(fp, im, **kwargs)
fp.seek(0)
out, err = proc.communicate(fp.read())
if len(out) > 0:
fp = io.StringIO()
fp.write(out)
fp.seek(0)
return fp
def main():
# 時間測定用
ticktock = Ticktock.Ticktock()
# 変換元の画像
ref_image = loadSrcImage()
# 変換元画像を分割
# 水平方向（X方向）に分割
num_separate = 2 #分割数
size_x = np.shape(ref_image)[1]
columns = split_seq(range(size_x), num_separate)
ref_img_separated = []
for i in range(num_separate):
ref_img_separated.append(ref_image[:,columns[i],:])
# モザイク画作成
ticktock.tick()
dest_image = []
for i, img_in in enumerate(ref_img_separated):
img_out = makeMosaicImage(img_in)
dest_image.append(img_out)
# pl.imsave(getResultPath() + "/d%d.png" % i, img_out)
ticktock.tock()
# 変換結果を結合
dest_image_cat = []
for i, img_out in enumerate(dest_image):
if i==0:
dest_image_cat = img_out
else:
dest_image_cat = np.hstack([dest_image_cat, img_out])
# 保存
pl.imsave(getResultPath() + "/dest.png", dest_image_cat)
def main(globstr, beat_subdivisions, fs, quantized, wrap, save_img, debug):
for filepath in glob.glob(globstr):
try:
data = pm.PrettyMIDI(filepath)
b = data.get_beats()
beats = interpolate_between_beats(b, beat_subdivisions)
if quantized:
quantize(data, beats)
if not fs:
cur_fs = 1. / beats[1]
while cur_fs > wrap:
cur_fs = cur_fs * 0.5
else:
cur_fs = fs
print("{}, {}".format(filepath, cur_fs))
# proll = data.get_piano_roll(fs=fs, times=beats)
proll = data.get_piano_roll(fs=cur_fs).astype(int)
if np.isnan(proll).any():
print("{} had NaN cells".format(filepath))
# automatically appends .npy fo filename
np.save(filepath, proll)
# save image
if save_img:
plt.imsave(filepath + '_o.png', proll)
plt.imsave(filepath + '_f.png', np.flipud(proll))
except:
print filepath, sys.exc_info()[0]
if debug:
traceback.print_exc()
continue
def encode_and_save(preds_test_upsampled, test_ids):
"""
Use run-length-encoding encode the prediction masks and save to csv file for submitting
:param preds_test_upsampled: list, for each elements, numpy array (Width, Height)
:param test_ids: list, for each elements, image id
:return:
save to csv file
"""
# save as imgs
for i in range(0, len(test_ids)):
path = os.path.join(Option.results_dir, test_ids[i])
if not os.path.exists(path):
os.mkdir(path)
# Image.fromarray(preds_test_upsampled[i]).save(os.path.join(path,'prediction.png'))
plt.imsave(os.path.join(path, 'prediction.png'),
preds_test_upsampled[i],
cmap='gray')
# save as encoding
new_test_ids = []
rles = []
for n, id_ in enumerate(test_ids):
rle = list(prob_to_rles(preds_test_upsampled[n]))
rles.extend(rle)
new_test_ids.extend([id_] * len(rle))
sub = pd.DataFrame()
sub['ImageId'] = new_test_ids
sub['EncodedPixels'] = pd.Series(rles).apply(
lambda x: ' '.join(str(y) for y in x))
sub.to_csv('sub-dsbowl2018.csv', index=False)
def loadSrcImage():
"""
変換元の画像を取得
return : RGB配列 MxNx3 [[[R00,G00,B00], [R01,G01,B01], ... ],
[[R10,G10,B10], [R11,G11,B11], ... ],
...
]
"""
# [pardir, cur] = os.path.split(os.path.dirname(__file__))
# [pardir, cur] = os.path.split(os.path.dirname(sys.argv[0]))
# prjpath = pardir + "\\"
prjpath = "D:\\root\\programing\\Python\\MosaicImage\\" #絶対パスしていでないとインタラクティブモードで失敗する
dirpath = "data/cifar-10-python.tar/cifar-10-batches-py/"
file = "data_batch_1"
fullpath = prjpath + dirpath + file
dict = unpickle(fullpath)
# 参照画像を取得
ref_ind = 2
ref_image = getRGBTable(dict, ref_ind)
fname = ("ref%05d" % ref_ind) + ".png"
# 参照画像を保存
pl.imsave( getResultPath() + "/" + fname, ref_image)
return ref_image
def make_svg(
fname, braindata, recache=False, pixelwise=True, sampler="nearest", height=1024, thick=32, depth=0.5, **kwargs
):
dataview = dataset.normalize(braindata)
if not isinstance(dataview, dataset.Dataview):
raise TypeError("Please provide a Dataview, not a Dataset")
if dataview.movie:
raise ValueError("Cannot flatten movie volumes")
## Create quickflat image array
im, extents = make(
dataview, recache=recache, pixelwise=pixelwise, sampler=sampler, height=height, thick=thick, depth=depth
)
## Convert to PNG
try:
import cStringIO
fp = cStringIO.StringIO()
except:
fp = io.StringIO()
from matplotlib.pylab import imsave
imsave(fp, im, cmap=dataview.cmap, vmin=dataview.vmin, vmax=dataview.vmax, **kwargs)
fp.seek(0)
pngdata = binascii.b2a_base64(fp.read())
## Create and save SVG file
roipack = utils.get_roipack(dataview.subject)
roipack.get_svg(fname, labels=True, with_ims=[pngdata])
def add_prediction(self, prediction):
dirname = os.path.dirname(self.fs.path(prediction.path))
if not os.path.exists(dirname):
os.makedirs(dirname)
with self.fs.open(prediction.path, 'w') as fp:
plt.imsave(fp, prediction.sci_bytes)
def save_fig(path, magnification=1, pixels=None, fig="gcf", **imsave_plotargs):
"""Take a screenshot and saves it to a file.
:param path: The path, including extension, to save to.
:type path: str or Pathlike
:param magnification: Image dimensions relative to the size of the render (window), defaults to 1.
:type magnification: int or a (width, height) tuple of ints, optional
:param pixels: Image dimensions in pixels, defaults to None.
:type pixels: int or a (width, height) tuple of ints, optional
:param fig: The figure screenshot, defaults to vpl.gcf().
:type fig: vpl.figure, vpl.QtFigure
This just calls ``vpl.screenshot_fig`` then passes it to matplotlib's
``pylab.imsave`` function. See those for more information.
The available file formats are determined by matplotlib's choice of
backend. For JPEG, you will likely need to install PILLOW. JPEG has
considerably better file size than PNG.
"""
from matplotlib.pylab import imsave
imsave(str(path), screenshot_fig(magnification, pixels, fig),
**imsave_plotargs)
def dicom2jpg(dcm_filename, jpg_filename, new_size=None):
ds = dicom.read_file(dcm_filename)
jpg = ds.pixel_array
# if new_size is not None:
# jpg = cv2.resize(jpg, new_size, interpolation=cv2.INTER_AREA)
pylab.imsave(jpg_filename, jpg, cmap=cm.Greys_r)
def main(input):
input_file = h5.File(input)
output = os.path.join(args.output, os.path.basename(input))
if not os.path.exists(output):
os.mkdir(output)
x0 = input_file['x0'][:]
y0 = input_file['y0'][:]
loss0 = input_file['loss0'][:]
x1 = input_file['x1'][:]
y1 = input_file['y1'][:]
loss1 = input_file['loss1'][:]
label = input_file['label'][:]
id = input_file['id'][:]
for i in range(x0.shape[0]):
pic = x0[i]
pic_name = '{}_{}_{}_{}.jpg'.format(int(id[i]), int(y0[i]),
int(label[i]), loss0[i])
pic_path = os.path.join(output, pic_name)
plt.imsave(pic_path, pic.squeeze(), cmap='gray')
pic = x1[i]
pic_name = '{}_{}_{}_{}_{}applied.jpg'.format(int(id[i]), int(y1[i]),
int(label[i]), loss1[i],
str(y0[i] == y1[i]))
pic_path = os.path.join(output, pic_name)
plt.imsave(pic_path, pic.squeeze(), cmap='gray')
if (i + 1) % 100 == 0:
print('{} pics exported'.format(i + 1))
print('Pic export of {} over.'.format(input))
def vis_eigen_explore(ref_code, eigvect_avg, eigv_avg, G, figdir="", RND=None, namestr="", transpose=True, eiglist=[1,2,4,7,16], maxdist=120, rown=5, sphere=False, ImDist=None, distrown=19, scaling=None):
"""This is small scale version of vis_eigen_frame + vis_distance_vector """
if RND is None: RND = np.random.randint(10000)
if eiglist is None: eiglist = list(range(len(eigv_avg)))
if scaling is None: scaling = np.ones(len(eigv_avg))
t0 = time()
codes_page = []
for idx, eigi in enumerate(eiglist): # range(eig_rng[0]+1, eig_rng[1]+1):
scaler = scaling[idx]
if not sphere:
interp_codes = LExpMap(ref_code, eigvect_avg[:, -eigi-1], rown, (-maxdist*scaler, maxdist*scaler))
else:
interp_codes = SExpMap(ref_code, eigvect_avg[:, -eigi-1], rown, (-maxdist*scaler, maxdist*scaler))
codes_page.append(interp_codes)
codes_all = np.concatenate(tuple(codes_page), axis=0)
img_page = G.render(codes_all)
mtg = build_montages(img_page, (256, 256), (rown, len(eiglist)), transpose=transpose)[0]
imsave(join(figdir, "%s_%d-%d_%04d.jpg" % (namestr, eiglist[0]+1, eiglist[-1]+1, RND)), np.uint8(mtg * 255.0))
plt.imsave(join(figdir, "%s_%d-%d_%04d.pdf" % (namestr, eiglist[0]+1, eiglist[-1]+1, RND)), mtg, )
print("Finish printing page (%.1fs)" % (time() - t0))
if ImDist is not None: # if distance metric available then compute this
distmat, ticks, fig = vis_distance_curve(ref_code, eigvect_avg, eigv_avg, G, ImDist, eiglist=eiglist,
maxdist=maxdist, rown=rown, distrown=distrown, sphere=sphere, figdir=figdir, RND=RND, namestr=namestr, )
return mtg, codes_all, distmat, fig
else:
return mtg, codes_all
def writeStackImages(result,outputBaseName='Arp147-'):
'''
Take a saved image stack (as returned by makeArp147Image()) and save out
the individual images as something digestible by Photoshop.
INPUTS:
result: as returned by makeArp147Image(); or alternatively, a filename (string),
in which case the result will be restored from that file.
outputBaseName: the initial part of the file names to be saved out.
Format will be outputBaseName+'color-nnn.png', where color
is red/green/blue, and nnn is the frame number.
'''
bands = ['red','green','blue']
pngmax = 255
upperpercentile = 99.99
if type(result) is str:
result = np.load(result)
nimages = np.shape(result['stack'][bands[0]])[0]
for eachband in bands:
print '-----'+eachband+'------'
vals = np.copy(result['stack'][eachband]).flatten()
upperval = np.percentile(vals[~np.isnan(vals)],upperpercentile)
#upperval = np.nanmax(vals)
print 'Upper val:', upperval
for iimage in range(nimages):
fn = outputBaseName+eachband+'-'+str(iimage).zfill(3)+'.png'
im = result['stack'][eachband][iimage,:,:]
#im[np.isnan(im)] = 0
#im[im>upperval] = upperval
#im = im*pngmax/upperval
#scipy.misc.imsave(fn,im)
mpl.imsave(fname=fn,arr=im,vmin=0,vmax=upperval,cmap=mpl.cm.gray)
def main(globstr, beat_subdivisions, fs, quantized, wrap, save_img, debug):
for filepath in glob.glob(globstr):
try:
data = pm.PrettyMIDI(filepath)
b = data.get_beats()
beats = interpolate_between_beats(b, beat_subdivisions)
if quantized:
quantize(data, beats)
if not fs:
cur_fs = 1./beats[1]
while cur_fs > wrap:
cur_fs = cur_fs * 0.5
else:
cur_fs = fs
print("{}, {}".format(filepath, cur_fs))
# proll = data.get_piano_roll(fs=fs, times=beats)
proll = data.get_piano_roll(fs=cur_fs).astype(int)
if np.isnan(proll).any():
print("{} had NaN cells".format(filepath))
# automatically appends .npy fo filename
np.save(filepath, proll)
# save image
if save_img:
plt.imsave(filepath+'_o.png', proll)
plt.imsave(filepath+'_f.png', np.flipud(proll))
except:
print filepath, sys.exc_info()[0]
if debug:
traceback.print_exc()
continue
def save_fig(path,
magnification=1,
pixels=None,
trim_pad_width=None,
off_screen=False,
fig="gcf",
**imsave_plotargs):
"""Take a screenshot and saves it to a file.
:param path: The path, including extension, to save to.
:type path: str or Pathlike
:param magnification: Image dimensions relative to the size of the render (window), defaults to 1.
:type magnification: int or a (width, height) tuple of ints, optional
:param pixels: Image dimensions in pixels, defaults to None.
:type pixels: int or a (width, height) tuple of ints, optional
:param trim_pad_width: Padding to leave when cropping to contents, see :meth:`screenshot_fig`, defaults to None.
:type trim_pad_width: int, float, optional
:param off_screen: If true, attempt to take the screenshot without opening the figure's window, defaults to False.
:type off_screen: bool, optional
:param fig: The figure to save, defaults to :meth:`vtkplotlib.gcf`.
:type fig: :class:`vtkplotlib.figure`, :class:`vtkplotlib.QtFigure`, optional
This just calls :meth:`screenshot_fig` then passes it to matplotlib's
``pylab.imsave`` function. See those for more information.
The available file formats are determined by matplotlib's choice of
backend. For JPEG, you will likely need to install PILLOW. JPEG has
considerably better file size than PNG.
"""
array = screenshot_fig(magnification=magnification,
pixels=pixels,
fig=fig,
trim_pad_width=trim_pad_width,
off_screen=off_screen)
try:
from matplotlib.pylab import imsave
imsave(str(path), array, **imsave_plotargs)
return
except ImportError:
pass
try:
from PIL import Image
Image.fromarray(array).save(str(path), **imsave_plotargs)
return
except ImportError:
pass
from vtkplotlib.image_io import write
if write(array, path) is NotImplemented:
raise ValueError("No writer for format '{}' could be found. Try "
"installing PIL for more formats.".format(
Path(path).ext))
def plot_sample(self, fname='./data/sample.png', ratio=1.5, W=None, pad=1):
X_stacked = stack_X(self.X, ratio, W, pad)
fig = plt.imshow(stack_X(self.X, ratio, W, pad), cmap='Greys_r')
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.imsave(fname, X_stacked, format='png', cmap='Greys')
def summarize(results, samples, image_dir=None, prefix=''):
results = dict((k, np.mean(v)) for k, v in results.items())
logger.info(results)
if image_dir is not None:
plt.imsave(path.join(image_dir, '{}.png'.format(prefix)),
(samples.reshape(10, 10, 28, 28).transpose(
0, 2, 1, 3).reshape(10 * 28, 10 * 28)),
cmap='gray')
def plot_images(images, filename):
h, w, c = images.shape[1:]
grid_size = ceil(np.sqrt(images.shape[0]))
images = (images.reshape(grid_size, grid_size, h, w,
c).transpose(0, 2, 1, 3,
4).reshape(grid_size * h,
grid_size * w, c))
plt.figure(figsize=(16, 16))
plt.imsave(filename, images)
def draw(self, show=True, save=False, path='', figsize=5):
"""Draw QR code
Args:
show: whether to show the image or not, default is true
save: whether to save the image or not, default is false,
if turn on this option, you must pass the path too.
path: where to save the image, default is empty string,
this argument is need only if save is true.
figsize: the size of generate image
Raises:
KeyError: Invalid mode.
NotImplementedError: It only implements mode 'Alphanumeric'
with version 2 now.
ValueError:
1. The data is too long that beyond its data capacity
corresponding to the error correction level
2. Save is true but path is a empty string
"""
# encode data
generate_gf_table()
self.encode()
# draw function region
self.draw_pos_detection_pattern()
self.draw_alignment_pattern()
self.draw_timing_pattern()
self.draw_format_information()
# assign function region
for i in xrange(0, self.size):
for j in xrange(0, self.size):
self.qr_code_func[i, j] = self.qr_code_flag[i, j]
# draw data
self.draw_data()
# mask
mask = self.generate_mask()
# xor
for i in xrange(0, self.size):
for j in xrange(0, self.size):
self.qr_code_img[i, j] = int(
self.qr_code_img[i, j]) ^ int(mask[i, j])
# generate image
plt.figure(figsize=(figsize, figsize))
plt.imshow(self.qr_code_img, cmap=plt.cm.gray_r,
interpolation='nearest')
plt.axis('off')
if show:
# show
plt.show()
if save:
if path == '':
raise ValueError("Require path")
# plt.savefig(path)
plt.imsave(fname=path, arr=self.qr_code_img,
cmap=plt.cm.gray_r)
def vis_eigen_explore_row(ref_code,
eigvect_avg,
eigv_avg,
G,
figdir="",
RND=None,
namestr="",
indivimg=False,
transpose=True,
eiglist=[1, 2, 4, 7, 16],
maxdist=120,
rown=5,
sphere=False,
save=True): # ImDist=None, distrown=19
"""This is small scale version of vis_eigen_frame + vis_distance_vector """
if RND is None: RND = np.random.randint(10000)
if eiglist is None: eiglist = list(range(len(eigv_avg)))
t0 = time()
codes_page = []
mtg_col = []
ticks = np.linspace(-maxdist, maxdist, rown)
for idx, eigi in enumerate(eiglist): # range(eig_rng[0]+1, eig_rng[1]+1):
if not sphere:
interp_codes = LExpMap(ref_code, eigvect_avg[:, -eigi - 1], rown,
(-maxdist, maxdist))
else:
interp_codes = SExpMap(ref_code, eigvect_avg[:, -eigi - 1], rown,
(-maxdist, maxdist))
codes_page.append(interp_codes)
img_page = G.render(interp_codes)
mtg = build_montages(img_page, (256, 256), (rown, 1),
transpose=transpose)[0]
if save:
imsave(
join(figdir, "%s_eig%d_%04d.jpg" % (namestr, eigi + 1, RND)),
np.uint8(mtg * 255.0))
plt.imsave(
join(figdir, "%s_eig%d_%04d.pdf" % (namestr, eigi + 1, RND)),
mtg,
)
mtg_col.append(mtg)
if indivimg and save:
for deviation, img in zip(ticks, img_page):
imsave(
join(
figdir, "%s_eig%d_%.1e_%04d.jpg" %
(namestr, eigi + 1, deviation, RND)),
np.uint8(img * 255.0))
codes_all = np.concatenate(tuple(codes_page), axis=0)
print("Finish printing page (%.1fs)" % (time() - t0))
# if ImDist is not None: # if distance metric available then compute this
# distmat, ticks, fig = vis_distance_curve(ref_code, eigvect_avg, eigv_avg, G, ImDist, eiglist=eiglist,
# maxdist=maxdist, rown=rown, distrown=distrown, sphere=sphere, figdir=figdir, RND=RND, namestr=namestr, )
# return mtg, codes_all, distmat, fig
# else:
return mtg_col, codes_all
def detector_batch_deploy(LogBlobDetector, inbreast_name_list):
"""Batch deploy blob detector
Args:
LogBlobDetector:
inbreast_name_list:
Returns:
"""
inbreast_dict = inbreast.generate_inbreast_dict()
for name in inbreast_name_list:
print(name)
# get paths
try:
mask_path = \
list(glob.glob(os.path.join(inbreast_dict['basedir'], 'AllMASK_level2', '_combined', '{}*'.format(name))))[0]
image_path = list(
glob.glob(
os.path.join(inbreast_dict['basedir'], 'AllPNG',
'{}*'.format(name))))[0]
stack_path = list(
glob.glob(
os.path.join(inbreast_dict['basedir'], 'stack',
'{}*'.format(name))))[0]
except:
print('not found {}'.format(name))
continue
# read images
img = plt.imread(image_path, -1)
img_shape = img.shape
img_mask = plt.imread(mask_path, -1)
img_stack = plt.imread(stack_path, -1)
img_overlay = (img_stack[:, img_stack.shape[1] // 2:])
# get eroded binary mask
det = LogBlobDetector(img,
max_sigma=25,
min_sigma=2,
num_sigma=3,
threshold=0.1,
disk_size=50)
blobs_log = det.detect()
canvas = img_overlay.copy()
for y, x, r in blobs_log:
cv2.circle(canvas, (int(x), int(y)),
int(r + 5),
color=(102, 255, 0),
thickness=2)
# stack image side-by-side for comparison
img_log = np.hstack([canvas, np.dstack([img] * 3)])
plt.imsave(
os.path.join(inbreast_dict['basedir'], 'log',
'{}_log_th0.1.png'.format(name)), img_log)
def playVideo(self):
self.framenum = 0;
while True:
(success, img) = self.getNextFrame()
if success == False:
break;
savename = '/scail/group/deeplearning/driving_data/stillimgs/280N_right_%d.png'%(self.framenum)
img = img[:,:,::-1]
print savename
pp.imsave(savename, img)
def plot_images(images, filename):
# scale images to [0.0, 1.0]
images = (images + 1) / 2
h, w, c = images.shape[1:]
grid_size = ceil(np.sqrt(images.shape[0]))
images = (images.reshape(grid_size, grid_size, h, w, c)
.transpose(0, 2, 1, 3, 4)
.reshape(grid_size*h, grid_size*w, c))
plt.figure(figsize=(16, 16))
plt.imsave(filename, images)
plt.close('all')
def playVideo(self):
self.framenum = 0
while True:
(success, img) = self.getNextFrame()
if success == False:
break
savename = '/scail/group/deeplearning/driving_data/stillimgs/280N_right_%d.png' % (
self.framenum)
img = img[:, :, ::-1]
print savename
pp.imsave(savename, img)
def main():
parser = ap.ArgumentParser()
parser.add_argument('--directory', type=str, help='The directory of where SUNRGBD is stored.')
parser.add_argument('--imfile', type=int, help='The number of image in NYU dataset.')
args = parser.parse_args()
dataset_file = args.directory + ('SUNRGBD/kv1/NYUdata/NYU%04d/image/NYU%04d.jpg' % (args.imfile, args.imfile))
print('Extracting the file' + dataset_file)
im = skimage.io.imread(dataset_file)
seg_mask = skimage.segmentation.quickshift(im)
normalized_seg = seg_mask.astype(np.float)/np.amax(seg_mask)*255
plt.imsave("quickshift.jpg", normalized_seg, cmap=new_map)
def main():
model = mocap.model.AlgModel()
data_reader = mocap.data.H36mDataReader()
vis = mocap.vis.Visualizer()
for iter_i in tqdm(range(100)):
cameras = data_reader.load_cameras(iter_i)
images = data_reader.load_images(iter_i)
prediction = model.infer(cameras, images)
for batch_index in range(images.shape[0]):
fig = vis.vis_batch_2d(images, prediction.d2, cameras, prediction.d3, batch_index)
plt.imsave('vis_%d_%d.png' % (iter_i, batch_index), fig)
pdb.set_trace()
def plot_sample(self, fname=None, ratio = 1.5, W = None, pad = 1):
X_stacked = stack_X(self.X.reshape((-1, *self.shape_2d)), ratio, W, pad)
fig = plt.imshow(X_stacked, cmap='Greys_r')
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
if fname is None:
logger.info('Showing plot...')
else:
plt.imsave(fname, X_stacked, format='png', cmap='Greys')
def shift_image(path, shift):
rgb, depth = h5_loader(path)
shift_depth_transform = ShiftDepth(shift=shift)
shifted_depth = shift_depth_transform(depth)
# Fix the wrong colormap issue
if shift == 0:
shifted_depth = np.pad(shifted_depth, (1, 0), 'constant')
import matplotlib.pylab as plt
import os
fname = os.path.basename(path)
plt.imsave(fname[:5] + '_shift_' + str(shift) + '.jpg', shifted_depth)
def show_path(self, start, goal, came_from,
img_high=None, scale=1, save=False):
if not img_high: img_high = self.figname
fig2 = pylab.imread(img_high)
current = goal
while not current == start:
x, y = current
x *= scale
y *= scale
fig2[y][x] = np.array([255, 0, 0], dtype=np.uint8)
current = came_from[current]
pylab.imshow(fig2)
if save:
pylab.imsave(arr=fig2, fname=img_high[:-4]+'_minpath.png')
def _export_atlas(self, atlas, suffix=''):
""" export estimated atlas
:param ndarray atlas: np.array<height, width>
:param str suffix:
"""
n_img = NAME_ATLAS.format(suffix)
export_image(self.params.get('path_exp'),
atlas,
n_img,
stretch_range=False)
path_atlas_rgb = os.path.join(self.params.get('path_exp'),
n_img + '_rgb.png')
logging.debug('exporting RGB atlas: %s', path_atlas_rgb)
plt.imsave(path_atlas_rgb, atlas, cmap=plt.cm.jet)
def infer(data_filepath='data/flowers.hdf5',
z_dim=128,
out_dir='gan',
n_steps=10):
G = load_model(out_dir)
val_data = get_data(data_filepath, 'train')
val_data = next(iterate_minibatches(val_data, 2))
emb_a, emb_b = val_data[1]
txts = val_data[2]
# add batch dimension
emb_a, emb_b = emb_a[None, :], emb_b[None, :]
# sample z vector for inference
z = np.random.uniform(-1, 1, size=(1, z_dim))
G.trainable = False
# predict using embeddings a and b
fake_image_a = G.predict([z, emb_a])[0]
fake_image_b = G.predict([z, emb_b])[0]
# add and subtract
emb_add = (emb_a + emb_b)
emb_a_sub_b = (emb_a - emb_b)
emb_b_sub_a = (emb_b - emb_a)
# generate images
fake_a = G.predict([z, emb_a])[0]
fake_b = G.predict([z, emb_b])[0]
fake_add = G.predict([z, emb_add])[0]
fake_a_sub_b = G.predict([z, emb_a_sub_b])[0]
fake_b_sub_a = G.predict([z, emb_b_sub_a])[0]
fake_a = ((fake_a + 1) * 0.5)
fake_b = ((fake_b + 1) * 0.5)
fake_add = ((fake_add + 1) * 0.5)
fake_a_sub_b = ((fake_a_sub_b + 1) * 0.5)
fake_b_sub_a = ((fake_b_sub_a + 1) * 0.5)
plt.imsave("{}/fake_text_arithmetic_a".format(out_dir), fake_a)
plt.imsave("{}/fake_text_arithmetic_b".format(out_dir), fake_b)
plt.imsave("{}/fake_text_arithmetic_add".format(out_dir), fake_add)
plt.imsave("{}/fake_text_arithmetic_a_sub_b".format(out_dir), fake_a_sub_b)
plt.imsave("{}/fake_text_arithmetic_b_sub_a".format(out_dir), fake_b_sub_a)
print(str(txts[0]),
str(txts[1]),
file=open("{}/fake_text_arithmetic.txt".format(out_dir), "a"))
def save_image(image, file_name, grayscale=True):
if len(image.shape) == 2 or grayscale == True:
if len(image.shape) == 3:
image = np.sum(np.abs(image), axis=2)
vmax = np.percentile(image, 99)
vmin = np.min(image)
plt.imsave(fname=file_name,
arr=image,
cmap=plt.cm.gray,
vmin=vmin,
vmax=vmax,
dpi=100)
else:
image = image + 127.5
image = image.astype('uint8')
plt.imsave(fname=file_name, arr=image, dpi=100)
def plot(samples):
fig = plt.figure(figsize=(4, 4))
gs = gridspec.GridSpec(4, 4)
gs.update(wspace=0.05, hspace=0.05)
for i, sample in enumerate(samples):
ax = plt.subplot(gs[i])
plt.axis('off')
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_aspect('equal')
# print(sample.shape)
sample = sample.reshape(128, -1)
# print(np.array([[[sample[i][j], sample[i][j], sample[i][j], 1.0] for j in range(sample.shape[1])] for i in range(sample.shape[0])]))
plt.imsave('../gan_result/{}.png'.format(str(i).zfill(3)), np.array([[[sample[i][j], sample[i][j], sample[i][j], 1.0] for j in range(sample.shape[1])] for i in range(sample.shape[0])]), cmap='Greys_r')
return fig
def imwrite(fname: str, image: np.array):
"""save any 2d numpy array (or list) to an image file
Parameters
----------
fname : str
flie name to be saved
image : np.array
2d numpy array (or list) to be saved
"""
if "pathlib" in str(type(fname)):
fname = fname.as_posix()
if HAS_OPENCV:
cv2.imwrite(fname, image)
else:
plt.imsave(fname, image)
def rescale_2(name, scale):
img_origin = Image.open('sent_photo/' + name + '.png')
img_origin.save('sent_photo/' + name + '.png')
img = plt.imread('sent_photo/' + name + '.png')
size = (len(img), len(img[0]))
splice_x = find_splice(size[0])
splice_y = find_splice(size[1])
new_img = np.zeros((scale, scale, 3))
for i in range(scale):
for j in range(scale):
x_b, x_e = splice_x[1] * i, splice_x[0] + splice_x[1] * i
y_b, y_e = splice_y[1] * j, splice_y[0] + splice_y[1] * j
for channel in range(3):
bite = img[x_b:x_e, y_b:y_e, channel]
new_img[i, j, channel] = np.mean(bite)
plt.imsave('rescale_photo/' + name + '_s.png', new_img, cmap='gray')
return new_img
def save_images_for_debug(dir_img, imgs):
"""
2x3x12x224x224 --> [BS, C, seq_len, H, W]
"""
print("Saving images to {}".format(dir_img))
from matplotlib import pylab as plt
imgs = imgs.permute(0, 2, 3, 4, 1) # [BS, seq_len, H, W, C]
imgs = imgs.mul(255).numpy()
if not os.path.exists(dir_img):
os.makedirs(dir_img)
print(imgs.shape)
for batch_id, batch in enumerate(imgs):
batch_dir = os.path.join(dir_img, "batch{}".format(batch_id + 1))
if not os.path.exists(batch_dir):
os.makedirs(batch_dir)
for j, img in enumerate(batch):
plt.imsave(os.path.join(batch_dir, "frame{%04d}.png" % (j + 1)),
img.astype("uint8"))
def infer(data_filepath='data/flowers.hdf5', z_dim=128, out_dir='gan',
n_samples=5):
G = load_model(out_dir)
val_data = get_data(data_filepath, 'train')
val_data = next(iterate_minibatches(val_data, n_samples))
emb, txts = val_data[1], val_data[2]
# sample z vector for inference
z = np.random.uniform(-1, 1, size=(n_samples, z_dim))
G.trainable = False
fake_images = G.predict([z, emb])
for i in range(n_samples):
img = ((fake_images[i] + 1)*0.5)
plt.imsave("{}/fake_{}".format(out_dir, i), img)
print(i, str(txts[i]).strip(),
file=open("{}/fake_text.txt".format(out_dir), "a"))
def show_path(self,
start,
goal,
came_from,
img_high=None,
scale=1,
save=False):
if not img_high: img_high = self.figname
fig2 = pylab.imread(img_high)
current = goal
while not current == start:
x, y = current
x *= scale
y *= scale
fig2[y][x] = np.array([255, 0, 0], dtype=np.uint8)
current = came_from[current]
pylab.imshow(fig2)
if save:
pylab.imsave(arr=fig2, fname=img_high[:-4] + '_minpath.png')
def run_fix(ld = 2, u = 8, Q1 = 0.05, Q2 = 0.1, img = ''):
if not img:
img = plt.imread('test/Sublime_text.png')
else:
img = plt.imread(img)
if img.max() >= 200:
img /= 255.0
#plt.figure()
#plt.imshow(img)
#plt.figure()
new = np.zeros(img.shape)
for i in range(img.shape[2]):
new[:, :, i] = fix_image(img[:, :, i], ld, u, Q1, Q2)
#plt.imshow(new)
filename = generate_random_file_name()
plt.imsave('static/temp/' + filename, new)
return 'static/temp/' + filename
def find_mask(base_name, base_img, img_name, img, model_robust, channel):
# what type of interpolation
# 0: nearest-neighbor
# 1: bi-linear
warp_order = 1
output_shape, corner_min = find_output_shape(base_img, model_robust, channel)
# This in-plane offset is the only necessary transformation for the base image
offset = SimilarityTransform(translation= -corner_min)
base_warped = warp(base_img[:,:,channel], offset.inverse, order=warp_order,
output_shape = output_shape, cval=-1)
base_color = warp(base_img, offset.inverse, order=warp_order,
output_shape = output_shape, cval=-1)
# warp image corners to new position in mosaic
transform = (model_robust + offset).inverse
img_warped = warp(img[:,:,channel], transform, order=warp_order,
output_shape=output_shape, cval=-1)
img_color = warp(img, transform, order=warp_order,
output_shape=output_shape, cval=-1)
base_mask = (base_warped != -1)
base_warped[~base_mask] = 0
img_mask = (img_warped != -1)
img_warped[~img_mask] = 0
plt.imsave("img_mask.jpg", img_mask)
#convert to rgb
img_alpha = np.dstack((img_color, img_mask))
base_alpha = np.dstack((base_color, base_mask))
td = config.tmp_dir
tmp_base = os.path.join(td, 'tmp_' + '.'.join(base_name.split('.')[:-1]) + '.png')
tmp_img = os.path.join(td, 'tmp_' + '.'.join(img_name.split('.')[:-1]) + '.png')
tmp_out = os.path.join(td, 'tmp_out_' + '.'.join(base_name.split('.')[:-1]) + '.png')
plt.imsave(tmp_base, base_alpha)
plt.imsave(tmp_img, img_alpha)
cmd = ['enblend', tmp_base, tmp_img, '-o', tmp_out]
p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
output, err = p.communicate(b"input data that is passed to subprocess' stdin")
rc = p.returncode
#if you don't have enblend, you can use one of these
#merged_img = simple_merge(base_warped, img_warped, base_mask, img_mask)
#merged_img = minimum_cost_merge(base_warped, img_warped, base_mask, img_mask)
#merged_edges = remove_empty_edges(merged_img)
# remove alpha channel
if os.path.exists(tmp_out):
out = imread(tmp_out)
oute = remove_empty_alpha(out)
os.remove(tmp_base)
os.remove(tmp_img)
os.remove(tmp_out)
return oute[:,:,:3]
else:
print("Could not find out", tmp_out, rc)
raise Exception("failed cmd %s" %cmd)
def overlay_rois(im, subject, name=None, height=1024, labels=True, **kwargs):
import shlex
import subprocess as sp
from matplotlib.pylab import imsave
if name is None:
name = 'png:-'
key = (subject, labels)
if key not in rois:
print("loading %s"%subject)
rois[key] = utils.get_roipack(subject).get_texture(height, labels=labels)
cmd = "composite {rois} - {name}".format(rois=rois[key].name, name=name)
proc = sp.Popen(shlex.split(cmd), stdin=sp.PIPE, stdout=sp.PIPE)
fp = io.StringIO()
imsave(fp, im, **kwargs)
fp.seek(0)
out, err = proc.communicate(fp.read())
if len(out) > 0:
fp = io.StringIO()
fp.write(out)
fp.seek(0)
return fp
def make_svg(fname, braindata, with_labels=False, with_curvature=True, layers=['rois'],
height=1024, **kwargs):
"""Save an svg file of the desired flatmap.
This function creates an SVG file with vector graphic ROIs overlaid on a single png image.
Ideally, this function would layer different images (curvature, data, dropout, etc), but
that has been left to implement at a future date if anyone really wants it.
Parameters
----------
fname : string
file name to save
braindata : Dataview
the data you would like to plot on a flatmap
with_labels : bool
Whether to display text labels on ROIs
with_curvature : bool
Whether to include background curvature
layers : list
List of layer names to show
height : int
Height of PNG in pixels
"""
fp = io.BytesIO()
from matplotlib.pylab import imsave
## Render PNG file & retrieve image data
arr, extents = make_flatmap_image(braindata, height=height, **kwargs)
if hasattr(braindata, 'cmap'):
imsave(fp, arr, cmap=braindata.cmap, vmin=braindata.vmin, vmax=braindata.vmax)
else:
imsave(fp, arr)
fp.seek(0)
pngdata = binascii.b2a_base64(fp.read())
image_data = [pngdata]
if with_curvature:
# no options. learn to love it.
from cortex import db
fpc = io.BytesIO()
curv_vertices = db.get_surfinfo(braindata.subject)
curv_arr, _ = make_flatmap_image(curv_vertices, height=height)
mask = np.isnan(curv_arr)
curv_arr = np.where(curv_arr > 0, 0.5, 0.25)
curv_arr[mask] = np.nan
imsave(fpc, curv_arr, cmap='Greys_r', vmin=0, vmax=1)
fpc.seek(0)
image_data = [binascii.b2a_base64(fpc.read()), pngdata]
## Create and save SVG file
roipack = utils.get_roipack(braindata.subject)
roipack.get_svg(fname, layers=layers, labels=with_labels, with_ims=image_data)
g_loss = g_train_fn(g_X, g_C, g_M)
generator_updates += 1
c_epoch_losses.append(np.mean(c_losses))
g_epoch_losses.append(g_loss)
fig, axes = plt.subplots(1, 3, figsize=(8, 2))
axes[0].set_title('Loss(d)')
axes[0].plot(c_losses)
axes[1].set_title('Mean(Loss(d))')
axes[1].plot(c_epoch_losses)
axes[2].set_title('Loss(g)')
axes[2].plot(g_epoch_losses)
fig.tight_layout()
fig.savefig('images/{}/g_updates{}'.format(folderpath, generator_updates))
plt.close('all')
display.clear_output(wait=True)
noise = lasagne.utils.floatX(np.random.normal(size=g_specs['noise_shape']))
rand_ids = np.random.randint(0, g_specs['noise_shape'][0], 64)
samples = g_sample_fn(c_X, noise, c_C, c_M)[rand_ids]
plt.imsave('images/{}/epoch{}_samples.png'.format(folderpath, epoch),
(samples.reshape(8, 8, max_len, n_features)
.transpose(0, 2, 1, 3)
.reshape(8*max_len, 8*n_features)).T,
cmap='gray',
origin='bottom')
plt.close('all')
display.clear_output(wait=True)
plt.show()
test_labels, test_data = [], []
for line in open('./faces/test.txt'):
im = misc.imread(line.strip().split()[0])
test_data.append(im.reshape(2500,))
test_labels.append(line.strip().split()[1])
test_data, test_labels = np.array(test_data, dtype=float), np.array(test_labels, dtype=int)
# Part c Calculate Mean
mu = np.sum(train_data,axis=0)
mu /= train_data.shape[0]
print mu
plt.imshow(mu.reshape(50,50),cmap = cm.Greys_r)
plt.show()
plt.imsave("Mean.png",mu.reshape(50,50), cmap = cm.Greys_r)
# Part d Subtract Mean
for i in range(train_data.shape[0]):
train_data[i] = train_data[i] - mu
plt.imshow(train_data[10, :].reshape(50,50), cmap = cm.Greys_r)
for i in range(test_data.shape[0]):
test_data[i] = test_data[i] - mu
plt.imshow(test_data[10, :].reshape(50,50), cmap = cm.Greys_r)
# Part e SVD
U, s, V = np.linalg.svd(train_data, full_matrices=False)
for i in range(10):
plt.imshow(V[i].reshape(50,50), cmap = cm.Greys_r)
plt.show()
plt.imsave(str(i)+".png",V[i].reshape(50,50), cmap = cm.Greys_r)
# Find the chess board corners.
Found, Corners = cv2.findChessboardCorners(Image_BW, PatternSize)
# If found, refine the image points, add them to their lists and draw
# the chessboard corners on the images
if Found:
print 'Found pattern!'
# Find more precise corner points. The fist tuple influences the side
# length of the search window. The second tuple is the dead region in
# the middle of the search zone, see http://is.gd/xm6SXi
cv2.cornerSubPix(Image_BW, Corners, (30, 30), (-1, -1), criteria)
ImagePoints.append(Corners)
RealWorldPoints.append(ObjectPoints)
cv2.drawChessboardCorners(Image, PatternSize, Corners, Found)
plt.imsave(FileName[:-4] + '_pattern.png', Image)
print 'Saving found pattern image as %s' % FileName[:-4] + '_pattern.png'
plt.subplot(3, 4, 11 - counter + 1)
plt.imshow(ndimage.rotate(Image, 270), cmap='gray',
interpolation='nearest')
ImageTitle = os.path.basename(FileName)
if Found:
ImageTitle = '\n'.join(('Pattern found on', ImageTitle))
plt.title(ImageTitle)
plt.axis('off')
if not ImagePoints:
print 'I was not able to find a pattern on any image, maybe try ' \
'another "PatternSize"...'
exit('PatternNotFound')
plt.ylim([0, 75])
plt.legend(loc='best')
plt.title('Voltage vs. Current')
for c, i in enumerate(CompareImages):
print '%s/%s | %s kV/%s uA | Comparing %s with %s' % (
c + 1, len(CompareImages), VoltageERI[c], CurrentERI[c],
bold(os.path.basename(i)),
bold(os.path.basename(ImageListERI[c])))
ImageERI = plt.imread(ImageListERI[c])
ImageHamamatsu = plt.imread(i)
plt.subplot(gs[:2, 1:])
plt.imshow(plt.imread(ImageListERI[c]))
plt.axis('off')
plt.subplot(gs[2:, 1:])
plt.imshow(plt.imread(i))
plt.axis('off')
plt.subplots_adjust(wspace=0.02, hspace=0, left=0.03, right=1,
top=1, bottom=0)
plt.draw()
# Save figure and concatenated results
plt.savefig(os.path.join(OutputPath, '%02d' % VoltageERI[c] + 'kV' +
str(CurrentERI[c]) + 'uA.png'))
ConcatenateImage = numpy.concatenate((ImageERI, ImageHamamatsu), axis=0)
plt.imsave(os.path.join(OutputPath, 'Concatenate_%02d' % VoltageERI[c] +
'kV' + str(CurrentERI[c]) + 'uA.png'),
ConcatenateImage)
plt.ioff()
plt.show()
print 'Done with everything!'
dirpath = "data/cifar-10-python.tar/cifar-10-batches-py/"
file = "data_batch_1"
fullpath = prjpath + dirpath + file
dict = unpickle(fullpath)
data = dict['data']
labels = dict['labels']
num = np.size(labels) #データ数
ticktock = Ticktock.Ticktock()
# 参照画像を取得
ref_ind = 2
ref_image = getRGBTable(dict, ref_ind)
fname = ("ref%05d" % ref_ind) + ".png"
pl.imsave(prjpath+"result\\py04\\" + fname, ref_image)
ticktock.tick()
range_xy = np.shape(ref_image)
dest_image = np.zeros([range_xy[0]*32, range_xy[1]*32, 3], dtype='uint8') #uint8で作るのが大事
for x in range(range_xy[0]):
print x
for y in range(range_xy[1]):
ref_rgb = ref_image[x,y,:]
# 一番色が近い画像を求める
[minind, rss] = findNearestColorImage(dict, ref_rgb, range(100))
# [minind, rss] = findNearestColorImage(dict, ref_rgb, range(10000))
# [minind, rss] = findNearestColorImage(dict, ref_rgb)
# 一番近い画像を取得
near_rgb = getRGBTable(dict, minind)
# P=-ln((P-D)/(F-D)), while D and F are mean darks and mean flats
CorrectedImage = numpy.negative(
numpy.log(numpy.divide(numpy.subtract(ProjectionImage, AverageDark), numpy.subtract(AverageFlat, AverageDark)))
)
plt.clf()
plt.subplot(231)
plt.imshow(AverageFlat)
plt.title("Average flat")
plt.subplot(232)
plt.imshow(AverageDark)
plt.title("Average dark")
plt.subplot(233)
plt.imshow(ProjectionImage)
plt.title("Raw projection\n(%s)" % os.path.basename(p))
plt.subplot(212)
plt.imshow(CorrectedImage)
plt.title("Corrected image")
plt.suptitle(
"%s\nImage acquired at %skV and %suA\nwith a Detector "
"exposure time of %ss" % (os.path.basename(p.split("_")[0]), Voltage, Current, ExposureTime)
)
plt.savefig(os.path.splitext(p)[0] + ".figure.png")
plt.imsave(os.path.splitext(p)[0] + ".corrected.png", CorrectedImage)
plt.draw()
print "Done"
plt.ioff()
plt.show()
def makeImageStack(fileNames='photons_*.h5', dir=os.getenv('MKID_PROC_PATH',
default="/Scratch")+'/photonLists/20121211',
detImage=False, saveFileName='stackedImage.pkl', wvlMin=3500,
wvlMax=12000, doWeighted=True, medCombine=False, vPlateScale=0.2,
nPixRA=250,nPixDec=250,maxBadPixTimeFrac=0.2,integrationTime=-1,
outputdir=''):
'''
Create an image stack
INPUTS:
filenames - string, list of photon-list .h5 files. Can either
use wildcards (e.g. 'mydirectory/*.h5') or if string
starts with an @, supply a text file which contains
a list of file names to stack. (e.g.,
'mydirectory/@myfilelist.txt', where myfilelist.txt
is a simple text file with one file name per line.)
dir - to provide name of a directory in which to find the files
detImage - if True, show the images in detector x,y coordinates instead
of transforming to RA/dec space.
saveFileName - name of output pickle file for saving final resulting object.
doWeighted - boolean, if True, do the image flatfield weighting.
medCombine - experimental, if True, do a median combine of the image stack
instead of just adding them all.... Prob. should be implemented
properly at some point, just a fudge for now.
vPlateScale - (arcsec/virtual pixel) - to set the plate scale of the virtual
pixels in the outputs image.
nPixRA,nPixDec - size of virtual pixel grid in output image.
maxBadPixTimeFrac - Maximum fraction of time which a pixel is allowed to be
flagged as bad (e.g., hot) for before it is written off as
permanently bad for the duration of a given image load (i.e., a
given obs file).
integrationTime - the integration time to use from each input obs file (from
start of file).
OUTPUTS:
Returns a stacked image object, saves the same out to a pickle file, and
(depending whether it's still set to or not) saves out the individual non-
stacked images as it goes.
'''
#Get the list of filenames
if fileNames[0]=='@':
#(Note, actually untested, but should be more or less right...)
files=[]
with open(fileNames[1:]) as f:
for line in f:
files.append(os.path.join(dir,line.strip()))
else:
files = glob.glob(os.path.join(dir, fileNames))
#Initialise empty image centered on Crab Pulsar
virtualImage = rdi.RADecImage(nPixRA=nPixRA,nPixDec=nPixDec,vPlateScale=vPlateScale,
cenRA=1.4596725441339724, cenDec=0.38422539085925933)
imageStack = []
for eachFile in files:
if os.path.exists(eachFile):
print 'Loading: ',os.path.basename(eachFile)
#fullFileName=os.path.join(dir,eachFile)
phList = pl.PhotList(eachFile)
baseSaveName,ext=os.path.splitext(os.path.basename(eachFile))
if detImage is True:
imSaveName=os.path.join(outputdir,baseSaveName+'det.tif')
im = phList.getImageDet(wvlMin=wvlMin,wvlMax=wvlMax)
utils.plotArray(im)
mpl.imsave(fname=imSaveName,arr=im,colormap=mpl.cm.gnuplot2,origin='lower')
if eachFile==files[0]:
virtualImage=im
else:
virtualImage+=im
else:
imSaveName=os.path.join(outputdir,baseSaveName+'.tif')
virtualImage.loadImage(phList,doStack=not medCombine,savePreStackImage=imSaveName,
wvlMin=wvlMin, wvlMax=wvlMax, doWeighted=doWeighted,
maxBadPixTimeFrac=maxBadPixTimeFrac, integrationTime=integrationTime)
imageStack.append(virtualImage.image*virtualImage.expTimeWeights) #Only makes sense if medCombine==True, otherwise will be ignored
if medCombine==True:
medComImage = scipy.stats.nanmedian(np.array(imageStack), axis=0)
toDisplay = np.copy(medComImage)
toDisplay[~np.isfinite(toDisplay)] = 0
utils.plotArray(toDisplay,pclip=0.1,cbar=True,colormap=mpl.cm.gray)
else:
virtualImage.display(pclip=0.5,colormap=mpl.cm.gray)
medComImage = None
mpl.show()
else:
print 'File doesn''t exist: ',eachFile
#Save the results.
#Note, if median combining, 'vim' will only contain one frame. If not, medComImage will be None.
results = {'vim':virtualImage,'imstack':imageStack,'medim':medComImage}
try:
output = open(os.path(outputdir,saveFileName),'wb')
pickle.dump(results,output,-1)
output.close()
except:
warnings.warn('Unable to save results for some reason...')
return results
ticktock = Ticktock.Ticktock()
# 平均値一覧を取得
means = calMeans(dict)
# 参照画像を取得
ref_ind = 2
ref_image = getRGBTable(dict, ref_ind)
fname = ("ref%05d" % ref_ind) + ".png"
resultpath = prjpath+"result"
resultpath2 = resultpath + "/py04"
if os.path.exists(resultpath) == False:
os.mkdir(resultpath)
if os.path.exists(resultpath2 ) == False:
os.mkdir(resultpath2)
pl.imsave(resultpath2 + "/" + fname, ref_image)
ticktock.tick()
range_xy = np.shape(ref_image)
dest_image = np.zeros([range_xy[0]*32, range_xy[1]*32, 3], dtype='uint8') #uint8で作るのが大事
for x in range(range_xy[0]):
print x
for y in range(range_xy[1]):
ref_rgb = ref_image[x,y,:]
# 一番色が近い画像を求める
# [minind2, rss2] = findNearestColorImage(dict, ref_rgb, range(100))
# ind3 = range(100)
num_threashold=50
[minind, rss] = findNearestColorImageUseMeans(dict, ref_rgb, means, num_threashold, range(10000))
# 一番近い画像を取得
# load data
datapath = '/media/steampunkhd/rafaelvalle/datasets/MIDI/Piano'
glob_file_str = '*.npy'
n_pieces = 0 # 0 is equal to all pieces, unbalanced dataset
crop = (32, 96)
alphabet_size = 64
as_dict = False
n_steps = 64
i_len = 64
patch_size = False
inputs, labels = load_proll_data(
datapath, glob_file_str, n_pieces, crop, as_dict, patch_size=patch_size)
labels = np.array(labels)
iterator = iterate_minibatches_proll
# shuffle data
np.random.shuffle(inputs)
BATCH_SIZE = 64
train_gen = iterator(inputs, labels, BATCH_SIZE, shuffle=True, length=i_len,
forever=True)
for i in range(10):
samples, _ = train_gen.next()
plt.imsave('real_sample_{}_o.png'.format(i),
(samples.reshape(8, 8, alphabet_size, n_steps)
.transpose(0, 2, 1, 3)
.reshape(8*alphabet_size, 8*n_steps)), cmap='bwr')
plt.imsave('real_sample_{}_f.png'.format(i),
np.flipud((samples.reshape(8, 8, alphabet_size, n_steps)
.transpose(0, 2, 1, 3)
.reshape(8*alphabet_size, 8*n_steps))), cmap='bwr')
def main():
# ppservers = ()
# ppservers = ("192.168.1.242",)
ppservers = ("192.168.1.243","192.168.1.242", )
# job_server = pp.Server(1, ppservers=ppservers) #自PCのCPUリソース数を第一引き数で指定。0だと自PCは何もしない
job_server = pp.Server(0, ppservers=ppservers) #自PCのCPUリソース数を第一引き数で指定。0だと自PCは何もしない
# 時間測定用
ticktock = Ticktock.Ticktock()
# 変換元の画像
ref_image = loadSrcImage()
# 変換元画像を分割
# 水平方向（X方向）に分割
# num_separate = 1 #分割数
num_separate = len(ppservers) #分割数
size_x = numpy.shape(ref_image)[1]
columns = split_seq(range(size_x), num_separate)
ref_img_separated = []
for i in range(num_separate):
ref_img_separated.append(ref_image[:,columns[i],:])
ticktock.tick() #速度測定開始
# モザイク画作成
jobs = []
for i, img_in in enumerate(ref_img_separated):
job = job_server.submit(makeMosaicImage,
(img_in,),
(unpickle, calMeans, getImageNum, getRGB, getPIXSIZE,
getPIXNUM, findNearestColorImageUseMeans, findNearestColorImage,
getColorRSSFromRGB, getRGBTable, putSmallImageOntoLargeImage,
getCifar10FilePath, isExistMenaFile, getMeanFilePath, saveMeans, loadMeans, ),
("numpy","pickle"))
jobs.append(job)
# 実行結果を得る
dest_image = []
for jo in jobs:
result = jo()
# print result
dest_image.append(result)
# 変換結果を結合
dest_image_cat = []
for i, img_out in enumerate(dest_image):
if i==0:
dest_image_cat = img_out
else:
dest_image_cat = numpy.hstack([dest_image_cat, img_out])
ticktock.tock() #速度測定終了
# レポート表示
job_server.print_stats()
# 保存
pl.imsave(getResultPath() + "/dest.png", dest_image_cat)
