def test_salt(filename, result_dir):
"""2.3.4 Salt noise and denoising"""
im = Image.open(filename)
def savewith(result, name):
result_path = os.path.join(result_dir, name)
result.save(result_path)
print '[Saved] ' + result_path
# add salt noise with ps=0.2
ps = 0.2
noisy = add_noise(im, 'sap', ps=ps)
savewith(noisy, 'salt-%d.png' % (int(100 * ps)))
# contraharmonic filtering
q_neg, q_pos = 1.5, -1.5
q_neg_name, q_pos_name = [str(q).replace('.', '-')
for q in (q_neg, q_pos)]
# Q < 0
result = contraharmonic_mean(noisy, (3, 3), q_neg)
savewith(result, 'salt-contraharmonic-%s.png' % q_neg_name)
# Q > 0
result = contraharmonic_mean(noisy, (3, 3), q_pos)
savewith(result, 'salt-contraharmonic-%s.png' % q_pos_name)
def test_gauss(filename, result_dir):
"""2.3.3 Guassian noise and denoising"""
im = Image.open(filename)
def savewith(result, name):
result_path = os.path.join(result_dir, name)
result.save(result_path)
print '[Saved] ' + result_path
# generate guassian noise
mean, var = 0, 40
noisy = add_noise(im, 'gauss', mean=mean, var=var)
savewith(noisy, 'gauss-%d-%d.png' % (mean, var))
# arithmetic mean filtering
result = arithmetic_mean(noisy, (3, 3))
savewith(result, 'gauss-arithmetic.png')
# geometric mean filtering
result = geometric_mean(noisy, (3, 3))
savewith(result, 'gauss-geometric.png')
# harmonic mean filtering
result = harmonic_mean(noisy, (3, 3))
savewith(result, 'gauss-harmonic.png')
# contraharmonic mean filtering
result = contraharmonic_mean(noisy, (3, 3), -1.5)
savewith(result, 'gauss-contraharmonic.png')
# median filtering
result = median_filter(noisy, (3, 3))
savewith(result, 'gauss-median.png')
def test_gauss(filename, result_dir):
"""2.3.3 Guassian noise and denoising"""
im = Image.open(filename)
def savewith(result, name):
result_path = os.path.join(result_dir, name)
result.save(result_path)
print '[Saved] ' + result_path
# generate guassian noise
mean, var = 0, 40
noisy = add_noise(im, 'gauss', mean=mean, var=var)
savewith(noisy, 'gauss-%d-%d.png' % (mean, var))
# arithmetic mean filtering
result = arithmetic_mean(noisy, (3, 3))
savewith(result, 'gauss-arithmetic.png')
# geometric mean filtering
result = geometric_mean(noisy, (3, 3))
savewith(result, 'gauss-geometric.png')
# harmonic mean filtering
result = harmonic_mean(noisy, (3, 3))
savewith(result, 'gauss-harmonic.png')
# contraharmonic mean filtering
result = contraharmonic_mean(noisy, (3, 3), -1.5)
savewith(result, 'gauss-contraharmonic.png')
# median filtering
result = median_filter(noisy, (3, 3))
savewith(result, 'gauss-median.png')
def main(input_string):
print('Input Value: ', input_string)
freq_mat = huffman_coding.read_the_freq_matrix()
mapping = huffman_coding.create_mapping(freq_mat)
huffman_encoded_value = huffman_coding.perform_huffman_coding(
input_string, mapping)
print('Huffman Encoded Value: ', huffman_encoded_value)
on_the_other_side_of_the_network = pass_from_the_network(
huffman_encoded_value)
print('After passing the network: ', on_the_other_side_of_the_network)
after_adding_noise = noise.add_noise(on_the_other_side_of_the_network)
print('After adding noise: ', after_adding_noise)
minimum_error, viterbi_decoded_value = viterbi_decoder.perform_viterbi_decoding(
after_adding_noise)
print('After Viterbi decoding: ', viterbi_decoded_value)
final_result = huffman_coding.perform_huffman_decoding(
viterbi_decoded_value, mapping)
print('After huffman decoding: ', final_result)
def test_sap(filename, result_dir):
"""2.3.5 Salt-and-pepper noise and denoising"""
im = Image.open(filename)
def savewith(result, name):
result_path = os.path.join(result_dir, name)
result.save(result_path)
print '[Saved] ' + result_path
# add salt-and-pepper noise with ps=pp=0.2
ps, pp = 0.2, 0.2
noisy = add_noise(im, 'sap', ps=ps, pp=pp)
savewith(noisy, 'sap-%d-%d.png' % (int(100 * ps), int(100 * pp)))
# arithmetic mean filtering
result = arithmetic_mean(noisy, (3, 3))
savewith(result, 'sap-arithmetic.png')
# harmonic mean filtering
result = harmonic_mean(noisy, (3, 3))
savewith(result, 'sap-harmonic.png')
# contraharmonic mean filtering
result = contraharmonic_mean(noisy, (3, 3), 0.5)
savewith(result, 'sap-contraharmonic.png')
# max filtering
result = max_filter(noisy, (3, 3))
savewith(result, 'sap-max.png')
# min filtering
result = min_filter(noisy, (3, 3))
savewith(result, 'sap-min.png')
# median filtering
result = median_filter(noisy, (3, 3))
savewith(result, 'sap-median.png')
def test_sap(filename, result_dir):
"""2.3.5 Salt-and-pepper noise and denoising"""
im = Image.open(filename)
def savewith(result, name):
result_path = os.path.join(result_dir, name)
result.save(result_path)
print '[Saved] ' + result_path
# add salt-and-pepper noise with ps=pp=0.2
ps, pp = 0.2, 0.2
noisy = add_noise(im, 'sap', ps=ps, pp=pp)
savewith(noisy, 'sap-%d-%d.png' % (int(100 * ps), int(100 * pp)))
# arithmetic mean filtering
result = arithmetic_mean(noisy, (3, 3))
savewith(result, 'sap-arithmetic.png')
# harmonic mean filtering
result = harmonic_mean(noisy, (3, 3))
savewith(result, 'sap-harmonic.png')
# contraharmonic mean filtering
result = contraharmonic_mean(noisy, (3, 3), 0.5)
savewith(result, 'sap-contraharmonic.png')
# max filtering
result = max_filter(noisy, (3, 3))
savewith(result, 'sap-max.png')
# min filtering
result = min_filter(noisy, (3, 3))
savewith(result, 'sap-min.png')
# median filtering
result = median_filter(noisy, (3, 3))
savewith(result, 'sap-median.png')
def test_salt(filename, result_dir):
"""2.3.4 Salt noise and denoising"""
im = Image.open(filename)
def savewith(result, name):
result_path = os.path.join(result_dir, name)
result.save(result_path)
print '[Saved] ' + result_path
# add salt noise with ps=0.2
ps = 0.2
noisy = add_noise(im, 'sap', ps=ps)
savewith(noisy, 'salt-%d.png' % (int(100 * ps)))
# contraharmonic filtering
q_neg, q_pos = 1.5, -1.5
q_neg_name, q_pos_name = [str(q).replace('.', '-') for q in (q_neg, q_pos)]
# Q < 0
result = contraharmonic_mean(noisy, (3, 3), q_neg)
savewith(result, 'salt-contraharmonic-%s.png' % q_neg_name)
# Q > 0
result = contraharmonic_mean(noisy, (3, 3), q_pos)
savewith(result, 'salt-contraharmonic-%s.png' % q_pos_name)
def read_file_cpu(trainset, queue, batch_size, num_prepare, rseed=None):
local_random = np.random.RandomState(rseed)
n_train = len(trainset)
trainset_index = local_random.permutation(n_train)
idx = 0
while True:
# read in data if the queue is too short
while queue.full() == False:
batch = np.zeros([batch_size, img_size, img_size, 3])
noisy_batch = np.zeros([batch_size, img_size, img_size, 3])
for i in range(batch_size):
image_path = trainset[trainset_index[idx + i]]
img = sp.misc.imread(image_path)
# <Note> In our original code used to generate the results in the paper, we directly
# resize the image directly to the input dimension via (for both ms-celeb-1m and imagenet)
img = sp.misc.imresize(
img, [img_size, img_size]).astype(float) / 255.0
# The following code crops random-sized patches (may be useful for imagenet)
#img_shape = img.shape
#min_edge = min(img_shape[0], img_shape[1])
#min_resize_ratio = float(img_size) / float(min_edge)
#max_resize_ratio = min_resize_ratio * 2.0
#resize_ratio = local_random.rand() * (max_resize_ratio - min_resize_ratio) + min_resize_ratio
#img = sp.misc.imresize(img, resize_ratio).astype(float) / 255.0
#crop_loc_row = local_random.randint(img.shape[0]-img_size+1)
#crop_loc_col = local_random.randint(img.shape[1]-img_size+1)
#if len(img.shape) == 3:
#img = img[crop_loc_row:crop_loc_row+img_size, crop_loc_col:crop_loc_col+img_size,:]
#else:
#img = img[crop_loc_row:crop_loc_row+img_size, crop_loc_col:crop_loc_col+img_size]
if np.prod(img.shape) == 0:
img = np.zeros([img_size, img_size, 3])
if len(img.shape) < 3:
img = np.expand_dims(img, axis=2)
img = np.tile(img, [1, 1, 3])
## random flip
#flip_prob = local_random.rand()
#if flip_prob < 0.5:
#img = img[-1:None:-1,:,:]
#flip_prob = local_random.rand()
#if flip_prob < 0.5:
#img = img[:,-1:None:-1,:]
# add noise to img
noisy_img = add_noise(
img,
local_random,
std=std,
uniform_max=uniform_noise_max,
min_spatially_continuous_noise_factor=
min_spatially_continuous_noise_factor,
max_spatially_continuous_noise_factor=
max_spatially_continuous_noise_factor,
continuous_noise=continuous_noise,
use_spatially_varying_uniform_on_top=
use_spatially_varying_uniform_on_top,
clip_input=clip_input,
clip_input_bound=clip_input_bound)
batch[i] = img
noisy_batch[i] = noisy_img
batch *= 2.0
batch -= 1.0
noisy_batch *= 2.0
noisy_batch -= 1.0
if clip_input > 0:
batch = np.clip(batch,
a_min=-clip_input_bound,
a_max=clip_input_bound)
noisy_batch = np.clip(noisy_batch,
a_min=-clip_input_bound,
a_max=clip_input_bound)
queue.put([batch,
noisy_batch]) # block until free slot is available
idx += batch_size
if idx > n_train: #reset when last batch is smaller than batch_size or reaching the last batch
trainset_index = local_random.permutation(n_train)
idx = 0
def main():
# COMMAND LINE ARGUMENTS
args = parse_command_line()
print "\nCARMENES Spectrum Forward Simulator (CSFS v%s)" % __version__
# INITIALIZE SPECTRAL ARM
arm = SpectralArm(args)
# SIMULATION START TIMES
t1 = time.time()
sim_start = time.strftime("%a, %d, %b %Y %H:%M:%S + 0000", time.gmtime())
if arm.fib_simmode[0] not in arm.SIM_LIST or arm.fib_simmode[1] not in arm.SIM_LIST:
raise ValueError
for i in xrange(len(arm.fib_simmode)):
#fiber = i
simmode = arm.fib_simmode[i]
#simmodetype = arm.simmodetypes[i] # seems unnecessary
if simmode is '0':
arm.slittyp = "0D point-source"
arm.add_image(np.zeros(arm.CCD_DIMS, dtype=np.uint16))
elif simmode is 'B':
arm.slittyp = "0D point-source"
arm.fiber_description = 'bias frame'
arm.fib_obstype = ['BIAS', 'BIAS']
arm.fib_src = ['BIAS', 'BIAS']
arm.add_image(np.zeros(arm.CCD_DIMS, dtype=np.uint16))
else:
print "Initializing Fiber %s" % arm.fib_char[i]
wavemap = False
if simmode is 'C':
arm.fiber_description = 'Laser Comb Spectrum'
fn = "MODELS/COMB/comb.npy"
wavelengths, intensities = np.load(fn)
inds = (wavelengths >= arm.wmin) & (wavelengths <= arm.wmax)
wavelengths = wavelengths[inds]
intensities = intensities[inds]
if arm.SAMPLING == "grid":
wf.wavegrid(
arm,
wavelengths=wavelengths,
intensities=intensities,
assign=True,
telluric=False)
elif arm.SAMPLING == "mc":
arm.wavelengths = wavelengths
arm.intensities = intensities
if arm.fib_rv[i]:
arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i])
arm.infiles[i] = fn
arm.fib_obstype[i] = 'WAVE'
arm.fib_src[i] = 'COMB'
elif simmode is 'F':
arm.fiber_description = 'flatfield spectrum simulation'
arm.wavelengths = wf.calculate_wavelengths(arm, mode='CCD', nwaves=arm.nw)
arm.intensities = np.ones(arm.wavelengths.size)
arm.fib_obstype[i] = 'FLAT'
arm.fib_src[i] = 'HAL'
elif simmode is 'L':
if len(arm.infiles[i]) is not 1:
raise ValueError
print 'loading %s' % (arm.infiles[i][0])
arm.fiber_description = 'emission line list spectrum simulation'
wavelengths, intensities = np.loadtxt(arm.infiles[i][0], unpack=True)
#wavelengths, intensities = np.load(arm.infiles[i][0])
wavelengths *= 1.0e-7 # convert Ang to mm @MZ
inds = np.where((wavelengths >= arm.wmin) & (wavelengths <= arm.wmax))
arm.wavelengths = wavelengths[inds]
arm.intensities = intensities[inds]
if arm.fib_rv[i]:
arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i])
elif simmode is 'P':
arm.fiber_description = """PHOENIX model spectrum simulation: T_eff=3000 K, [Fe/H]=0.0, log(g)=5.0"""
wavelengths = np.load('phx_wavelengths.npy')
intensities = np.load('phx_intensities.npy')
inds = (wavelengths >= arm.wmin) & (wavelengths <= arm.wmax)
wavelengths = wavelengths[inds]
intensities = intensities[inds]
if arm.SAMPLING == 'grid':
wf.wavegrid(
arm,
wavelengths=wavelengths,
intensities=intensities,
assign=True,
telluric=arm.tell)
elif arm.SAMPLING == 'mc':
arm.wavelengths = wavelengths
arm.intensities = intensities
if arm.fib_rv[i]:
arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i])
if arm.tell:
arm.intensities = wf.convolve_telluric_lines(
arm,
arm.wavelengths,
arm.intensities)
arm.infiles[i] = ['phx_wavelengths.npy', 'phx_intensities.npy']
arm.catg = 'SCI'
arm.fib_obstype[i] = 'STAR'
arm.fib_src[i] = 'OBJ'
arm.sciobject = 'PHOE_lte03000-5.00-0.0'
elif simmode is 'S':
if len(arm.infiles[i]) == 1:
try:
wavelengths, intensities = pyfits.getdata(arm.infiles[i][0])
except IOError:
wavelengths, intensities = np.loadtxt(arm.infiles[i][0], unpack=True)
elif len(arm.infiles[i]) == 2:
try:
wavelengths = pyfits.getdata(arm.infiles[i][0])
intensities = pyfits.getdata(arm.infiles[i][1])
except IOError:
wavelengths = np.loadtxt(arm.infiles[i][0])
intensities = np.loadtxt(arm.infiles[i][1])
elif len(arm.infiles[i]) not in [1, 2]:
raise AttributeError("Please specify an input wavelength file and input flux/counts file.")
arm.fiber_description = 'object spectrum simulation'
wavelengths *= 1.0e-7 # convert Ang to mm
inds = (wavelengths >= arm.wmin) & (wavelengths <= arm.wmax)
wavelengths = wavelengths[inds]
intensities = intensities[inds]
# wavelength sampling, add telluric lines
if arm.SAMPLING == 'grid':
wf.wavegrid(
arm,
wavelengths=wavelengths,
intensities=intensities,
assign=True,
telluric=arm.tell)
elif arm.SAMPLING == 'mc':
arm.wavelengths = wavelengths
arm.intensities = intensities
if arm.fib_rv[i]:
arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i])
if arm.tell:
arm.intensities = wf.convolve_telluric_lines(
arm,
arm.wavelengths,
arm.intensities)
arm.fib_obstype[i] = 'STAR'
arm.fib_src[i] = 'OBJ'
elif simmode is 'T':
from importtharlines import import_thar_lines
arm.fiber_description = 'Thorium Argon line list'
wavelengths, intensities = import_thar_lines()
inds = (wavelengths >= arm.wmin) & (wavelengths <= arm.wmax)
arm.wavelengths = wavelengths[inds]
arm.intensities = intensities[inds]
if arm.fib_rv[i]:
arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i])
arm.infiles[i] = "Lovis,2007; Kerber,2008"
arm.fib_obstype[i] = 'WAVE'
arm.fib_src[i] = 'ThAr'
elif simmode is 'U':
arm.fiber_description = 'Uranium Neon calibration lamp'
fn = "MODELS/UNE/une.npy"
arm.infiles[i] = fn
wavelengths, intensities = np.load(fn)
inds = (wavelengths >= arm.wmin) & (wavelengths <= arm.wmax)
wavelengths = wavelengths[inds]
intensities = intensities[inds]
if arm.fib_rv[i]:
wavelengths = redshift(wavelengths, arm.fib_rv[i])
if arm.SAMPLING == "grid":
wf.wavegrid(
arm,
wavelengths=wavelengths,
intensities=intensities,
assign=True,
telluric=False)
elif arm.SAMPLING == "mc":
arm.wavelengths = wavelengths
arm.intensities = intensities
arm.fib_obstype[i] = 'WAVE'
arm.fib_src[i] = 'UNe'
elif simmode is 'W':
arm.fiber_description = 'wavelength mapping'
arm.wavelengths = wf.calculate_wavelengths(arm, mode='CCD', nwaves=arm.nw)
arm.intensities = arm.wavelengths
if arm.fib_rv[i]:
arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i])
arm.wavemap = True
arm.fib_obstype[i] = 'WAVE'
arm.fib_src[i] = 'WAVE'
elif simmode is 'X':
arm.fiber_description = 'Fabry-Perot spectrum simulation'
# arm.wavelengths = np.load('phx_wavelengths.npy')
# print arm.wavelengths
arm.wavelengths = wf.calculate_wavelengths(arm, mode='CCD', nwaves=arm.nw)
arm.intensities = fabry_perot(arm.wavelengths)
if arm.fib_rv[i]:
arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i])
arm.fib_obstype[i] = 'WAVE'
arm.fib_src[i] = 'FP'
## APPLY RV SHIFT TO WAVELENGTHS
#if arm.fib_rv[i]:
#arm.wavelengths = redshift(arm.wavelengths, arm.fib_rv[i]) # @MZ arm.fib_rv[fiber] not fiber
# RUN SIMULATION
sim_general(arm, i)
print "Fiber %s simulation finished\n" % arm.fib_char[i]
# PROCESS ARRAYS INTO A SINGLE IMAGE / ADD NOISE
arm.add_full_sim_time(sim_start) # start time
arm.add_full_sim_time(time.time() - t1) # finish time
arm.image = arm.images[0] + arm.images[1] # final image array
# ADD NOISE
# if arm.noise:
add_noise(arm)
# prevents value overflow wraparound
arm.image[arm.image > np.iinfo(np.uint16).max] = np.iinfo(np.uint16).max
arm.image = np.array(arm.image, dtype=np.uint16) # noise converts array to int64 at some step - let's bring it back to uint16
print "Converting image array to %s" % arm.image.dtype
# WRITE FITS FILE
write_to_fits(arm)
# WAVELENGTH SOLUTIONS; CREATE WAVETRACE REGION FILES
for i in xrange(len(arm.wt)):
if arm.wt[i]:
wlt.wavelength_trace(arm, i)
# SPAWN FITS OUTPUT IMAGE IN SAO-DS9
if args.ds9 or args.ds9_mosaic:
if args.ds9_mosaic:
ds9_param = '-mosaicimage iraf'
else:
ds9_param = '-mecube'
if arm.WT_FLAG:
if args.no_compress:
call = 'ds9 %s.fits %s -region %s.reg' % (ds9_param, rm.outfile, arm.outfile)
else:
call = 'ds9 %s.fits.gz %s -region %s.reg' % (ds9_param, arm.outfile, arm.outfile)
else:
if args.no_compress:
call = 'ds9 %s %s.fits' % (ds9_param, arm.outfile)
else:
call = 'ds9 %s %s.fits.gz' % (ds9_param, arm.outfile)
print "Executing '%s'" % call
try:
subprocess.check_call(call.split())
except OSError, e:
print e
print "Shell call failed. You can just run the following line in the shell:"
print call
import socket
import en_decript as ed
import noise as noise
import ham as ham
serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serv.bind(('0.0.0.0', 8080))
serv.listen(5)
while True:
conn, addr = serv.accept()
from_client = ''
while True:
data = conn.recv(4096)
if not data: break
from_client += data.decode()
a = ed.str_to_BIN('holaquetal')
b = noise.add_noise(a, 0.5)
message = ed.BIN_to_bitarray(b)
conn.send(message)
conn.close()
print('client disconnected')
def read_file_cpu(trainset, queue, batch_size, num_reference, img_size, num_prepare, sampling_rate, rseed=None):
local_random = np.random.RandomState(rseed)
n_train = len(trainset)
trainset_index = local_random.permutation(n_train)
idx = 0
while True:
# read in data if the queue is too short
# 参数补充定义
std = 1.2 # noise_std
uniform_noise_max = 3.464
min_spatially_continuous_noise_factor = 0.01
max_spatially_continuous_noise_factor = 0.5
continuous_noise = 1
use_spatially_varying_uniform_on_top = 1
clip_input = 0
clip_input_bound = 2.0
while queue.full() == False:
instance_size = batch_size - num_reference
inst_batch = np.zeros([instance_size, img_size, img_size, 1])
inst_incomplete_batch = np.zeros([instance_size, img_size, img_size, 1])
for i in range(instance_size):
image_path = trainset[trainset_index[idx+i]]
img_dict = sio.loadmat(image_path)
# 归一化 [-1, 1]
img = img_dict['b'] / np.max(np.abs(img_dict['b']))
# print("img' : ", img)
# os.system("pause")
# incomplete img
# incomplete_img = batch_multiply(batch, mask_c)
# mask_c似乎还没有定义
# add noise to img， noisy_img也在0到1的范围
noisy_img = add_noise(img, local_random,
std=std,
uniform_max=uniform_noise_max,
min_spatially_continuous_noise_factor=min_spatially_continuous_noise_factor,
max_spatially_continuous_noise_factor=max_spatially_continuous_noise_factor,
continuous_noise=continuous_noise,
use_spatially_varying_uniform_on_top=use_spatially_varying_uniform_on_top,
clip_input=clip_input, clip_input_bound=clip_input_bound
)
if len(img.shape) < 3:
img = np.expand_dims(img, axis=2) #(28, 28)->(28, 28, 1)
inst_batch[i] = img
# noisy_batch[i] = noisy_img
inst_mask_c = generate_mask(instance_size, img_size, sampling_rate)
inst_incomplete_batch = np.multiply(inst_batch, inst_mask_c)
# batch *= 2.0 #为了弄到0到2的范围
# batch -= 1.0 #为了弄到-1到1的范围
# noisy_batch *= 2.0
# noisy_batch -= 1.0
# 添加，保持在-1到1的范围
inst_batch = np.clip(inst_batch, a_min = -1, a_max = 1)
# noisy_batch = np.clip(noisy_batch, a_min = -1, a_max = 1)
inst_incomplete_batch = np.clip(inst_incomplete_batch, a_min = -1, a_max = 1)
#恢复到0-255, 这里还是不恢复到0-255,先归一化处理
# batch = batch * 127.5 + 127.5
# noisy_batch = noisy_batch * 127.5 + 127.5
if clip_input > 0:
inst_batch = np.clip(inst_batch, a_min=-clip_input_bound, a_max=clip_input_bound)
inst_noisy_batch = np.clip(inst_noisy_batch, a_min=-clip_input_bound, a_max=clip_input_bound)
# queue.put([batch, noisy_batch]) # block until free slot is available
queue.put([inst_batch, inst_incomplete_batch, inst_mask_c])
idx += batch_size
# if idx > n_train: #reset when last batch is smaller than batch_size or reaching the last batch
if idx > n_train - batch_size:
trainset_index = local_random.permutation(n_train)
idx = 0
return self.editedImg
if __name__ == '__main__':
input_filename = "sunset.jpg"
if len(sys.argv) > 1:
input_filename = sys.argv[1]
srcImg = cv2.imread(input_filename)
grayImg = cv2.cvtColor(srcImg, cv2.COLOR_BGR2GRAY)
resultImg = cv2.cvtColor(grayImg, cv2.COLOR_GRAY2BGR)
resultImg = noise.add_noise(resultImg, 30)
resultImg = noise.shift_image(resultImg)
cv2.imwrite("result.jpg", resultImg)
srcImg = cv2.imread("result.jpg")
glitch = Glitch(srcImg)
IMG_SIZE_h, IMG_SIZE_w, _ = srcImg.shape
fourcc = cv2.VideoWriter_fourcc('a', 'v', 'c', '1')
video = cv2.VideoWriter('video.mp4', fourcc, 9.0, (IMG_SIZE_w, IMG_SIZE_h))
for _ in range(270):
resultImg = glitch.get_image()
def read_file_cpu(trainset, queue, batch_size, num_prepare, rseed=None):
local_random = np.random.RandomState(rseed)
n_train = len(trainset)
trainset_index = local_random.permutation(n_train)
idx = 0
while True:
# read in data if the queue is too short
while queue.full() == False:
batch = np.zeros([batch_size, img_size, img_size, 3])
noisy_batch = np.zeros([batch_size, img_size, img_size, 3])
for i in range(batch_size):
image_path = trainset[trainset_index[idx+i]]
img = sp.misc.imread(image_path)
# <Note> In our original code used to generate the results in the paper, we directly
# resize the image directly to the input dimension via (for both ms-celeb-1m and imagenet)
img = sp.misc.imresize(img, [img_size, img_size]).astype(float) / 255.0
# The following code crops random-sized patches (may be useful for imagenet)
#img_shape = img.shape
#min_edge = min(img_shape[0], img_shape[1])
#min_resize_ratio = float(img_size) / float(min_edge)
#max_resize_ratio = min_resize_ratio * 2.0
#resize_ratio = local_random.rand() * (max_resize_ratio - min_resize_ratio) + min_resize_ratio
#img = sp.misc.imresize(img, resize_ratio).astype(float) / 255.0
#crop_loc_row = local_random.randint(img.shape[0]-img_size+1)
#crop_loc_col = local_random.randint(img.shape[1]-img_size+1)
#if len(img.shape) == 3:
#img = img[crop_loc_row:crop_loc_row+img_size, crop_loc_col:crop_loc_col+img_size,:]
#else:
#img = img[crop_loc_row:crop_loc_row+img_size, crop_loc_col:crop_loc_col+img_size]
if np.prod(img.shape) == 0:
img = np.zeros([img_size, img_size, 3])
if len(img.shape) < 3:
img = np.expand_dims(img, axis=2)
img = np.tile(img, [1,1,3])
## random flip
#flip_prob = local_random.rand()
#if flip_prob < 0.5:
#img = img[-1:None:-1,:,:]
#flip_prob = local_random.rand()
#if flip_prob < 0.5:
#img = img[:,-1:None:-1,:]
# add noise to img
noisy_img = add_noise(img, local_random,
std=std,
uniform_max=uniform_noise_max,
min_spatially_continuous_noise_factor=min_spatially_continuous_noise_factor,
max_spatially_continuous_noise_factor=max_spatially_continuous_noise_factor,
continuous_noise=continuous_noise,
use_spatially_varying_uniform_on_top=use_spatially_varying_uniform_on_top,
clip_input=clip_input, clip_input_bound=clip_input_bound
)
batch[i] = img
noisy_batch[i] = noisy_img
batch *= 2.0
batch -= 1.0
noisy_batch *= 2.0
noisy_batch -= 1.0
if clip_input > 0:
batch = np.clip(batch, a_min=-clip_input_bound, a_max=clip_input_bound)
noisy_batch = np.clip(noisy_batch, a_min=-clip_input_bound, a_max=clip_input_bound)
queue.put([batch, noisy_batch]) # block until free slot is available
idx += batch_size
if idx > n_train: #reset when last batch is smaller than batch_size or reaching the last batch
trainset_index = local_random.permutation(n_train)
idx = 0
import load_model
import train
import attack
import noise
# Hyperparameters
epochs = 20
adv_mult = 0.2
adv_step = 0.05
attack_eps = 0.03
attack_norm = np.inf
noise_factor = 0.01
(x_train, y_train, y_train_cat), (x_test, y_test,
y_test_cat) = load_data.load_fashion_mnist()
x_train_noise_001 = noise.add_noise(x_train, 0.01)
x_train_noise_005 = noise.add_noise(x_train, 0.05)
x_train_noise_01 = noise.add_noise(x_train, 0.1)
x_test_noise_001 = noise.add_noise(x_test, 0.01)
x_test_noise_005 = noise.add_noise(x_test, 0.05)
x_test_noise_01 = noise.add_noise(x_test, 0.1)
data_models = []
for selected_train_data in [
x_train, x_train_noise_001, x_train_noise_005, x_train_noise_01
]:
for selected_model in [
load_model.lenet_base, load_model.lenet_max,
load_model.lenet_deep5, load_model.lenet_max_deep5,
load_model.lenet_large, load_model.lenet_max_large,