def gen_coherent_noise(height,width):
vs = np.linspace(-0.2, 0.2, num=width)
px_1 = markov.FuzzyProgression(
values=vs,
positive_shifts=3, negative_shifts=3,
repeat_factor=4)
np.random.seed(120)
values = []
for i in range(3):
mask = np.random.binomial(1, p=0.5, size=width // 10)
vs = ['0', '1','2' ]
pattern = ''.join([vs[i] for i in mask])
print(pattern)
values += [
markov.SimplePattern(pattern=pattern, candidates=[-0.5,0,0.5])]
black_white = markov.RandomMarkovModel(
values=values,
child_lengths=[width * i for i in range(1, 2)])
varied = markov.SimpleProgression(
values=[px_1],
child_lengths=[width * i for i in range(10, 15)])
parent = markov.RandomMarkovModel(
values=[varied, black_white],
child_lengths=[1, 2])
img = markov.paint_linearly_markov_hierarchy(
markov_tree=parent, width=width, height=height, seed=20)
return img
def generate_full_image(color_string, seed):
r.init_def_generator(seed)
image = np.zeros((HEIGHT, WIDTH, 3))
plots = []
loop_key = r.bind_generator()
setup_key = r.bind_generator()
post_process = lambda x: data.integrate_series(
x, n=2, mean_influences=[0, 0])
pup = m.SimpleProgression(values=1,
self_length=[10, 40, 50],
post_process=post_process)
pdown = m.SimpleProgression(values=-1,
self_length=[10, 40, 50],
post_process=post_process)
arc = m.RandomMarkovModel(values=[pup, pdown], self_length=[2])
p = m.RandomMarkovModel(
# values=[p1, p2, arc],
values=[arc],
parent_rkey=r.bind_generator_from(setup_key))
# for i in range(-30,30):
for i in range(1):
sample = m.sample_markov_hierarchy(p, 1000)
sample = data.integrate_series(sample, 1, mean_influences=1)
# sample = data.integrate_series(sample,1,mean_influences=0)
# sample -= np.min(sample)
# sample = data.integrate_series(sample,1)
# slices = [ np.s_[:50],np.s_[50:100], np.s_[100:] ]
# for slice in slices:
# sample[slice] -= np.mean(sample[slice])
# sample = data.integrate_series(sample,1)
# sample[:60+i] -= np.mean(sample[:60+i])
# sample[60+i:] -= np.mean(sample[60+i:])
# sample = data.integrate_series(sample,1)
plots += [sample]
plt.plot(plots[0])
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()
plt.show()
# viz.animate_plots_y(plots)
return image
mask = mask[mask<NUM_CELLS]
vls[mask] = np.random.choice([NUM_CELLS+1,NUM_CELLS+2,NUM_CELLS+3])
lngts = pat['lengths']
model = m.SimpleProgression(values=m.Processor(
m.SimpleProgression(
values=vls,
lenghts=lngts,
self_length=NUM_CELLS,
start_probs=[0,1,2,3]),
num_tiles=num_tiles),self_length=[5,10,15,20,25])
pattern_models += [model]
def update_fun(preference_matrix,start_probs):
return preference_matrix,np.roll(start_probs,shift=1)
parent = m.RandomMarkovModel(
values=pattern_models,
start_probs=0,
update_fun=update_fun,update_step=1)
img = gen_portion(
parent,
height=HEIGHT,width=WIDTH,
tile_height=None,tile_width=None)
final_img_prototype = data.upscale_nearest(img,UPSCALE_FACTOR)
final_img = color.replace_indices_with_colors(final_img_prototype,COLOR_DICT).astype('uint8')
if N==1:
viz.start_color_editing_tool(
blueprint=final_img_prototype,
color_dict=COLOR_DICT,
downsample=2)
else:
p = [
gen_patterns(current_tile_width,
num_segments,
current_colors,
min_length=2) for i in range(np.random.choice([2, 3]))
]
print(p)
p = [
m.Processor(m.SimpleProgression(values=i['values'],
lenghts=i['lengths'],
self_length=num_segments,
start_probs=0),
num_tiles=[2, 4, 5, 6, 8]) for i in p
]
parent = m.RandomMarkovModel(values=p)
img = gen_portion(parent,
height=portion_height,
width=WIDTH,
tile_height=current_tile_height,
tile_width=current_tile_width)
portions += [img]
print(img.shape)
print(np.min(img))
print(np.max(img))
final_img_prototype = np.vstack(portions)
final_img_prototype = final_img_prototype[:HEIGHT, :WIDTH]
final_img_prototype = data.upscale_nearest(final_img_prototype,
np.random.choice(
PATTERN_LENGTH,
size=np.random.choice(PATTERN_LENGTH // 2 - 1) + 1,
replace=False)) for i in range(30)
] + ['0' * PATTERN_LENGTH]
patterns_white = [
m.SimplePattern(pattern=i, candidates=[0, 1]) for i in patterns_white
]
patterns_black = [
m.SimplePattern(pattern=i, candidates=[0, 1]) for i in patterns_black
]
row_patterns_white = [
m.SimpleProgression(values=m.RandomMarkovModel(values=patterns_white,
child_lengths=[i]),
child_lengths=j)
for (i, j) in [[50, 4], [100, 20], [200, 1]]
]
row_patterns_white = m.RandomMarkovModel(values=row_patterns_white,
child_lengths=5)
row_patterns_black = [
m.SimpleProgression(values=m.RandomMarkovModel(values=patterns_black,
child_lengths=[i]),
child_lengths=j)
for (i, j) in [[50, 4], [100, 20], [200, 1]]
]
row_patterns_black = m.RandomMarkovModel(values=row_patterns_black,
gen_all_possible_permutations('00212-00212', ['0', '1', '2']),
gen_all_possible_permutations('01000-00220', ['0', '1', '2']),
gen_all_possible_permutations('02200-00010', ['0', '1', '2']),
]
pats = [j for i in pats for j in i]
pats = [
m.SimpleProgression(values=m.SimplePattern(pattern=i,
candidates=[0] +
[int(a), int(b)],
start_probs=0),
child_lengths=TILE_WIDTH) for i in pats
]
pats = m.Processor(m.SimpleProgression(values=m.RandomMarkovModel(
values=pats, child_lengths=1),
child_lengths=TILE_HEIGHT),
num_tiles=TILING_OPTIONS)
basic_tiles += [pats]
basic_tiles = m.SimpleProgression(values=basic_tiles, child_lengths=1)
r = [m.SimpleProgression(values=i) for i in [2, 3, 10, 11, 12]]
random_tiles = m.Processor(m.SimpleProgression(
values=m.RandomMarkovModel(values=r, child_lengths=[1, 2, 3, 4]),
child_lengths=TILE_HEIGHT * TILE_WIDTH // 2),
num_tiles=1,
length_limit=TILE_HEIGHT * TILE_WIDTH)
parent = m.RandomMarkovModel(values=[basic_tiles, random_tiles],
vs = '012'
pattern = ''.join([vs[i] for i in mask])
# if ending[i] == 1:
# pattern += '5'
print(pattern)
base_values += [
markov.SimplePattern(pattern,
lengths=lengths,
candidates=[11, 12, 13]),
markov.SimplePattern(pattern,
lengths=lengths,
candidates=[11, 12, 13])
]
base = markov.Processor(markov.Processor(markov.RandomMarkovModel(
values=base_values,
child_lengths=[WIDTH // 10],
seed=current_iteration * 50),
num_tiles=[7]),
num_tiles=[4, 5])
bg = [
markov.Processor(markov.SimpleProgression(values=[i]),
num_tiles=WIDTH * 3) for i in [11, 13]
]
bg = markov.RandomMarkovModel(values=bg, child_lengths=[1])
pure = [
markov.Processor(markov.SimpleProgression(values=[i]),
num_tiles=WIDTH // 10) for i in [1, 2, 3, 4, 5]
]