def extract_surf(image):# todo change the name of the function
"""*********************************************************************
"""# todo : copy the documentation from the C++ file
# save input images
tmp_folder=tempfile.mkdtemp()
imwrite(os.path.join(tmp_folder,'image.png'),image)
command='cd %s'%tmp_folder+';'# moving in the temporary folder
command+=bin_directory+'/extract_surf image.png surf_point.txt'
# calling the executable
os.system( command)
# todo: read the outputs from the temporary file
# it call help to open the temporary folder in your file explorer
#imgOutVert=imread(os.path.join(tmp_folder,'imgOutVert.png'))
#imgOutHori=imread(os.path.join(tmp_folder,'imgOutHori.png'))
with open(os.path.join(tmp_folder,'surf_point.txt'),'r') as file:
l=file.readline()#skipping the first line
l=file.readline()
key_points=np.loadtxt(file)
# todo : delete the temporary files
shutil.rmtree(tmp_folder)
return key_points
def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (HEIGHT, WIDTH))
kps = []
for y in range(NB_ROWS):
ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1))
for x in range(NB_COLS):
xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1))
kp = (xcoord, ycoord)
kps.append(kp)
kps = set(kps)
kps = [ia.Keypoint(x=xcoord, y=ycoord) for (xcoord, ycoord) in kps]
kps = ia.KeypointsOnImage(kps, shape=image.shape)
bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2)
bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape)
seq = iaa.Affine(rotate=45)
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_image(image)
kps_aug = seq_det.augment_keypoints([kps])[0]
bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]
image_before = np.copy(image)
image_before = kps.draw_on_image(image_before)
image_before = bbs.draw_on_image(image_before)
image_after = np.copy(image_aug)
image_after = kps_aug.draw_on_image(image_after)
image_after = bbs_aug.draw_on_image(image_after)
ia.imshow(np.hstack([image_before, image_after]))
imageio.imwrite("bb_aug.jpg", np.hstack([image_before, image_after]))
def generate(flag):
data = gen_qr(flag, version=7, box_size=1)
patch_size = 5
patch_list = list()
for i in range(0, data.shape[0], patch_size):
for j in range(0, data.shape[1], patch_size):
patch_list.append((i , j))
# setup
x, y = patch_list[0]
patch_data = str(int(''.join([str(c) for c in list(data[x:x+patch_size, y:y+patch_size].flatten())]), 2))
for v in range(1, 41):
try:
patch_qr = gen_qr(patch_data, version=v)
except qrcode.exceptions.DataOverflowError:
continue
else:
factor = patch_qr.shape[0] // patch_size
padding = patch_qr.shape[0] - factor * patch_size
if padding > 0:
continue
else:
break
# emplace
large_data = np.repeat(np.repeat(data, factor, axis=0), factor, axis=1)
for x, y in patch_list:
patch_data = str(int(''.join([str(c) for c in list(data[x:x+patch_size, y:y+patch_size].flatten())]), 2))
patch_qr = np.rot90(gen_qr(patch_data, version=v), k=random.randint(0, 3))
large_data[x * factor : x * factor + patch_qr.shape[0], y * factor : y * factor + patch_qr.shape[1]] = patch_qr
print(large_data.shape)
imageio.imwrite('code.png', np.repeat(np.repeat(large_data, 4, axis=0), 4, axis=1) * 255)
def make_comment(count=1, out_path="output", vid_file=None):
vid_file = vid_file or get_random_mkv()
log(u"Using {} as source...".format(os.path.basename(vid_file)))
label = os.path.basename(vid_file).split(".")[0].replace(" ","").lower()
vid_clip = VideoFileClip(vid_file)
earliest = int(vid_clip.duration * 0.1)
latest = int(vid_clip.duration * 0.9)
valid_range = range(earliest, latest+1)
sub_opts = make_sub_opts(vid_clip);
with open("queue.txt", "a") as queue:
real_lines = process_memorable_lines(20, 110)
for n in range(1, count+1):
### this "None" will get a random SRT from corpora, by default.
### Can override with specific source file
### txt_line = get_nyer_caption(20, 110)
### txt_line = get_tweetable_line("corpora/tentacle-rough.txt", min_length=30, max_length=90)
txt_line = choice(real_lines)
debug(u"Using {} as subtitle...".format(txt_line.encode('utf8', 'ignore')))
txt_clip = sub_generator(txt_line, **sub_opts)
composed = CompositeVideoClip([vid_clip, txt_clip.set_pos("top")])
frame = composed.get_frame(choice(valid_range))
log(u"\tWriting {0} of {1:03d}...".format(n, count) )
image_path = u"{0}/{1}_{2:03d}.png".format(out_path, label, n)
imwrite(image_path, frame)
queue.write(u"{0}{1}{2}\n".format(image_path, queue_separator, txt_line).encode('utf8', 'replace') )
def nlmeans(image,sigma,noise_free=None):
"""
`nlmeans_ipol ` takes 4 parameter: `nlmeans_ipol in.png sigma noisy.png denoised.png`
* `sigma` : the noise standard deviation
* `in.png` : initial noise free image
* `noisy.png` : noisy image used by the denoising algorithm
* `denoised.png` : denoised image
"""
#saving input image to a temporary file
output_file=tempfile.mkstemp('.PNG')[1]
temp_image_file =tempfile.mkstemp('.PNG')[1]
imwrite(temp_image_file,image)
if not noise_free is None:
temp_noise_free_image_file =tempfile.mkstemp('.PNG')[1]
imwrite(temp_noise_free_image_file,noise_free)
else:
temp_noise_free_image_file=temp_image_file
command=exec_folder+'/nlmeans_ipol %s %f %s %s'%(temp_noise_free_image_file,sigma,temp_image_file,output_file)
# calling the executable
os.system( command)
#reading the output from the temporary file
output=imread(output_file)
os.remove(output_file)
if not noise_free is None:
os.remove(temp_noise_free_image_file)
os.remove(temp_image_file)
return output
def save_colorized_image(data, fpath, center=None, cmap='hot', batchnorm=False, fullcmap=False, what='explanation', outshape=[5, 6]):
if isinstance(data, nd.NDArray):
data = asnumpy(data)
N, C, H, W = data.shape
data = data.transpose([0, 2, 3, 1])
if outshape is None:
outshape = [int(N**0.5)]*2
crop = np.prod(outshape)
oH, oW = outshape
data = data[:crop].mean(axis=3)
if batchnorm:
lo, hi = data.min(), data.max()
else:
lo = data.min(axis=1, keepdims=True).min(axis=2, keepdims=True)
hi = data.max(axis=1, keepdims=True).max(axis=2, keepdims=True)
if not fullcmap:
hi = np.maximum(np.abs(lo), np.abs(hi))
lo = -hi
#getLogger('ecGAN').debug('%s min %f, max %f', what, lo.min(), hi.max())
data = draw_heatmap(data, lo, hi, center=center, cmap=cmap)
#getLogger('ecGAN').debug('data min %s, max %s', str(data.min()), str(data.max()))
data = (data * 255).clip(0, 255).astype(np.uint8)
data = align_images(data, oH, oW, H, W, 3)
imwrite(fpath, data)
getLogger('ecGAN').info('Saved %s in \'%s\'.', what, fpath)
def imnoise(image,model,sigma):
"""
Syntax: imnoise <model>:<sigma> <input> <output>
The program reads the image <input> and simulates noise to create <output>.
The <model>:<sigma> argument has the same meaning as in tvdenoise.
"""
#saving input image to a temporary file
output_file=tempfile.mkstemp('.PNG')[1]
temp_image_file =tempfile.mkstemp('.PNG')[1]
imwrite(temp_image_file,image)
assert(model in ['gaussian','laplace','poisson'])
command=exec_folder+'/imnoise %s:%f %s %s'%(model,sigma,temp_image_file,output_file)
# calling the executable
os.system( command)
#reading the output from the temporary file
output=imread(output_file)
os.remove(output_file)
os.remove(temp_image_file)
return output
def _make_still(self, pattern):
if "still" not in pattern:
return
last_shot = self._lookup_matching(pattern)[-1]
overlays = self._load_overlays(pattern)
content = self._compose_frame(last_shot, overlays)
imageio.imwrite(self._output / pattern["still"], content, "PNG-FI")
def imblur(image,kernel,radius=None,sigma_kernel=None,noise='gaussian',sigma=2,jpegquality=100):
"""
The imblur program blurs and adds noise to an image.
Parameters
K:<kernel> blur kernel for deconvolution
K:disk:<radius> filled disk kernel
K:gaussian:<sigma> Gaussian kernel
K:<file> read kernel from text or image file
noise:<model>:<sigma> simulate noise with standard deviation sigma
noise:gaussian:<sigma> additive white Gaussian noise
noise:laplace:<sigma> Laplace noise
noise:poisson:<sigma> Poisson noise
f:<file> input file (alternative syntax)
u:<file> output file (alternative syntax)
jpegquality:<number> quality for saving JPEG images (0 to 100)
"""
assert(noise in ['gaussian','laplace','poisson'])
#saving input image to a temporary file
output_file=tempfile.mkstemp('.PNG' )[1]
image_file =tempfile.mkstemp('.PNG')[1]
imwrite(image_file,image)
command=exec_folder+'/imblur %s %s'%(image_file,output_file)
if kernel=='disk':
command+=' K:disk:%s'%(radius)
assert(sigma_kernel is None)
elif kernel=='gaussian':
command+=' K:gaussian:%s'%(sigma_kernel)
assert(radius is None)
elif isinstance(kernel,np.array) :
pass
command+=' noise:%s:%f'%(noise,sigma)
# calling the executable
#subprocess.call( command ,shell=True)
p = Popen(command, stdout = PIPE, stderr = PIPE,bufsize=1,shell=True)
for line in iter(p.stdout.readline, ''):
print (line)
p.stdout.close()
p.wait()
#reading the output from the temporary file
output=imread(output_file)
os.remove(output_file)
os.remove(image_file)
return output
def tvdeconv(image,kernel,radius=None,sigma_kernel=None,lamb=50,noise='gaussian',jpegquality=100):
"""
Parameters
K:<kernel> blur kernel for deconvolution
K:disk:<radius> filled disk kernel
K:gaussian:<sigma> Gaussian kernel
K:<file> read kernel from text or image file
lambda:<value> fidelity weight
noise:<model> noisy model
noise:gaussian additive Gaussian noise (default)
noise:laplace Laplace noise
noise:poisson Poisson noise
f:<file> input file (alternative syntax)
u:<file> output file (alternative syntax)
jpegquality:<number> quality for saving JPEG images (0 to 100)
"""
assert(noise in ['gaussian','laplace','poisson'])
#saving input image to a temporary file
output_file=tempfile.mkstemp('.PNG')[1]
image_file =tempfile.mkstemp('.PNG')[1]
imwrite(image_file,image)
command=exec_folder+'/tvdeconv %s %s'%(image_file,output_file)
if kernel=='disk':
command+=' K:disk:%s'%(radius)
assert(sigma_kernel is None)
elif kernel=='gaussian':
command+=' K:gaussian:%s'%(sigma_kernel)
assert(radius is None)
elif isinstance(kernel,np.array) :
pass
command+=' lambda:%f'%lamb
command+=' noise:%s'%noise
# calling the executable
#subprocess.call( command ,shell=True)
p = Popen(command, stdout = PIPE, stderr = PIPE,bufsize=1,shell=True)
for line in iter(p.stdout.readline, ''):
print (line)
p.stdout.close()
p.wait()
#reading the output from the temporary file
output=imread(output_file)
os.remove(output_file)
os.remove(image_file)
return output
def export_color_images(self, output_path, image_size=None, frame_skip=1):
if not os.path.exists(output_path):
os.makedirs(output_path)
print('exporting', len(self.frames)//frame_skip, 'color frames to', output_path)
for f in range(0, len(self.frames), frame_skip):
color = self.frames[f].decompress_color(self.color_compression_type)
if image_size is not None:
color = cv2.resize(color, (image_size[1], image_size[0]), interpolation=cv2.INTER_NEAREST)
imageio.imwrite(os.path.join(output_path, str(f) + '.jpg'), color)
def _saveImage(self, filepath, **kwargs):
import math
for i in range(0, self.frameCount):
uri = "{0}_{1:0>{width}}.png".format(
os.path.splitext(filepath)[0],
i,
width = math.floor(math.log10(self.frameCount)) + 1
)
imageio.imwrite(uri, self.frame(i))
def test_imwrite_not_array_like():
class Foo(object):
def __init__(self):
pass
with raises(ValueError):
imageio.imwrite("foo.bmp", Foo())
with raises(ValueError):
imageio.imwrite("foo.bmp", "asd")
def export_depth_images(self, output_path, image_size=None, frame_skip=1):
if not os.path.exists(output_path):
os.makedirs(output_path)
print('exporting', len(self.frames)//frame_skip, ' depth frames to', output_path)
for f in range(0, len(self.frames), frame_skip):
depth_data = self.frames[f].decompress_depth(self.depth_compression_type)
depth = np.fromstring(depth_data, dtype=np.uint16).reshape(self.depth_height, self.depth_width)
if image_size is not None:
depth = cv2.resize(depth, (image_size[1], image_size[0]), interpolation=cv2.INTER_NEAREST)
imageio.imwrite(os.path.join(output_path, str(f) + '.png'), depth)
def spatial( image1,image2, processors=1, alpha=18, gamma=1, nscales=100, zoom_factor=0.75, TOL=0.0001, inner_iter=1, outer_iter=15,verbose=False):
"""
Enhance the colors of an image using the method decribed in
Automatic Color Enhancement (ACE) and its Fast Implementation
Pascal Getreuer IPOL 2012
Usage:
inputs
Images : list of images as a list of numpy arrays
processors : number of processors to run the method
alpha : weight of the smoothing term
gamma : weight of the gradient constancy term
nscales : desired number of scales
zoom_factor : downsampling factor
TOL : stopping criterion threshold for the numerical scheme
inner_iter : number of inner iterations in the numerical scheme
outer_iter : number of outer iterations in the numerical scheme
verbose : 0 or 1, for quiet or verbose behaviour
return
list of optical flow images as numpy arrays
"""
# todo : you can copy the documentation from the C++ file
# it is prefered to clean the description for it to better
# reflect the python binding interface
# create temporary folder where temporary file while be read an created by the executable
tmp_folder=tempfile.mkdtemp()
if not (isinstance([],list)):
BaseException('your input image should be pu in a python list')
# todo : save the input images
imwrite(os.path.join(tmp_folder,'image1.png'),image1)
imwrite(os.path.join(tmp_folder,'image2.png'),image2)
command='cd %s'%tmp_folder+';'# moving in the temporary folder
command+=os.path.join(binary_directory1,'main ')+' image1.png image2.png flow.uv %f %f %d %f %f %d %d %s %d'%(\
alpha, gamma, nscales, zoom_factor, TOL, inner_iter, outer_iter,tmp_folder,verbose)
# calling the executable
os.system( command)
#todo: read the output from the temporary file
output_file=os.path.join(tmp_folder,'flow.uv')
with open(output_file,'r') as file:
file.readline()
file.readline()
file.readline()
flow=np.fromfile(file,dtype=np.float32)[57:].reshape(2,image1.shape[0],image1.shape[1]).transpose((1,2,0))
# delete the temporary files
shutil.rmtree(tmp_folder)
return flow
def asift(image1,image2,resize_input=0):# todo change the name of the function
"""
*******************************************************************************
*************************** ASIFT image matching ****************************
*******************************************************************************
Usage: " << argv[0] << " imgIn1.png imgIn2.png imgOutVert.png imgOutHori.png
matchings.txt keys1.txt keys2.txt [Resize option: 0/1]
- imgIn1.png, imgIn2.png: input images (in PNG format).
- imgOutVert.png, imgOutHori.png: output images (vertical/horizontal concatenated,
in PNG format.) The detected matchings are connected by write lines.
- matchings.txt: coordinates of matched points (col1, row1, col2, row2).
- keys1.txt keys2.txt: ASIFT keypoints of the two images.
- [optional 0/1]. 1: input images resize to 800x600 (default). 0: no resize.
*******************************************************************************
********************* Jean-Michel Morel, Guoshen Yu, 2010 ********************
*******************************************************************************
"""# todo : copy the documentation from the C++ file
# save input images
tmp_folder=tempfile.mkdtemp()
imwrite(os.path.join(tmp_folder,'imgIn1.png'),image1)
imwrite(os.path.join(tmp_folder,'imgIn2.png'),image2)
command='cd %s'%tmp_folder+';'# moving in the temporary folder
command+=source_directory+'/demo_ASIFT imgIn1.png imgIn2.png imgOutVert.png imgOutHori.png matchings.txt keys1.txt keys2.txt %d'%resize_input
# calling the executable
os.system( command)
# todo: read the outputs from the temporary file
# it call help to open the temporary folder in your file explorer
#imgOutVert=imread(os.path.join(tmp_folder,'imgOutVert.png'))
#imgOutHori=imread(os.path.join(tmp_folder,'imgOutHori.png'))
with open(os.path.join(tmp_folder,'matchings.txt'),'r') as file:
nbmatches=int(file.readline())#skipping the first line
matchings=np.loadtxt(file)
with open(os.path.join(tmp_folder,'keys1.txt'),'r') as file:
file.readline()#skipping the first line that contain the size of the matrix
keys1=np.loadtxt(file)
with open(os.path.join(tmp_folder,'keys2.txt'),'r') as file:
file.readline()#skipping the first line that contain the size of the matrix
keys2=np.loadtxt(file)
# todo : delete the temporary files
shutil.rmtree(tmp_folder)
return matchings,keys1,keys2
def ace(image,alpha,omega,sigma=None,method='interp',levels=None,degree=None,jpeg_quality=100):
"""
Usage: ace [options] input output
where "input" and "output" are BMP files (JPEG, PNG, or TIFF files can also
be used if the program is compiled with libjpeg, libpng, and/or libtiff).
Options:
-a <number> alpha, stronger implies stronger enhancement
-w <omega> omega, spatial weighting function, choices are
1/r default ACE, omega(x,y) = 1/sqrt(x^2+y^2)
1 constant, omega(x,y) = 1
G:# Gaussian, where # specifies sigma,
omega(x,y) = exp(-(x^2+y^2)/(2 sigma^2))
-m <method> method to use for fast computation, choices are
interp:# interpolate s_a(L - I(x)) with # levels
poly:# polynomial s_a with degree #
-q <number> quality for saving JPEG images (0 to 100)
"""
#saving input image to a temporary file
output_file=tempfile.mkstemp('.PNG')[1]
temp_image_file =tempfile.mkstemp('.PNG')[1]
imwrite(temp_image_file,image)
if method=='interp':
method_str='interp:%d'%levels
assert(degree is None)
elif ethod=='poly':
method_str='poly:%d'%degree
assert(levels is None)
if omega=='G':
omega_str='G %f'%sigma
else:
omega_str=omega
assert(sigma is None)
options='-a %f -w %s -m %s %s %s'%(alpha,omega_str,method_str,temp_image_file,output_file)
if False: #using the executable
command=exec_folder+'/ace %s'%options
# calling the executable
os.system( command)
else:
print (options.split(' '))
_wrapper.main(options.split(' '))
#reading the output from the temporary file
output=imread(output_file)
os.remove(output_file)
os.remove(temp_image_file)
return output
def inpaint(image,mask,method='nlmeans',patch=9,iters=300,scales=7,coarse=0.3,conft=5,confa=0.1,lamb=0.05,init='poisson',psigma=10000):
"""
options
-method method name (nlmeans)
-patch patch side (9)
-iters inpainting iterations (300)
-scales scales amount (7)
-coarse coarsest rate (0.3)
-conft confidence decay time (5)
-confa confidence asymptotic value (0.1)
-lambda lambda (0.05)
-init initialization type [poisson/black/avg/none] (poisson)
-psigma Gaussian patch weights (10000)
-showpyr PREFIX write intermediate pyramid results
-shownnf FILENAME write illustration of the final NNF
"""
#saving input image to a temporary file
output_file=tempfile.mkstemp('.PNG' )[1]
image_file =tempfile.mkstemp('.PNG')[1]
imwrite(image_file,image)
mask_file =tempfile.mkstemp('.PNG')[1]
imwrite(mask_file,mask)
command=exec_folder+'/build/Inpainting %s %s %s'%(image_file,mask_file,output_file)
command+=' -method %s'%method
command+=' -patch %d'%patch
command+=' -iters %d'%iters
command+=' -scales %d'%scales
command+=' -coarse %f'%coarse
command+=' -conft %f'%conft
command+=' -confa %f'%confa
command+=' -lambda %f'%lamb
command+=' -init%s'%init
command+=' -psigma %f'%psigma
# calling the executable
#subprocess.call( command ,shell=True)
p = Popen(command, stdout = PIPE, stderr = PIPE,bufsize=1,shell=True)
for line in iter(p.stdout.readline, ''):
print (line)
p.stdout.close()
p.wait()
#reading the output from the temporary file
l=glob.glob(output_file+'_*')# trick because the output file name is not excactly the one expected , things are added at the end
assert(len(l)==1)
output=imread(l[0])
os.remove(l[0])
os.remove(output_file)
os.remove(image_file)
os.remove(mask_file)
return output
def test_imwrite_not_subclass(tmpdir):
class Foo(object):
def __init__(self):
pass
def __array__(self, dtype=None):
return np.zeros((4, 4), dtype=dtype)
filename = os.path.join(str(tmpdir), "foo.bmp")
imageio.imwrite(filename, Foo())
im = imageio.imread(filename)
assert im.shape == (4, 4)
def _test():
while True:
try:
if not BufFrameQ.empty():
frm = BufFrameQ.get()
ts = TStampQ.get()
filename = datetime.fromtimestamp(ts).strftime('%m-%d_%H:%M:%S.%f') + '.jpg'
imageio.imwrite(filename, frm)
# print out log
print 'Saved image', filename
except KeyboardInterrupt:
break
def test_tifffile_reading_writing():
""" Test reading and saving tiff """
need_internet() # We keep a test image in the imageio-binary repo
im2 = np.ones((10, 10, 3), np.uint8) * 2
filename1 = os.path.join(test_dir, 'test_tiff.tiff')
# One image
imageio.imsave(filename1, im2)
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert (im == im2).all()
assert len(ims) == 1
# Multiple images
imageio.mimsave(filename1, [im2, im2, im2])
im = imageio.imread(filename1)
ims = imageio.mimread(filename1)
assert (im == im2).all()
assert len(ims) == 3, ims[0].shape
# remote multipage rgb file
filename2 = get_remote_file('images/multipage_rgb.tif')
img = imageio.mimread(filename2)
assert len(img) == 2
assert img[0].shape == (3, 10, 10)
# Mixed
W = imageio.save(filename1)
W.set_meta_data({'planarconfig': 'planar'})
assert W.format.name == 'TIFF'
W.append_data(im2)
W.append_data(im2)
W.close()
#
R = imageio.read(filename1)
assert R.format.name == 'TIFF'
ims = list(R) # == [im for im in R]
assert (ims[0] == im2).all()
meta = R.get_meta_data()
assert meta['orientation'] == 'top_left'
# Fail
raises(IndexError, R.get_data, -1)
raises(IndexError, R.get_data, 3)
# Ensure imwrite write works round trip
filename3 = os.path.join(test_dir, 'test_tiff2.tiff')
R = imageio.imread(filename1)
imageio.imwrite(filename3, R)
R2 = imageio.imread(filename3)
assert (R == R2).all()
def __onSaveImage(self):
filename = gui.QFileDialog.getSaveFileName()
if (qtver == 5):
filename = filename[0]
else:
filename = str(filename)
if (len(filename) == 0):
return
#self.imgwdg.getPixmap().save(filename) # Use Qt for saving images.
try:
imwrite(filename, self.imgwdg.getNPArray()) # Use Scipy for saving images.
except Exception as e:
gui.QMessageBox.critical(self, "Exception", "An error is thrown while saving: {}".format(e))
def write(self, imagearr, file_name=None):
if file_name != None:
self.file_name = file_name
elif self.file_name != None:
pass
else:
raise Exception(" %s , Undefined file name: " %
sys._getframe().f_code.co_name)
imagearr.un_normalize()
imageio.imwrite(self.file_name, imagearr.get_uint_array(
tdepth=self.out_color_depth), None)
def saveImagesMono(images, size, path):
img = images
h, w = img.shape[1], img.shape[2]
merge_img = np.zeros((h * size[0], w * size[1], 1),dtype="float32")
for idx, image in enumerate(images):
i = idx % size[1]
j = idx // size[1]
merge_img[j*h:j*h+h, i*w:i*w+w, :] = image
#Max value == min value, ambiguous given dtype 因为值全是0
merge_img = np.clip(merge_img, -0.5, 0.5)
imageio.imwrite(path, merge_img)
return
def main():
opts = docopt.docopt(__doc__)
datadir = opts['<datadir>']
outputdir = os.path.join(datadir, 'superpixel')
if not os.path.isdir(outputdir):
os.makedirs(outputdir)
for input_fn in glob.glob(os.path.join(datadir, 'input', '*.JPG')):
input_base = os.path.join(outputdir,
os.path.splitext(os.path.basename(input_fn))[0])
if os.path.isfile(input_base + '.npz'):
print('Skipping since {} exists'.format(input_base))
continue
print('Input: ' + input_fn)
input_im = imageio.imread(input_fn)
print('Converting to LAB colorspace')
lab_im = skimcolor.rgb2lab(input_im)
labels = np.zeros(input_im.shape[:2])
print('Segmenting (watershed)...')
labels = skimseg.join_segmentations(labels, ws_segment(lab_im[..., 0]))
print('Segmenting (slic)...')
# Set number of segments so each segment is roughly seg_size*seg_size in area
seg_size = 128
n_segments = 1 + int(input_im.shape[0] * input_im.shape[1] /
(seg_size*seg_size))
labels = skimseg.join_segmentations(labels,
skimseg.slic(lab_im, n_segments=n_segments, sigma=1,
compactness=0.1, multichannel=True, convert2lab=False,
slic_zero=True)
)
print('Enforcing connectivity')
# Enforce connectivity. This is important otherwise superpixels may be
# spread over image.
labels = skimmeas.label(labels)
print('Saving output...')
# Write visualisation
imageio.imwrite(input_base + '-visualisation.jpg',
skimseg.mark_boundaries(input_im, labels))
# Write output
np.savez_compressed(input_base + '.npz', labels=labels)
def save_aligned_image(data, fpath, bbox, what='input data', outshape=[5, 6]):
if isinstance(data, nd.NDArray):
data = asnumpy(data)
N, C, H, W = data.shape
data = data.transpose([0, 2, 3, 1])
if outshape is None:
outshape = [int(N**0.5)]*2
crop = np.prod(outshape)
data = data[:crop]
oH, oW = outshape
indat = ((data - bbox[0]) * 255/(bbox[1]-bbox[0])).clip(0, 255).astype(np.uint8)
indat = align_images(indat, oH, oW, H, W, C)
imwrite(fpath, indat)
getLogger('ecGAN').info('Saved %s in \'%s\'.', what, fpath)
def saveImages(images, size, path):
img = images
h, w = img.shape[1], img.shape[2]
merge_img = np.zeros((h * size[0], w * size[1], 3),dtype="float32")
for idx, image in enumerate(images):
i = idx % size[1]
j = idx // size[1]
merge_img[j*h:j*h+h, i*w:i*w+w, :] = image
merge_img = np.clip(merge_img, -0.5, 0.5)
merge_img[0,0,0] = 0.5
merge_img[0,0,1] = -0.5
imageio.imwrite(path, merge_img)
return
def file_writer(filename, signal, file_format='png', **kwds):
"""Writes data to any format supported by PIL
Parameters
----------
filename: str
signal: a Signal instance
file_format : str
The fileformat defined by its extension that is any one supported by
PIL.
"""
data = signal.data
if rgb_tools.is_rgbx(data):
data = rgb_tools.rgbx2regular_array(data)
imwrite(filename, data)
def save_image(image, image_path='_temp.png'):
"""Save a image.
Parameters
-----------
image : numpy array
[w, h, c]
image_path : str
path
"""
try: # RGB
imageio.imwrite(image_path, image)
except Exception: # Greyscale
imageio.imwrite(image_path, image[:, :, 0])
def deepcut_outfn(data, outdir, count, fis, save_data):
# pass count as array to pass it by reference.
if conf.imgDim == 1:
im = data[0][:, :, 0]
else:
im = data[0]
img_name = os.path.join(outdir, 'img_{:06d}.png'.format(count[0]))
imageio.imwrite(img_name, im)
locs = data[1]
bparts = conf.n_classes
for b in range(bparts):
fis[b].write('{}\t{}\t{}\n'.format(count[0], locs[b, 0], locs[b, 1]))
mod_locs = np.insert(np.array(locs), 0, range(bparts), axis=1)
save_data.append([img_name, im.shape, mod_locs])
count[0] += 1
import imageio
import numpy
from secrets import randbelow
SEED = 5
numpy.random.seed(SEED)
pix = numpy.random.randint(256, size=(10, 10, 3))
pic = imageio.imwrite("randomii.png", pix.astype(numpy.uint8))
A = numpy.array([1, 2, 3, 4])
B = numpy.array([1, 2, 3, 4])
C = numpy.divide(A, 2)
print(C)
#Imageio 是一个读写照片数据，包括动态图，video,volumetric data,and scientific formats的库，
########example
##https://imageio.readthedocs.io/en/latest/examples.html
import imageio
im = imageio.imread('imageio:chelsea.png') # read a standard image
im.shape # im is a numpy array
(300, 451, 3)
imageio.imwrite('~/chelsea-gray.jpg', im[:, :, 0])
###
import imageio
reader = imageio.get_reader('imageio:cockatoo.mp4')
for i, im in enumerate(reader):
print('Mean of frame %i is %1.1f' % (i, im.mean()))
#使用imageio 制作动图
import imageio
def create_gif(image_list, gif_name):
frames = []
for image_name in image_list:
frames.append(imageio.imread(image_name))
# Save them as frames into a gif
imageio.mimsave(gif_name, frames, 'GIF', duration=0.5)
return
def main():
image_list = glob.glob(r"D:\pythonrun\20180504rnn\*.jpg")
print(image_list)
with torch.no_grad():
image, _, _ = render_image(width, height, focal, pose, render_near,
render_far, coarse_model, fine_model,
render_coarse_sample_num,
render_fine_sample_num)
demo_images.append(image)
demo_targets.append(target[..., :3])
for pose, target in zip(poses['val']['in'][:2], images['val']['in'][:2]):
with torch.no_grad():
image, _, _ = render_image(width, height, focal, pose, render_near,
render_far, coarse_model, fine_model,
render_coarse_sample_num,
render_fine_sample_num)
demo_images.append(image)
demo_targets.append(target[..., :3])
for pose, target in zip(poses['val']['ex'][:2], images['val']['ex'][:2]):
with torch.no_grad():
image, _, _ = render_image(width, height, focal, pose, render_near,
render_far, coarse_model, fine_model,
render_coarse_sample_num,
render_fine_sample_num)
demo_images.append(image)
demo_targets.append(target[..., :3])
demo_image_path = os.path.join(log_path, 'demo.jpg')
demo_image = np.concatenate(
[np.concatenate(demo_images, 1),
np.concatenate(demo_targets, 1)], 0)
imageio.imwrite(demo_image_path, to8b(demo_image))
print('Demo image write to:', demo_image_path)
8: [244, 35, 232], # Sidewalks
9: [107, 142, 35], # Vegetation
10: [0, 0, 255], # Vehicles
11: [102, 102, 156], # Walls
12: [220, 220, 0] # TrafficSigns
}
depth_seg = imageio.imread(file)
# Build a blank image
result = np.zeros((depth_seg.shape[0], depth_seg.shape[1], 3))
# Person
result[np.where(depth_seg[:, :, 0] == 4)] = [255, 0, 0]
# Combine road and roadlines
result[np.where(depth_seg[:, :, 0] == 6)] = [0, 255, 0]
result[np.where(depth_seg[:, :, 0] == 7)] = [0, 255, 0]
# Car and remove car hood
result[np.where(depth_seg[:490, :, 0] == 10)] = [0, 0, 255]
return result.astype(np.uint8)
# Sem seg
total_num = 0
for i, file in enumerate(glob(seg_path)):
file_name = os.path.basename(file)
result = labels_to_seg2(file)
imageio.imwrite(seg_out_dir + '/' + file_name, result, format='png')
total_num += 1
print(total_num, "images has been processed.")
print(tf.__version__)
# tfds works in both Eager and Graph modes
tf.enable_eager_execution()
# tf_flowers total = 3,670
# img_dim = 50
# See available datasets
print(tfds.list_builders())
class_names = ['dandelion', 'daisy', 'tulips', 'sunflowers', 'roses']
ds_all = tfds.load(name="tf_flowers", split="train")
# ds_all = ds_all.shuffle(buffer_size=100)
iterator = ds_all.make_one_shot_iterator()
for i in range(3670):
if i % 100 == 0:
print("processing " + str(i))
mnist_example = iterator.get_next()
# mnist_example, = ds_all.take(1)
image, label = mnist_example["image"], mnist_example["label"]
image = image / 255
image = tf.image.resize_images(image, (img_dim, img_dim))
# image = image.reshape(1, 50, 50)
# image = image_fit.resize_to_fit(image, 12, 22)
# image = tf.image.rgb_to_grayscale(image)
label_name = label_number_to_name(label)
imageio.imwrite(imgs_folder + "/" + label_name + "/" + str(i) + ".jpg",
image)
import cv2
import imageio
imageio.plugins.ffmpeg.download()
# Cascade yükleme
face_cascade = cv2.CascadeClassifier('haarcascade-frontalface-default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascade-eye.xml')
# Tanıma yapacak fonksiyon
def detect(frame):
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
roi_gray = gray[y:y + h, x:x + w]
roi_color = frame[y:y + h, x:x + w]
eyes = eye_cascade.detectMultiScale(roi_gray, 1.1, 3)
for (ex, ey, ew, eh) in eyes:
cv2.rectangle(roi_color, (ex, ey), (ex + ew, ey + eh), (0, 255, 0),
2)
return frame
# Proje klasörü içerisindeki image.jpg dosyasında yüz ve göz tesbiti yapılıyor.
# Daha sonra output.jpg dosyasına yazılıyor.
# Dosya isimlerini değiştirebilirsiniz.
image = imageio.imread('2.jpeg')
image = detect(frame=image)
imageio.imwrite('output.png', image)
#plt.imshow(full_inputs_test[i+n])
'''
current_directory = os.getcwd()
final_directory = os.path.join(current_directory, r'cnn_train')
if not os.path.exists(final_directory):
os.makedirs(final_directory)
for i in range(n):
test_directory = os.path.join(final_directory,
r'cnn_train' + str(i) + '/')
#test_directory = os.path.join(final_directory, r'test'+str(i+n) +'/')
if not os.path.exists(test_directory):
os.makedirs(test_directory)
imwrite(
str(test_directory) + 'pred_mask.png',
(np.clip(combined_masks[i], 0, 1) * 255).astype(np.uint8))
imwrite(
str(test_directory) + 'input.png',
(combined_input[i] * 255).astype(np.uint8))
imwrite(
str(test_directory) + 'pred_mask_TH.png',
(thresh_masks[i] * 255).astype(np.uint8))
imwrite(
str(test_directory) + 'GT_mask.png',
(combined_GT_masks[i] * 255).astype(np.uint8))
n = 15
n_patches = n * (512 // roi)**2
test_mask = sess.run(pred_mask_test,
def make_efficient_example(ex):
image_relpath = ex.image_path
max_rotate = np.pi / 6
padding_factor = 1 / 0.85
scale_up_factor = 1 / 0.85
scale_down_factor = 1 / 0.85
shift_factor = 1.2
base_dst_side = 256
box_center = boxlib.center(ex.bbox)
s, c = np.sin(max_rotate), np.cos(max_rotate)
w, h = ex.bbox[2:]
rot_bbox_side = max(c * w + s * h, c * h + s * w)
rot_bbox = boxlib.box_around(box_center, rot_bbox_side)
scale_factor = min(base_dst_side / np.max(ex.bbox[2:]) * scale_up_factor,
1)
expansion_factor = padding_factor * shift_factor * scale_down_factor
expanded_bbox = boxlib.expand(rot_bbox, expansion_factor)
expanded_bbox = boxlib.intersect(expanded_bbox,
np.array([0, 0, 2048, 2048]))
new_camera = ex.camera.copy()
new_camera.intrinsic_matrix[:2, 2] -= expanded_bbox[:2]
new_camera.scale_output(scale_factor)
new_camera.undistort()
dst_shape = improc.rounded_int_tuple(scale_factor * expanded_bbox[[3, 2]])
new_im_relpath = ex.image_path.replace('3dhp', f'3dhp_downscaled')
new_im_path = os.path.join(paths.DATA_ROOT, new_im_relpath)
if not (util.is_file_newer(new_im_path, "2019-11-14T23:32:07")
and improc.is_image_readable(new_im_path)):
im = improc.imread_jpeg(f'{paths.DATA_ROOT}/{image_relpath}')
new_im = cameralib.reproject_image(im, ex.camera, new_camera,
dst_shape)
util.ensure_path_exists(new_im_path)
imageio.imwrite(new_im_path, new_im)
new_bbox_topleft = cameralib.reproject_image_points(
ex.bbox[:2], ex.camera, new_camera)
new_bbox = np.concatenate([new_bbox_topleft, ex.bbox[2:] * scale_factor])
mask_rle_relpath = new_im_path.replace('Images', 'FGmaskImages').replace(
'.jpg', '.pkl')
mask_rle_path = os.path.join(paths.DATA_ROOT, mask_rle_relpath)
if util.is_file_newer(mask_rle_path, "2020-03-11T20:46:46"):
mask_runlength = util.load_pickle(mask_rle_path)
else:
mask_relpath = ex.image_path.replace('Images', 'FGmaskImages').replace(
'.jpg', '.png')
mask = imageio.imread(os.path.join(paths.DATA_ROOT, mask_relpath))
mask_reproj = cameralib.reproject_image(mask, ex.camera, new_camera,
dst_shape)
mask_runlength = get_mask_with_highest_iou(mask_reproj, new_bbox)
util.dump_pickle(mask_runlength, mask_rle_path)
return p3ds.Pose3DExample(new_im_relpath,
ex.world_coords,
new_bbox,
new_camera,
mask=mask_runlength,
univ_coords=ex.univ_coords)
def save_image(rgb):
imageio.imwrite('rgb.jpg', rgb)
X = torch.cat([
torch.zeros(1,3,360,420),
X,
torch.zeros(1,3,360,420)
], axis=0).unsqueeze(0).cuda()
else:
im1 = to_tensor(Image.open(os.path.join(folderpath, 'frame09.png')))
im2 = to_tensor(Image.open(os.path.join(folderpath, 'frame10.png')))
im3 = to_tensor(Image.open(os.path.join(folderpath, 'frame11.png')))
im4 = to_tensor(Image.open(os.path.join(folderpath, 'frame12.png')))
X = torch.stack([im1, im2, im3, im4]).unsqueeze(0).cuda()
y_hat = model(X).clamp(0,1).mul(255).cpu().detach().int().squeeze(0).permute(1,2,0)
y_hat = y_hat.numpy().astype(np.uint8)
print(seq)
t1 = time.time()
output_folder_sequence = os.path.join(OUTPUT_FOLDER, seq)
os.makedirs(output_folder_sequence, exist_ok=True)
imageio.imwrite(os.path.join(output_folder_sequence, f'frame10i11.png'), im=y_hat)
if seq=='Urban':
print(f'Running time Urban: {t1-t0} seconds')
# Normalization
max_value = img_slice.max()
img_slice = img_slice / max_value
img_slice = img_slice * 255;
img_slice_uint8 = img_slice.astype(np.uint8)
nii_filename = input_full_filename
#extract_all_slices_to_png(nii_filename)
"""
#TESTE 2
# Saving image
"""
import imageio as iio
iio.imwrite('teste.png',img_slice_uint8)
print('Forma da matriz de dados da imagem adni: ' + repr(adni_img_data.shape))
print('\nTipo da variavel img_slice: ' + repr(type(img_slice)))
print('png file full path: ' + repr(png_full_filename))
#png_img = Image.fromarray(img_slice)
#png_img.save("adni_png.jpeg")
#plt.imsave('adni.png',png_img)
print('Tipo de dados do array img_slice: ' + repr(type(img_slice)))
def visualize(epoch_id,
machine_steering,
out_dir,
perform_smoothing=False,
verbose=False,
verbose_progress_step=100,
frame_count_limit=None):
epoch_dir = params.data_dir
human_steering = get_human_steering(epoch_id)
assert len(human_steering) == len(machine_steering)
# testing: artificially magnify steering to test steering wheel visualization
# human_steering = list(np.array(human_steering) * 10)
# machine_steering = list(np.array(machine_steering) * 10)
# testing: artificially alter machine steering to test that the disagreement coloring is working
# delta = 0
# for i in xrange(len(machine_steering)):
# delta += random.uniform(-1, 1)
# machine_steering[i] += delta
if perform_smoothing:
machine_steering = list(smooth(np.array(machine_steering)))
steering_min = min(np.min(human_steering), np.min(machine_steering))
steering_max = max(np.max(human_steering), np.max(machine_steering))
assert os.path.isdir(epoch_dir)
# use mp4 instead of mkv
# front_vid_path = join_dir(epoch_dir, 'epoch{:0>2}_front.mkv'.format(epoch_id))
vid_mp4_path = join_dir(epoch_dir,
'epoch{:0>2}_front.mp4'.format(epoch_id))
assert os.path.isfile(vid_mp4_path)
dash_vid_path = join_dir(epoch_dir,
'epoch{:0>2}_dash.mkv'.format(epoch_id))
dash_exists = os.path.isfile(dash_vid_path)
# front_cap = cv2.VideoCapture(front_vid_path)
dash_cap = cv2.VideoCapture(dash_vid_path) if dash_exists else None
assert os.path.isdir(out_dir)
vid_size = video_resolution_to_size('720p', width_first=True)
# out_path = join_dir(out_dir, 'epoch{:0>2}_human_machine.mkv'.format(epoch_id))
# vw = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc('X','2','6','4'), 30, vid_size)
w, h = vid_size
# -----------------using imageio read/write video---------------------------------#
import imageio
out_path_mp4 = join_dir(out_dir,
'epoch{:0>2}_human_machine.mp4'.format(epoch_id))
reader = imageio.get_reader(vid_mp4_path, 'ffmpeg')
video_fps = reader.get_meta_data()['fps']
writer = imageio.get_writer(out_path_mp4, fps=video_fps)
# --------------------------------------------------------------------------------#
# for f_cur in xrange(len(machine_steering)):
for f_cur in range(len(machine_steering)):
if (f_cur != 0) and (f_cur % verbose_progress_step == 0):
print('completed {} of {} frames'.format(f_cur,
len(machine_steering)))
if (frame_count_limit is not None) and (f_cur >= frame_count_limit):
break
# rret, rimg = front_cap.read()
# assert rret
rimg = reader.get_data(f_cur)
if dash_exists:
dret, dimg = dash_cap.read()
assert dret
else:
dimg = rimg.copy()
dimg[:] = (0, 0, 0)
ry0, rh = 80, 500
dimg = dimg[100:, :930]
dimg = cv2_resize_by_height(dimg, h - rh)
fimg = rimg.copy()
fimg[:] = (0, 0, 0)
fimg[:rh] = rimg[ry0:ry0 + rh]
dh, dw = dimg.shape[:2]
fimg[rh:, :dw] = dimg[:]
########################## plot ##########################
plot_size = (500, dh)
win_before, win_after = 150, 150
xx, hh, mm = [], [], []
# for f_rel in xrange(-win_before, win_after+1):
for f_rel in range(-win_before, win_after + 1):
f_abs = f_cur + f_rel
if f_abs < 0 or f_abs >= len(machine_steering):
continue
xx.append(f_rel / 30)
hh.append(human_steering[f_abs])
mm.append(machine_steering[f_abs])
fig = plt.figure()
axis = fig.add_subplot(1, 1, 1)
steering_range = max(abs(steering_min), abs(steering_max))
#ylim = [steering_min, steering_max]
ylim = [-steering_range, steering_range]
# ylim[0] = min(np.min(hh), np.min(mm))
# ylim[1] = max(np.max(hh), np.max(mm))
axis.set_xlabel('Current Time (secs)')
axis.set_ylabel('Steering Angle')
axis.axvline(x=0, color='k', ls='dashed')
axis.plot(xx, hh)
axis.plot(xx, mm)
axis.set_xlim([-win_before / 30, win_after / 30])
axis.set_ylim(ylim)
#axis.set_ylabel(y_label, fontsize=18)
axis.label_outer()
#axes.append(axis)
buf = io.BytesIO()
# http://stackoverflow.com/a/4306340/627517
sx, sy = plot_size
sx, sy = round(sx / 100, 1), round(sy / 100, 1)
fig.set_size_inches(sx, sy)
fig.tight_layout()
fig.savefig(buf, format="png", dpi=100)
buf.seek(0)
buf_img = PIL.Image.open(buf)
pimg = np.asarray(buf_img)
plt.close(fig)
pimg = cv2.resize(pimg, plot_size)
pimg = pimg[:, :, :3]
ph, pw = pimg.shape[:2]
pimg = 255 - pimg
fimg[rh:, -pw:] = pimg[:]
####################### human steering wheels ######################
wimg = imread(os.path.abspath("images/wheel-tesla-image-150.png"),
cv2.IMREAD_UNCHANGED)
human_wimg = rotate_image(wimg, -human_steering[f_cur])
wh, ww = human_wimg.shape[:2]
fimg = overlay_image(fimg,
human_wimg,
y_offset=rh + 50,
x_offset=dw + 60)
####################### machine steering wheels ######################
disagreement = abs(machine_steering[f_cur] - human_steering[f_cur])
machine_wimg = rotate_image(wimg, -machine_steering[f_cur])
red_machine_wimg = machine_wimg.copy()
green_machine_wimg = machine_wimg.copy()
red_machine_wimg[:, :, 2] = 255
green_machine_wimg[:, :, 1] = 255
#r = disagreement / (steering_max - steering_min)
max_disagreement = 10
r = min(1., disagreement / max_disagreement)
g = 1 - r
assert r >= 0
assert g <= 1
machine_wimg = cv2.addWeighted(red_machine_wimg, r, green_machine_wimg,
g, 0)
wh, ww = machine_wimg.shape[:2]
fimg = overlay_image(fimg,
machine_wimg,
y_offset=rh + 50,
x_offset=dw + 260)
####################### text ######################
timg_green_agree = imread(
os.path.abspath("images/text-green-agree.png"),
cv2.IMREAD_UNCHANGED)
timg_ground_truth = imread(
os.path.abspath("images/text-ground-truth.png"),
cv2.IMREAD_UNCHANGED)
timg_learned_control = imread(
os.path.abspath("images/text-learned-control.png"),
cv2.IMREAD_UNCHANGED)
timg_red_disagree = imread(
os.path.abspath("images/text-red-disagree.png"),
cv2.IMREAD_UNCHANGED)
timg_tesla_control_autopilot = imread(
os.path.abspath("images/text-tesla-control-autopilot.png"),
cv2.IMREAD_UNCHANGED)
timg_tesla_control_human = imread(
os.path.abspath("images/text-tesla-control-human.png"),
cv2.IMREAD_UNCHANGED)
fimg = overlay_image(fimg,
timg_tesla_control_autopilot,
y_offset=rh + 8,
x_offset=dw + 83)
fimg = overlay_image(fimg,
timg_learned_control,
y_offset=rh + 8,
x_offset=dw + 256)
fimg = overlay_image(fimg,
timg_ground_truth,
y_offset=rh + 205,
x_offset=dw + 90)
fimg = overlay_image(fimg,
timg_red_disagree,
y_offset=rh + 205,
x_offset=dw + 230)
fimg = overlay_image(fimg,
timg_green_agree,
y_offset=rh + 205,
x_offset=dw + 345)
if (frame_count_limit is not None) and (frame_count_limit == 1):
# cv2.imwrite(out_path.replace('mkv', 'jpg'), fimg)
imageio.imwrite(out_path_mp4.replace('mp4', 'jpg'), fimg)
sys.exit()
writer.append_data(fimg)
# vw.write(fimg)
# front_cap.release()
if dash_exists:
dash_cap.release()
# vw.release()
writer.close()
# transformpict.py
# Author: Sébastien Combéfis
# Version: April 15, 2020
import imageio
import scipy as np
# Opening the tiger picture you can find here:
# https://www.flickr.com/photos/31004716@N00/3732644607
# The returned ndarray has three dimensions: the width, the height and
# the number of layers (3 for RGB picture, 4 for RGBA picture, etc.)
im = imageio.imread('tiger.jpg')
# Darkening the picture by dividing the RGB values of each pixel by 2
# and ensuring the value remains in [0; 255]
im = np.maximum(0, im / 2)
# Writing the new picture without forgetting to convert the values
# from float to uint8 (because of the operations previously performed)
imageio.imwrite('tiger-transformed.jpg', im.astype(np.uint8))
import os
import sys
from imageio import imread, imwrite
from skimage.transform import resize
target_dir = './data/aircraft' if len(sys.argv) < 2 else sys.argv[1]
img_size = [84, 84]
_ids = []
for root, dirnames, filenames in os.walk(target_dir):
for filename in filenames:
if filename.endswith(('.jpg', '.webp', '.JPEG', '.png', 'jpeg')):
_ids.append(os.path.join(root, filename))
for i, path in enumerate(_ids):
img = imread(path)
print('{}/{} size: {}'.format(i, len(_ids), img.shape))
imwrite(path, resize(img, img_size))
def receive(self, image):
imageio.imwrite(self._filepath, image)
def runTimings(mode: str):
# CONFIGURATION
SETTINGS_FILE = "../scenes/dvrCassini-scene1.json"
ROOT_PATH = ".."
RESOLUTION = (512, 512)
NUM_FRAMES = 1
VOLUME_RESOLUTION = 128
KERNEL_NAMES = [
("DVR: DDA - fixed step (control points)",
"dvr stepping 0.0001\n(Baseline)", 0.001),
("DVR: Fixed step size - trilinear", "stepping 0.1", 0.1),
("DVR: Fixed step size - trilinear", "stepping 0.01", 0.01),
("DVR: Fixed step size - trilinear", "stepping 0.001", 0.001),
("DVR: DDA - interval simple", "interval - simple", 1),
("DVR: DDA - interval stepping (3)", "interval - stepping-3", 1),
("DVR: DDA - interval trapezoid (2)", "interval - trapezoid-2", 1),
("DVR: DDA - interval trapezoid (4)", "interval - trapezoid-4", 1),
("DVR: DDA - interval trapezoid (10)", "interval - trapezoid-10", 1),
("DVR: DDA - interval Simpson (2)", "interval - Simpson-2", 1),
("DVR: DDA - interval Simpson (4)", "interval - Simpson-4", 1),
("DVR: DDA - interval Simpson (10)", "interval - Simpson-10", 1),
("DVR: DDA - interval Simpson adapt",
"interval - Simpson-adaptive e-3", 1e-3 * VOLUME_RESOLUTION),
("DVR: DDA - interval Simpson adapt",
"interval - Simpson-adaptive e-5", 1e-5 * VOLUME_RESOLUTION),
#("DVR: DDA - interval trapezoid var", "interval - trapezoid-var 0.1", 0.1),
#("DVR: DDA - interval trapezoid var", "interval - trapezoid-var 0.01", 0.01),
#("DVR: DDA - interval trapezoid var", "interval - trapezoid-var 0.001", 0.001),
("DVR: Marching Cubes", "marching cubes 1", 1 / 1 - 0.001
), # number of subdivisions
("DVR: Marching Cubes", "marching cubes 2", 1 / 2 - 0.001),
("DVR: Marching Cubes", "marching cubes 4", 1 / 4 - 0.001),
("DVR: Marching Cubes", "marching cubes 8", 1 / 8 - 0.001),
("DVR: Marching Cubes", "marching cubes 16", 1 / 16 - 0.001),
]
DENSITY_STEPS = 7
MIN_DENSITY_DIFFERENCE = 0.005 # minimal difference between min and max density
TIMING_STEPS = 50
OUTPUT_STATS_ALL = "../results/statistics/dvr-cassini/timings-all-%s.tsv"
OUTPUT_STATS_AVG = "../results/statistics/dvr-cassini/timings-avg-%s.tsv"
OUTPUT_HISTO_ALL = "../results/statistics/dvr-cassini/histograms-%s.tsv"
OUTPUT_HISTO_CFG = "../results/statistics/dvr-cassini/histogram-cfg-%s.tsv"
OUTPUT_STATS_USE_DOUBLE = False
OUTPUT_IMAGE_PATH = "../results/statistics/dvr-cassini/images/"
OUTPUT_INSTRUMENTATION = "../results/statistics/dvr-cassini/instrumentation.tsv"
HISTO_NUM_BINS = 100
HISTO_BIN_MIN = np.log10(1e-6)
HISTO_BIN_MAX = np.log10(1)
HISTO_BIN_EDGES = [0.0] + list(10**np.linspace(
HISTO_BIN_MIN, HISTO_BIN_MAX, HISTO_NUM_BINS))
print("histogram bins:", HISTO_BIN_EDGES)
pyrenderer.oit.set_fragment_buffer_size(2**26)
pyrenderer.oit.set_marching_cubes_mode(
pyrenderer.oit.MarchingCubesComputationMode.OnTheFly)
pyrenderer.oit.set_max_fragments_per_pixel(256)
pyrenderer.oit.set_tile_size(256)
os.makedirs(OUTPUT_IMAGE_PATH, exist_ok=True)
# load settings file
rendererArgs, camera, volumePath = pyrenderer.load_from_json(
SETTINGS_FILE, ROOT_PATH)
print("settings loaded")
rendererArgs.width = RESOLUTION[0]
rendererArgs.height = RESOLUTION[1]
base_min_density = rendererArgs.min_density
base_max_density = rendererArgs.max_density
base_opacity = rendererArgs.opacity_scaling
# create density+opacity test cases
end_max_density = 0.5 * (base_min_density +
base_max_density) + MIN_DENSITY_DIFFERENCE
max_densities = np.power(
10,
np.linspace(np.log10(base_max_density), np.log10(end_max_density),
DENSITY_STEPS))
scaling = (base_max_density - base_min_density) / (max_densities -
base_min_density)
end_min_density = 0.5 * (base_min_density +
base_max_density) - MIN_DENSITY_DIFFERENCE
min_densities = np.log10(
np.linspace(np.power(10, base_min_density),
np.power(10, end_min_density), DENSITY_STEPS))
scaling = (base_max_density - base_min_density) / (max_densities -
min_densities)
opacities = base_opacity * scaling
print("min_densities:", min_densities)
print("max_densities:", max_densities)
print("opacities:", opacities)
# create volume
print("Create Marschner Lobb")
volume = pyrenderer.Volume.create_implicit(
pyrenderer.ImplicitEquation.Cassini, VOLUME_RESOLUTION)
print("Loaded volumed of resolution", volume.resolution, "and world size",
volume.world_size)
volume.copy_to_gpu()
# allocate timing
timer = pyrenderer.GpuTimer()
times = [[None] * DENSITY_STEPS for i in range(len(KERNEL_NAMES))]
if mode == "visualize":
# allocate output
pyrenderer.reload_kernels(enableDebugging=False,
enableInstrumentation=False)
output = pyrenderer.allocate_output(rendererArgs.width,
rendererArgs.height,
rendererArgs.render_mode)
outputs = [[None] * DENSITY_STEPS for i in range(len(KERNEL_NAMES))]
# render
camera.update_render_args(rendererArgs)
for j, (kernel_name, _, stepsize) in enumerate(KERNEL_NAMES):
print("Render", kernel_name, stepsize)
rendererArgs.stepsize = stepsize
for i in range(DENSITY_STEPS):
rendererArgs.min_density = min_densities[i]
rendererArgs.max_density = max_densities[i]
rendererArgs.opacity_scaling = opacities[i]
timer.start()
pyrenderer.render(kernel_name, volume, rendererArgs, output)
timer.stop()
outputs[j][i] = np.array(output.copy_to_cpu())
times[j][i] = timer.elapsed_ms()
def slugify(value):
"""
Normalizes string, converts to lowercase, removes non-alpha characters,
and converts spaces to hyphens.
"""
import unicodedata
import re
value = str(unicodedata.normalize(
'NFKD', value)) #.encode('ascii', 'ignore'))
value = re.sub('[^\w\s-]', '', value).strip().lower()
value = re.sub('[-\s]+', '-', value)
return value
# visualize
print("Visualize")
#fig, axes = plt.subplots(nrows=len(KERNEL_NAMES), ncols=DENSITY_STEPS)
for j, (kernel_name, human_kernel_name, _) in enumerate(KERNEL_NAMES):
for i in range(DENSITY_STEPS):
filename = os.path.join(
OUTPUT_IMAGE_PATH,
slugify("%s__%d" % (human_kernel_name, i)) + ".png")
imageio.imwrite(filename, outputs[j][i][:, :, 0:4])
#axes[j][i].imshow(outputs[j][i][:,:,0:4])
#axes[j][i].set_title("time=%.2fms"%times[j][i])
#if j==len(KERNEL_NAMES)-1:
# axes[j][i].set_xlabel("range=%.3f"%(
# max_densities[i]-base_min_density))
#if i==0:
# axes[j][i].set_ylabel(human_kernel_name)
# save to numpy
npz_output = {}
npz_output['kernels'] = KERNEL_NAMES
npz_output['densities'] = [
max_densities[i] - base_min_density for i in range(DENSITY_STEPS)
]
for j in range(len(KERNEL_NAMES)):
for i in range(DENSITY_STEPS):
npz_output['img_%d_%d' % (j, i)] = outputs[j][i]
np.savez(os.path.join(OUTPUT_IMAGE_PATH, "raw.npz"), **npz_output)
#plt.subplots_adjust(left=0.03, bottom=0.05, right=0.99, top=0.97, wspace=0.20, hspace=0.23)
#plt.show()
elif mode == "measure":
summed_times = [[0] * DENSITY_STEPS for i in range(len(KERNEL_NAMES))]
pyrenderer.reload_kernels(enableDebugging=False,
enableInstrumentation=False,
otherPreprocessorArguments=[
"-DKERNEL_USE_DOUBLE=%s" %
("1" if OUTPUT_STATS_USE_DOUBLE else "0")
])
# allocate output for baseline
output = pyrenderer.allocate_output(rendererArgs.width,
rendererArgs.height,
rendererArgs.render_mode)
outputs = [[None] * TIMING_STEPS for i in range(DENSITY_STEPS)]
histograms = [[
np.zeros(HISTO_NUM_BINS, dtype=np.int64)
for i in range(DENSITY_STEPS)
] for j in range(len(KERNEL_NAMES))]
# render and write output
with open(
OUTPUT_STATS_ALL %
("double" if OUTPUT_STATS_USE_DOUBLE else "float"), "w") as f:
f.write("Kernel Name\tTF-Range\tFrame\tTime (ms)\tPSNR (dB)\n")
for j, (kernel_name, human_kernel_name,
stepsize) in enumerate(KERNEL_NAMES):
print("Render", kernel_name, stepsize)
rendererArgs.stepsize = stepsize
for i in range(DENSITY_STEPS):
rendererArgs.min_density = min_densities[i]
rendererArgs.max_density = max_densities[i]
rendererArgs.opacity_scaling = opacities[i]
histogram = histograms[j][i]
histogram_edges = None
for k in range(TIMING_STEPS):
camera.yaw = k * 360 / TIMING_STEPS
camera.update_render_args(rendererArgs)
timer.start()
pyrenderer.render(kernel_name, volume, rendererArgs,
output)
timer.stop()
out_img = np.array(output.copy_to_cpu())
if j == 0: # baseline
outputs[i][k] = out_img
psnr = 0
else:
# compute psnr
maxValue = np.max(outputs[i][k][:, :, 0:4])
mse = ((outputs[i][k][:, :, 0:4] -
out_img[:, :, 0:4])**2).mean(axis=None)
psnr = 20 * np.log10(maxValue) - 10 * np.log10(mse)
# compute histogram
diff = outputs[i][k][:, :, 0:4] - out_img[:, :,
0:4]
new_histogram, histogram_edges = np.histogram(
diff, bins=HISTO_BIN_EDGES)
histogram += new_histogram
t = timer.elapsed_ms()
summed_times[j][i] += t
f.write(
"%s\t%.4f\t%d\t%.4f\t%.4f\n" %
(human_kernel_name.replace("\n", " "),
max_densities[i] - base_min_density, k, t, psnr))
# write average stats
with open(
OUTPUT_STATS_AVG %
("double" if OUTPUT_STATS_USE_DOUBLE else "float"), "w") as f:
f.write("Kernel Name\tTF-Range\tAvg-Time (ms)\n")
for j, (_, human_kernel_name, _) in enumerate(KERNEL_NAMES):
for i in range(DENSITY_STEPS):
f.write("%s\t%.4f\t%.4f\n" %
(human_kernel_name.replace("\n", " "),
max_densities[i] - base_min_density,
summed_times[j][i] / TIMING_STEPS))
# write histograms
with open(
OUTPUT_HISTO_ALL %
("double" if OUTPUT_STATS_USE_DOUBLE else "float"), "w") as f:
f.write("BinStart\tBinEnd")
for j in range(len(KERNEL_NAMES)):
for i in range(DENSITY_STEPS):
f.write("\t%d-%d" % (j, i))
f.write("\n")
for b in range(HISTO_NUM_BINS):
f.write("%.10f\t%.10f" %
(HISTO_BIN_EDGES[b], HISTO_BIN_EDGES[b + 1]))
for j in range(len(KERNEL_NAMES)):
for i in range(DENSITY_STEPS):
f.write("\t%d" % histograms[j][i][b])
f.write("\n")
with open(
OUTPUT_HISTO_CFG %
("double" if OUTPUT_STATS_USE_DOUBLE else "float"), "w") as f:
f.write("Kernel Name\tTF-Range\tConfig-ID\n")
for j, (_, human_kernel_name, _) in enumerate(KERNEL_NAMES):
for i in range(DENSITY_STEPS):
f.write("%s\t%.4f\t%s\n" %
(human_kernel_name.replace("\n", " "),
max_densities[i] - base_min_density, "%d-%d" %
(j, i)))
elif mode == "instrumentation":
# recompile with instrumentation
pyrenderer.reload_kernels(enableInstrumentation=True)
# allocate output
output = pyrenderer.allocate_output(rendererArgs.width,
rendererArgs.height,
rendererArgs.render_mode)
outputs = [[None] * DENSITY_STEPS for i in range(len(KERNEL_NAMES))]
fields = [
"densityFetches", "tfFetches", "ddaSteps", "isoIntersections",
"intervalEval", "intervalStep", "intervalMaxStep"
]
# render
with open(OUTPUT_INSTRUMENTATION, "w") as f:
f.write(
"Kernel Name\tTF-Range\t%s\tavgIntervalSteps\tnumTriangles\tnumFragments\n"
% "\t".join(fields))
camera.update_render_args(rendererArgs)
for j, (kernel_name, human_kernel_name,
stepsize) in enumerate(KERNEL_NAMES):
print("Render", kernel_name, stepsize)
rendererArgs.stepsize = stepsize
for i in range(DENSITY_STEPS):
rendererArgs.min_density = min_densities[i]
rendererArgs.max_density = max_densities[i]
rendererArgs.opacity_scaling = opacities[i]
instrumentations, globalInstrumentations = \
pyrenderer.render_with_instrumentation(
kernel_name, volume, rendererArgs, output)
f.write("%s\t%s" % (human_kernel_name.replace(
"\n", " "), max_densities[i] - base_min_density))
for field in fields:
f.write(
"\t%.2f" %
np.mean(instrumentations[field], dtype=np.float32))
avgIntervalSteps = np.mean(
instrumentations["intervalStep"].astype(np.float32) /
instrumentations["intervalEval"].astype(np.float32))
f.write(
"\t%.2f\t%d\t%d\n" %
(avgIntervalSteps, globalInstrumentations.numTriangles,
globalInstrumentations.numFragments))
f.flush()
# input_folder = "/home/koosk/data/images/adipocyte/dataset/60x-nuclei_thresholded"
# output_folder = "/home/koosk/data/images/adipocyte/dataset/60x-nuclei_thresholded-tiled"
# input_folder = "/home/koosk/data/images/adipocyte/nuclei_mask-20x"
# input_folder = "/home/koosk/data/images/adipocyte/nuclei_mask-20x-tiled"
tile_size = 512
if __name__ == '__main__':
os.makedirs(output_folder, exist_ok=True)
files = listdir(input_folder)
for file in files:
input_file = join(input_folder, file)
if not isfile(input_file):
continue
img = imageio.imread(input_file).astype(np.float32)
img = img - np.min(img)
img = img / np.max(img) * 255
img = img.astype('uint8')
im_bname = os.path.basename(input_file)
imshape = (np.shape(img))
im_name = im_bname[:-4]
im_ext = im_bname[-3:]
tile_counter = 0
for i in range(0, imshape[0] - tile_size + 1, tile_size):
for j in range(0, imshape[1] - tile_size + 1, tile_size):
tile_counter += 1
img_tile = img[i:i + tile_size, j:j + tile_size]
tile_fname = join(
output_folder,
im_name + "-tile-%03d" % tile_counter + ".png")
imageio.imwrite(tile_fname, img_tile, "png")
optmize_Com.zero_grad()
if opt.feature_loss == True:
vgg_loss = VGG_loss(generated_img,input_label)
else:
vgg_loss = 0
mse_loss = Critiretion(generated_img, input_label)
Com_loss = vgg_loss + alpha * mse_loss + mu / 2.0 * torch.norm(latent_vector - Z + eta, 2) ** 2 / \
latent_vector.shape[0]
Com_loss.backward()
optmize_Com.step()
with torch.no_grad():
Z = Quantizer(latent_vector + eta, "Hard")
eta = eta + latent_vector - Z
generated_img = model.netDecoder(Quantizer(latent_vector, "Hard"))
for index in range(input_label.shape[0]):
gen_img = generated_img[index].detach().cpu().numpy()
org_img = input_label[index].detach().cpu().numpy()
gen_img = gen_img * 0.5 - 0.5
org_img = org_img * 0.5 - 0.5
gen_img = np.exp(10 * (gen_img))
org_img = np.exp(10 * (org_img))
inverse_gen = np.abs(nnls(inverse_matrix, gen_img[0, :, :]))
inverse_org = np.abs(nnls(inverse_matrix, org_img[0, :, :]))
inverse_gen_img = (inverse_gen / np.max(inverse_gen.flatten()) * 65535).astype(np.uint16)
inverse_org_img = (inverse_org / np.max(inverse_org.flatten()) * 65535).astype(np.uint16)
short_path = ntpath.basename(data['path'][index])
name_ = os.path.splitext(short_path)[0]
imageio.imwrite(os.path.join(output_path, name_ + '_syn.png'), inverse_gen_img)
imageio.imwrite(os.path.join(output_path, name_ + '_real.png'), inverse_org_img)
res = yolo_detection.detect_imgs(pkllist, nms=0, thresh=0.25)
detect_end = time.time()
print('total detect: {:.4f}s'.format(detect_end - detect_begin))
# nms
nms_begin = time.time()
boxes, classes, scores = dsnms(res)
nms_end = time.time()
print('total nms: {:.4f}s'.format(nms_end - nms_begin))
# save&visualization
save_begin = time.time()
PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')
NUM_CLASSES = 80
if not os.path.exists('video/output'):
os.makedirs('video/output')
for i, image_path in enumerate(pkllist):
image_process = get_labeled_image(image_path, PATH_TO_LABELS,
NUM_CLASSES, np.array(boxes[i]),
np.array(classes[i]),
np.array(scores[i]))
#plt.imshow(image_process)
#plt.show()
#scipy.misc.imsave('video/output/frame{}.jpg'.format(i), image_process)
#plt.image.imsave('video/output/frame{}.jpg'.format(i), image_process)
imageio.imwrite('video/output/frame{}.jpg'.format(i), image_process)
if i % 100 == 0:
print('finish writing image{}'.format(i))
save_end = time.time()
print('total writing images: {:.4f}s'.format(save_end - save_begin))
def bg_target(queue):
while True:
if not queue.empty():
filename, tensor = queue.get()
if filename is None: break
imageio.imwrite(filename, tensor.numpy())
# get images and extract features
images = []
labels_list = []
landmarks = []
hog_features = []
hog_images = []
for i in range(len(samples)):
try:
if labels[i] in SELECTED_LABELS and nb_images_per_label[
get_new_label(labels[i])] < IMAGES_PER_LABEL:
image = np.fromstring(samples[i], dtype=int, sep=" ").reshape(
(image_height, image_width))
images.append(image)
if SAVE_IMAGES:
imageio.imwrite(category + '/' + str(i) + '.jpg', image)
if GET_HOG_WINDOWS_FEATURES:
features = sliding_hog_windows(image)
f, hog_image = hog(image,
orientations=8,
pixels_per_cell=(16, 16),
cells_per_block=(1, 1),
visualize=True)
hog_features.append(features)
hog_images.append(hog_image)
elif GET_HOG_FEATURES:
features, hog_image = hog(image,
orientations=8,
pixels_per_cell=(16, 16),
cells_per_block=(1, 1),
visualize=True)
def main(argv):
inputfile = r'C:/Users/Samantha/Documents/BIGR_Internship/CT_datasets/luu_nii/image/p_p04_int_04.nii'
outputfile = r'C:/Users/Samantha/Documents/BIGR_Internship/CT_datasets/luu_png/image'
try:
opts, args = getopt.getopt(argv, "hi:o:", ["ifile=", "ofile="])
except getopt.GetoptError:
print('nii2png.py -i <inputfile> -o <outputfile>')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('nii2png.py -i <inputfile> -o <outputfile>')
sys.exit()
elif opt in ("-i", "--input"):
inputfile = arg
elif opt in ("-o", "--output"):
outputfile = arg
print('Input file is ', inputfile)
print('Output folder is ', outputfile)
# set fn as your 4d nifti file
image_array = nibabel.load(inputfile).get_data()
print(len(image_array.shape))
image_array = image_array.astype(float)
########## Uncomment MASK or IMAGE ##########
# MASK The mask of the LITS also contains segmentation of the tumors, so add the following
#image_array[image_array > 0] = 1
# IMAGE
wl = 50
ww2 = 175
image_array[image_array < (wl - ww2)] = (wl - ww2)
image_array[image_array > (wl + ww2)] = (wl + ww2)
image_array = (numpy.maximum(image_array, 0) / image_array.max()) * 255.0
#############################################
# ask if rotate
ask_rotate = input('Would you like to rotate the orientation? (y/n) ')
if ask_rotate.lower() == 'y':
ask_rotate_num = int(input('OK. By 90° 180° or 270°? '))
if ask_rotate_num == 90 or ask_rotate_num == 180 or ask_rotate_num == 270:
print('Got it. Your images will be rotated by {} degrees.'.format(
ask_rotate_num))
else:
print(
'You must enter a value that is either 90, 180, or 270. Quitting...'
)
sys.exit()
elif ask_rotate.lower() == 'n':
print('OK, Your images will be converted it as it is.')
else:
print('You must choose either y or n. Quitting...')
sys.exit()
# if 4D image inputted
if len(image_array.shape) == 4:
# set 4d array dimension values
nx, ny, nz, nw = image_array.shape
# set destination folder
if not os.path.exists(outputfile):
os.makedirs(outputfile)
print("Created ouput directory: " + outputfile)
print('Reading NIfTI file...')
total_volumes = image_array.shape[3]
total_slices = image_array.shape[2]
# iterate through volumes
for current_volume in range(0, total_volumes):
slice_counter = 0
# iterate through slices
for current_slice in range(0, total_slices):
if (slice_counter % 1) == 0:
# rotate or no rotate
if ask_rotate.lower() == 'y':
if ask_rotate_num == 90 or ask_rotate_num == 180 or ask_rotate_num == 270:
print('Rotating image...')
if ask_rotate_num == 90:
data = numpy.rot90(image_array[:, :,
current_slice,
current_volume])
elif ask_rotate_num == 180:
data = numpy.rot90(
numpy.rot90(image_array[:, :,
current_slice,
current_volume]))
elif ask_rotate_num == 270:
data = numpy.rot90(
numpy.rot90(
numpy.rot90(
image_array[:, :, current_slice,
current_volume])))
elif ask_rotate.lower() == 'n':
data = image_array[:, :, current_slice, current_volume]
#alternate slices and save as png
print('Saving image...')
image_name = inputfile[:-4] + "_t" + "{:0>3}".format(
str(current_volume + 1)) + "_z" + "{:0>3}".format(
str(current_slice + 1)) + ".png"
imageio.imwrite(image_name, data)
print('Saved.')
#move images to folder
print('Moving files...')
src = image_name
shutil.move(src, outputfile)
slice_counter += 1
print('Moved.')
print('Finished converting images')
# else if 3D image inputted
elif len(image_array.shape) == 3:
# set 4d array dimension values
nx, ny, nz = image_array.shape
# set destination folder
if not os.path.exists(outputfile):
os.makedirs(outputfile)
print("Created ouput directory: " + outputfile)
print('Reading NIfTI file...')
total_slices = image_array.shape[2]
slice_counter = 0
# iterate through slices
for current_slice in range(0, total_slices):
# alternate slices
if (slice_counter % 1) == 0:
# rotate or no rotate
if ask_rotate.lower() == 'y':
if ask_rotate_num == 90 or ask_rotate_num == 180 or ask_rotate_num == 270:
if ask_rotate_num == 90:
data = numpy.rot90(image_array[:, :,
current_slice])
elif ask_rotate_num == 180:
data = numpy.rot90(
numpy.rot90(image_array[:, :, current_slice]))
elif ask_rotate_num == 270:
data = numpy.rot90(
numpy.rot90(
numpy.rot90(image_array[:, :,
current_slice])))
elif ask_rotate.lower() == 'n':
data = image_array[:, :, current_slice]
#alternate slices and save as png
if (slice_counter % 1) == 0:
print('Saving image...')
image_name = inputfile[:-4] + "_z" + "{:0>3}".format(
str(current_slice + 1)) + ".png"
imageio.imwrite(image_name, data)
print('Saved.')
#move images to folder
print('Moving image...')
src = image_name
shutil.move(src, outputfile)
slice_counter += 1
print('Moved.')
print('Finished converting images')
else:
print('Not a 3D or 4D Image. Please try again.')
lr: learningratevalue
})
if i % (Epochnum * 100) == 0:
epochindex = int(i / (Epochnum * 100))
testaccuracy, outputdata = sess.run([accuracy, back_input],
feed_dict={
x: x_test,
y: y_test
})
costtime = time.time() - currenttime
print(
"EPOCHS: %d, train loss:%f, testing accuracy:%f, elapsed time:%f"
% (epochindex, trainloss, testaccuracy, costtime))
print("cross_e:%f" % cross_e)
testf.write(str(epochindex) + '\t' + str(testaccuracy) + '\r\n')
trainf.write(str(epochindex) + '\t' + str(trainloss) + '\r\n')
timef.write(str(epochindex) + '\t' + str(costtime) + '\r\n')
if (epochindex + 1) % 2 == 0:
print(saveModel(test_path, epochindex))
# output test image
outputdata = np.reshape(outputdata, [10, 28, 28])
resultpath = test_path + "backwardtest_img/"
while not os.path.exists(resultpath):
os.mkdir(resultpath)
for ind in range(10):
imageio.imwrite(
resultpath + 'test%d_%04d.png' % (ind, testindex),
outputdata[ind].astype(np.uint8))
testindex += 1
currenttime = time.time()
cache_lambda1c[0]: batch_lamb1c[0], cache_lambda1c[1]: batch_lamb1c[1],
}
FD= {X: bx}
#start = time.time()
l1a, l1b, l2a, l2b, l3a, l3b, l4a, l4b = sess.run([ cache_l1[0], cache_l1[1], cache_l2[0], cache_l2[1], cache_l3[0], cache_l3[1], cache_l4[0], cache_l4[1]], feed_dict=FD)
im_demo, _ = get_view(im_4_show, by_b1, by_b2, by_b3, by_b4, 0.5, p1, p2, pw, ph, num_grid_cells1, num_grid_cells2, num_anchor_boxes, num_classes)
group_l1=(l1a,l1b)
group_l2=(l2a,l2b)
group_l3=(l3a,l3b)
group_l4=(l4a,l4b)
im_demo2, boxes = get_view(im_4_show, group_l1, group_l2, group_l3, group_l4, 0.5, p1, p2, pw, ph, num_grid_cells1, num_grid_cells2, num_anchor_boxes, num_classes)
full_list.append(im_demo)
full_list2.append(im_demo2)
i+=1
for i in range(len(full_list)):
file_id=str(i)
while len(file_id)<6:
file_id = '0' + file_id
imageio.imwrite(('Images_Export/' + file_id + '.jpg'),full_list2[i])
print("We out here")
im = imageio.imread(path + '1.jpg')
F1 = np.array([[1 / 4, 1 / 4], [1 / 4, 1 / 4]])
F2 = np.array([[1 / 9, 1 / 9, 1 / 9], [1 / 9, 1 / 9, 1 / 9],
[1 / 9, 1 / 9, 1 / 9]])
F3 = np.array([[-1 / 8, -1 / 8, -1 / 8], [-1 / 8, 1, -1 / 8],
[-1 / 8, -1 / 8, -1 / 8]])
F4 = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]])
F = F2 #调整这里选择核
#im = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)#控制转变为灰度图
#im=getim()#调整这里获得构造图像
show(im)
#opencv
tcv = cv2.filter2D(im, -1, F)
print('cv2:')
#print(tcv)
show(tcv)
#我的程序
way = 2 #调整这里选择边缘处理方式，默认为第二种
t = Convolve(im, F, way)
#print(t.shape)
print('my')
#print(t)
show(t)
print('相减')
show(t - tcv)
#保存
iname = '1_' + str(way) + '.jpg'
imageio.imwrite(path + iname, t)
inamecv = '1_' + 'cv.jpg'
imageio.imwrite(path + inamecv, tcv)
def writeImage(imagePath, image):
#raw_input("Press Enter to continue...")
imageio.imwrite(imagePath, image)
t = time.time()
print('save results', flush=True)
# low level plotting
f, ax = plt.subplots(1, 3, sharex=False, sharey=False)
ax[0].imshow(vol_rec[vol_sz[0] // 2, :, :])
ax[1].imshow(vol_rec[:, vol_sz[1] // 2, :])
ax[2].imshow(vol_rec[:, :, vol_sz[2] // 2])
f.tight_layout()
# construct full path for storing the results
recon_path_full = os.path.join(recon_path, 'Walnut{}'.format(walnut_id))
# create the directory in case it doesn't exist yet
if not os.path.exists(recon_path_full):
os.makedirs(recon_path_full)
# Save every slice in the volume as a separate tiff file
orbit_str = 'pos'
for orbit_id in orbits_to_recon:
orbit_str = orbit_str + '{}'.format(orbit_id)
for i in range(vol_sz[0]):
slice_path = os.path.join(
recon_path_full,
'nnls_' + orbit_str + '_iter{}_ass{}_vmm{}_{:06}.tiff'.format(
nb_iter, angluar_sub_sampling, voxel_per_mm, i))
imageio.imwrite(slice_path, vol_rec[i, ...])
print(np.round_(time.time() - t, 3), 'sec elapsed')
def pltImages(self,image,name="plt") :
img=np.transpose(image.type(torch.FloatTensor).numpy(),(0,2,1,3))
imageio.imwrite(name+".png",img.reshape(img.shape[0]*img.shape[1],img.shape[2]*img.shape[3]))
def runMethodTest(destPath, opt, contEncPath, styleEncPath, decPath,
useConcat):
if not os.path.exists(destPath):
os.makedirs(destPath)
data_loader = CreateDataLoader(opt)
dataloader = data_loader.load_data()
dataset_size = len(data_loader)
print('#testing images = %d' % dataset_size)
cont_enc = _EncoderNoa(opt.imageSize)
stl_enc = _EncoderNoa(opt.imageSize)
dec = _DecoderNoa(opt.imageSize, useConcat)
cont_enc.load_state_dict(torch.load(contEncPath))
stl_enc.load_state_dict(torch.load(styleEncPath))
dec.load_state_dict(torch.load(decPath))
if opt.cuda:
# feature_extractor.cuda()
cont_enc.cuda()
stl_enc.cuda()
dec.cuda()
torch.manual_seed(0)
for i, data in enumerate(dataloader, 0):
img1 = data['A']
img2 = data['B']
img12 = data['A2']
img21 = data['B2']
if opt.cuda:
img1 = img1.cuda()
img2 = img2.cuda()
img12 = img12.cuda()
img21 = img21.cuda()
stl1 = stl_enc(img1)
stl2 = stl_enc(img2)
cont1 = cont_enc(img1)
cont2 = cont_enc(img2)
# stl12 = stl_enc(img12)
# stl21 = stl_enc(img21)
# cont12 = cont_enc(img12)
# cont21 = cont_enc(img21)
if (useConcat):
stl1cont2 = torch.cat((stl1, cont2), 1)
stl2cont1 = torch.cat((stl2, cont1), 1)
# stl1cont1 = torch.cat((stl1, cont1), 1)
# stl2cont2 = torch.cat((stl2, cont2), 1)
else:
stl1cont2 = stl1 + cont2
stl2cont1 = stl2 + cont1
# stl1cont1 = stl1 + cont1
# stl2cont2 = stl2 + cont2
dec12 = dec(stl1cont2)
dec21 = dec(stl2cont1)
# dec11 = dec(stl1cont1)
# dec22 = dec(stl2cont2)
if i % 10 == 0:
im1 = util.tensor2im(img1[0])
im2 = util.tensor2im(img2[0])
oim12 = util.tensor2im(img12[0])
oim21 = util.tensor2im(img21[0])
im12 = util.tensor2im(dec12[0])
im21 = util.tensor2im(dec21[0])
imageio.imwrite(
os.path.join(destPath, '%d_style_1_cont_2.png' % (i)), im12)
imageio.imwrite(
os.path.join(destPath, '%d_style_2_cont_1.png' % (i)), im21)
imageio.imwrite(
os.path.join(destPath, '%d_style_1_cont_1_orig.png' % (i)),
im1)
imageio.imwrite(
os.path.join(destPath, '%d_style_2_cont_2_orig.png' % (i)),
im2)
imageio.imwrite(
os.path.join(destPath, '%d_style_1_cont_2_orig.png' % (i)),
oim12)
imageio.imwrite(
os.path.join(destPath, '%d_style_2_cont_1_orig.png' % (i)),
oim21)
def display_instances(strname,
image,
boxes,
masks,
class_ids,
class_names,
scores=None,
title="",
figsize=(16, 16),
ax=None):
"""
boxes: [num_instance, (y1, x1, y2, x2, class_id)] in image coordinates.
masks: [height, width, num_instances]
class_ids: [num_instances]
class_names: list of class names of the dataset
scores: (optional) confidence scores for each box
figsize: (optional) the size of the image.
"""
# Number of instances
# mask=np.zeros([masks.shape[0],masks.shape[1]])
mask = np.zeros([image.shape[0], image.shape[1]])
N = boxes.shape[0]
if not N:
print("\n*** No instances to display *** \n")
else:
assert boxes.shape[0] == masks.shape[-1] == class_ids.shape[0]
if not ax:
_, ax = plt.subplots(1, figsize=figsize)
# Generate random colors
colors = random_colors(N)
# Show area outside image boundaries.
height, width = image.shape[:2]
ax.set_ylim(height + 10, -10)
ax.set_xlim(-10, width + 10)
ax.axis('off')
ax.set_title(title)
masked_image = image.astype(np.uint32).copy()
masked_image1 = masked_image
# mymask=np.zeros(image.shape[:2],np.uint32)
number_of_person = np.sum(class_ids == 1)
jj = 0
for i in range(N):
color = colors[i]
# color = (0,0,0)
# Bounding box
if not np.any(boxes[i]):
# Skip this instance. Has no bbox. Likely lost in image cropping.
continue
y1, x1, y2, x2 = boxes[i]
w = x2 - x1
h = y2 - y1
p = patches.Rectangle((x1, y1),
x2 - x1,
y2 - y1,
linewidth=2,
alpha=0.7,
linestyle="dashed",
edgecolor=color,
facecolor='none')
ax.add_patch(p)
# Label
class_id = class_ids[i]
score = scores[i] if scores is not None else None
label = class_names[class_id]
x = random.randint(x1, (x1 + x2) // 2)
caption = "{} {:.3f}".format(label, score) if score else label
ax.text(x1,
y1 + 8,
caption,
color='w',
size=11,
backgroundcolor="none")
# if class_id==1:
# if w > (image.shape[0]/10) or h > (image.shape[1]/10):
# if score>0.95:
# mask = mask + masks[:, :, i]
# masked_image=apply_mask(masked_image, mask, color)
# jj=jj+1
if class_id == 1:
# if w > (image.shape[0]/10) or h > (image.shape[1]/10):
# if score>0.95:
mask = mask + masks[:, :, i]
masked_image = apply_mask(masked_image, mask, color)
jj = jj + 1
# mask = mask + masks[:, :, i]
# masked_image = apply_mask(masked_image, mask, color)
# Mask Polygon
# Pad to ensure proper polygons for masks that touch image edges.
padded_mask = np.zeros((mask.shape[0] + 2, mask.shape[1] + 2),
dtype=np.uint8)
padded_mask[1:-1, 1:-1] = mask
contours = find_contours(padded_mask, 0.5)
for verts in contours:
# Subtract the padding and flip (y, x) to (x, y)
verts = np.fliplr(verts) - 1
p = Polygon(verts, facecolor="none", edgecolor=color)
ax.add_patch(p)
mymask = mask
# num=str(number_of_person)
num = str(jj)
str1 = strname.replace('.jpg', 'BW.jpg')
# # str1=aa[0]+'BW'+'.jpg'
str2 = num + str1
import imageio
imageio.imwrite(str1, mymask)
return jj
