def show_all_dream_image_layers(file_name = "test.png",show=True):
"""
Args:
file_name: image to deep dream on
show: to show the image
Saves and shows the dream image for all 10 layers
"""
for num in range(1,11):
layer_tensor = model.layer_tensors[num]
img_result = load_image(filename='{}'.format(file_name))
img_result = recursive_optimize(layer_tensor=layer_tensor, image=img_result,
# how clear is the dream vs original image
num_iterations=100, step_size=1.0, rescale_factor=0.5,
# How many "passes" over the data. More passes, the more granular the gradients will be.
num_repeats=8, blend=0.2)
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save('{}_{}.png'.format(file_name[:-4], num))
if show:
result.show()
def DreamImage(fileDirectory, layers, iterations, stepSize, rescaleFactor,
repeats, blend, pictureName, outputDirectory):
"""
Amplyfies the patterns the inception model sees in one image.
"""
# Load the input image.
filePath = fileDirectory + pictureName
baseImage = load_image(filename='{}'.format(filePath))
# Loop through all passed layers, amplify the inception model patterns.
for layer in layers:
try:
img_result = recursive_optimize(
layer_tensor=model.layer_tensors[layer],
image=baseImage,
num_iterations=iterations,
step_size=stepSize,
rescale_factor=rescaleFactor,
num_repeats=repeats,
blend=blend)
# Save the output image.
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save(
"{}Layer{}_Iter{}_Step{}_Rescale{}_Repeats{}_Blend{}.jpg".
format(outputDirectory, layer, iterations, stepSize,
rescaleFactor, repeats, blend))
except Exception as ex:
print(ex)
def processing(filename):
from deepdreamer import model, load_image, recursive_optimize
import numpy as np
import PIL.Image
layer_tensor = model.layer_tensors[1]
img_result = load_image(filename='{}'.format(filename))
img_result = recursive_optimize(
layer_tensor=layer_tensor,
image=img_result,
# how clear is the dream vs original image
num_iterations=5,
step_size=1.0,
rescale_factor=0.5,
# How many "passes" over the data. More passes, the more granular the gradients will be.
num_repeats=5,
blend=1)
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
filename = filename.split(".")
filename = str(filename[0]) + "_out.jpg"
result.save(f'{filename}')
def process(img):
img = recursive_optimize(
layer_tensor=layer_tensor,
image=img,
# how clear is the dream vs original image
num_iterations=20,
step_size=1.0,
rescale_factor=0.5,
# How many "passes" over the data. More passes, the more granular the gradients will be.
num_repeats=6,
blend=0.2)
img -= (np.max(img) - np.min(img)) / 2
img = np.clip(img, 0.0, 255.0)
img = img.astype(np.uint8)
return img
def singleDream(self, output, layer=3):
# Chose Layer to enhance
layer_tensor = model.layer_tensors[layer]
file_name = self.__image
img_result = load_image(filename='{}'.format(file_name))
# Call recursive optimization to generate dream
img_result = recursive_optimize(
layer_tensor=layer_tensor,
image=img_result,
# how clear is the dream vs original image
num_iterations=20,
step_size=1.0,
rescale_factor=0.5,
# How many "passes" over the data. More passes, the more granular the gradients will be.
num_repeats=8,
blend=0.2)
# Make sure output results are valid pixel values
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
# Generate and save image out of numpy array
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save("./dream/" + self.__name + "/" + output)
from deepdreamer import model, load_image, recursive_optimize
import numpy as np
import PIL.Image
# determines layer to apply to image
layerTensor = model.layer_tensors[1]
# instantiates img filename and img object
filename = "casey-horner-1268624-unsplash.jpg"
img = load_image(filename='{}'.format(filename))
img_result = recursive_optimize(
layer_tensor=layerTensor,
image=img,
# determines image clarity
num_iterations=20,
step_size=1.0,
rescale_factor=0.5,
# How many passes over the data. More passes means more granular gradients
num_repeats=8,
blend=0.2)
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save('dream_image_out.jpg')
result.show()
img_result = img_result[0 + x_trim:y_size - y_trim,
0 + y_trim:x_size - x_trim]
img_result = cv2.resize(img_result, (x_size, y_size))
img_result[:, :, 0] += 2
img_result[:, :, 1] += 2
img_result[:, :, 2] += 2
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
img_result = recursive_optimize(
layer_tensor=layer_tensor,
image=img_result,
# how clear is the dream vs original image
num_iterations=15,
step_size=1.0,
rescale_factor=0.7,
# How many "passes" over the data. More passes, the more granular the gradients will be.
num_repeats=1,
blend=0.2)
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save('images/img{}.jpg'.format(i + 1))
counts += 1
if counts > max_count:
break
img_result = img_result[0 + x_trim:y_size - y_trim,
0 + y_trim:x_size - x_trim]
img_result = cv2.resize(img_result, (x_size, y_size))
# for modifying the general colors and brightness of results.
# +2 is slowly dimmer
# +3 is slowly brighter
img_result[:, :, 0] += 2 #reds
img_result[:, :, 1] += 2 #greens
img_result[:, :, 2] += 2 #blues
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
img_result = recursive_optimize(layer_tensor=layer_tensor,
image=img_result,
num_iterations=20,
step_size=1.0,
rescale_factor=0.7,
num_repeats=1,
blend=0.2)
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save('dream/{}/img_{}.jpg'.format(dream_name, i + 1))
created_count += 1
if created_count > max_count:
break
#results tend to get dimmer or brighter over time , so you want to
#mannually adjust this over time
#+2 is slowly dimmer
#+3 is slowly brighter
brightness_d = sqrt(0.241*img_result[:,:,0]+0.691*img_result[:,:,1]+0.068*img_result[:,:,2])
if(brightness_d<Avg_brightness):
img_result[:,:,0] += r.randint(3,4) #red
img_result[:,:,1] += r.randint(3,4) #green
img_result[:,:,2] += r.randint(3,4) #blue
img_result = np.clip(img_result, 0.0 , 255.0)
img_result = img_result.astype(np.uint8)
img_result = recursive_optimize(layer_tensor=model.layer_tensors[r.randint(0,11)],
image = img_result,
num_iterations = 2,
step_size = 1.0,
rescale_factor = 0.7,
num_repeats = 8,
blend = 0.2)
img_result = np.clip(img_result,0.0,255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result,mode = 'RGB')
result.save('dream/{}/img_{}.jpg'.format(dream_name,i+1))
created_count+=1
if created_count > max_count:
break
def DreamFrames(dreamDirectory, layers, iterations, stepSize, rescaleFactor, repeats, blend
, fps, dreamName, dreamLength, changeLayerAfterSec, trimPercent):
"""
Creates and saves the frames (images) for a dream video.
"""
# Randomly chose initial values for RGB correction.
redCorrection = int(random.choice("23"))
greenCorrection = int(random.choice("23"))
blueCorrection = int(random.choice("23"))
for i in range(0, dreamLength * fps):
# Check if the image has already been processed.
if not os.path.isfile("{}{}/img_{}.jpg".format(dreamDirectory, dreamName, i + 1)):
# Load the input/previous image.
img_result = load_image(filename="{}{}/img_{}.jpg".format(dreamDirectory, dreamName, i))
# Get the size of the image.
xSize = len(img_result[0])
ySize = len(img_result)
# Trim the image to create a "zoom-in" effect.
xTrim = math.ceil(xSize * trimPercent / 100)
yTrim = math.ceil(ySize * trimPercent / 100)
img_result = img_result[yTrim:ySize - yTrim - 9, xTrim:xSize - xTrim - 9]
img_result = imresize(img_result, (ySize, xSize), "nearest")
# Adjust the brightness of the image by ensuring that the red green and blue portions of the
# image are above/below the defined thresholds.
upperBrightnessLevel = xSize*ySize*255*0.8
lowerBrightnessLevel = xSize*ySize*255*0.2
redSum = numpy.sum(img_result[:, :, 0])
if redSum < lowerBrightnessLevel:
redCorrection = int(random.choice("34"))
elif redSum > upperBrightnessLevel:
redCorrection = int(random.choice("12"))
img_result[:, :, 0] += redCorrection
greenSum = numpy.sum(img_result[:, :, 0])
if greenSum < lowerBrightnessLevel:
greenCorrection = int(random.choice("34"))
elif greenSum > upperBrightnessLevel:
greenCorrection = int(random.choice("12"))
img_result[:, :, 1] += greenCorrection
blueSum = numpy.sum(img_result[:, :, 0])
if blueSum < lowerBrightnessLevel:
blueCorrection = int(random.choice("34"))
elif blueSum > upperBrightnessLevel:
blueCorrection = int(random.choice("12"))
img_result[:, :, 2] += blueCorrection
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
# Select the inception model layer for next dream iteration.
framesPerLayer = fps * changeLayerAfterSec
# Option 1: Automatically loop through layers 10..2
#layer = int(11 - (math.ceil((i - math.floor(i/(9*framesPerLayer))*(9*framesPerLayer)) / framesPerLayer)))
# Option 2: Cycle through layers list
layer = layers[int(math.ceil(i - (math.floor(i/(framesPerLayer*len(layers)))) * (framesPerLayer*len(layers)))/framesPerLayer)]
# Select the number of iterations for the selected layer.
iterations = int(min(21.0, layer * math.pi) + 2)
# Amplify the inception model patterns in the image.
img_result = recursive_optimize(layer_tensor=model.layer_tensors[layer],
image=img_result,
num_iterations=iterations,
step_size=stepSize,
rescale_factor=rescaleFactor,
num_repeats=1,
blend=blend)
# Save the output image.
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode="RGB")
print("{}{}/img_{}.jpg".format(dreamDirectory, dreamName, i + 1))
result.save("{}{}/img_{}.jpg".format(dreamDirectory, dreamName, i + 1))
else:
print("Already processed image {}".format(i))
0 + y_trim:x_size - x_trim]
img_result = cv2.resize(img_result, (x_size, y_size))
# Use these to modify the general colors and brightness of results.
# results tend to get dimmer or brighter over time, so you want to
# manually adjust this over time.
# +2 is slowly dimmer
# +3 is slowly brighter
img_result[:, :, 0] += random.choice([2, 2.5, 3]) # reds
img_result[:, :, 1] += random.choice([2, 2.5, 3]) # greens
img_result[:, :, 2] += random.choice([2, 2.5, 3]) # blues
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
img_result = recursive_optimize(
layer_tensor=layer_tensor,
image=img_result,
num_iterations=num_iterations,
step_size=step_size,
rescale_factor=rescale_factor, #downscaling
num_repeats=
num_repeats, #it's better to keep it one because every frame will change gradually
blend=blend) #how much filter effects on picture
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save('dreams/{}/img_{}.jpg'.format(dream_name, i + 1))
from deepdreamer import model, load_image, recursive_optimize
import numpy as np
import PIL.Image
import random
layer_tensor = model.layer_tensors[10]
file_name = "8.jpeg"
img = load_image(filename='{}'.format(file_name))
img_result = recursive_optimize(layer_tensor=layer_tensor,
image=img,
num_iterations=25,
step_size=2,
rescale_factor=0.5,
num_repeats=8,
blend=0.2)
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save(file_name + '_out.jpg')
result.show()
def create_dream_frames(file_name = "test.png", target_dream_layer = 3, total_frames=5, zoom_in=False):
"""
Args:
file_name: orginal image file
target_dream_layer: targeted dream layer style
total_frames: total number of frames of dream images to generate
Returns:
dream_layer_dir_path: directory path storing the frames
file_name: name of original image file
Creates the total number of frames, inside dream_frames/img_name
"""
curr_path = os.getcwd()
dream_frames_path = os.path.join(curr_path, 'dream_frames')
# zoom-in effect directory
if zoom_in:
dream_frames_path = dream_frames_path + '_zoom_in'
# check and create '/dream_frames' directory
if not os.path.exists(dream_frames_path):
os.mkdir(dream_frames_path)
# /file_name dir
dream_dir_path = os.path.join(dream_frames_path, '{}'.format(format(file_name[:-4])))
if not os.path.exists(dream_dir_path):
os.mkdir(dream_dir_path)
# /layer_num
dream_layer_dir_path = os.path.join(dream_dir_path, 'layer_{}'.format(target_dream_layer))
if not os.path.exists(dream_layer_dir_path):
os.mkdir(dream_layer_dir_path)
dream_layer_tensor = model.layer_tensors[target_dream_layer]
# saves original image as starter image
img_path = os.path.join(dream_layer_dir_path, 'img_0.png')
result = PIL.Image.open(file_name)
(x_size, y_size) = result.size
result.save(img_path)
# generates the frames
for i in range(total_frames-1):
img_result = load_image(filename='{}{}.png'.format(img_path[:-5], i))
if zoom_in:
x_trim = 10
y_trim = 10
img_result = img_result[0+x_trim:y_size-y_trim, 0+y_trim:x_size-x_trim]
img_result = cv2.resize(img_result, (x_size, y_size))
img_result[:, :, 0] += 3 # reds
img_result[:, :, 1] += 3 # greens
img_result[:, :, 2] += 3 # blues
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
img_result = recursive_optimize(layer_tensor=dream_layer_tensor,
image=img_result,
num_iterations=15,
step_size=1.0,
rescale_factor=0.7,
num_repeats=1,
blend=0.2)
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save('{}{}.png'.format(img_path[:-5], i+1))
print('{}/{} DONE'.format(i+1,total_frames))
return dream_layer_dir_path, file_name
def startDreaming(self):
# Define dream name
dream_name = self.__name
# Create output folder for dream frames if needed
if not os.path.exists("./dream/" + dream_name):
os.makedirs("./dream/" + dream_name)
# Copy initial image as the first Frame
shutil.copyfile(self.__image, "./dream/" + dream_name + "/img_0.jpg")
# Open first frame and get its size
im = PIL.Image.open(self.__image)
x_size, y_size = im.size
# Dream for at most max_count frames
created_count = 0
max_count = 30 * 60 * 15 # Max of 15 min at 30 FPS
for i in range(0, 9999999999999999):
# Search for already existing frames
if os.path.isfile('dream/{}/img_{}.jpg'.format(dream_name, i + 1)):
print('{} already exists, continuing along...'.format(i + 1))
else:
# Define layer boundaries
starting_layer = 1
max_layer = 11
change_after = 30
# Calculate current layer - auto increase layers over time / over i
layer = min(
int((1 / change_after) * i) + starting_layer, max_layer)
print("Enhancing layer {}".format(layer))
layer_tensor = model.layer_tensors[layer]
# Loading image
img_result = load_image(
filename='dream/{}/img_{}.jpg'.format(dream_name, i))
# Define zoom speed in pixels
x_trim = 2
y_trim = 1
# Zoom image
img_result = img_result[0 + x_trim:y_size - y_trim,
0 + y_trim:x_size - x_trim]
img_result = cv2.resize(img_result, (x_size, y_size))
# Use these to modify the general colors and brightness of results.
# results tend to get dimmer or brighter over time, so you want to
# manually adjust this over time.
# +2 is slowly dimmer
# +3 is slowly brighter
img_result[:, :, 0] += 2 # reds
img_result[:, :, 1] += 2 # greens
img_result[:, :, 2] += 2 # blues
# Again make sure to keep pixel values in range
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
# Recursively optimize / dream image with 2 repeats per frame
img_result = recursive_optimize(layer_tensor=layer_tensor,
image=img_result,
num_iterations=2,
step_size=1.0,
rescale_factor=0.5,
num_repeats=1,
blend=0.2)
# Clip again
img_result = np.clip(img_result, 0.0, 255.0)
img_result = img_result.astype(np.uint8)
# Performing histogram equalizaiton
img_yuv = cv2.cvtColor(img_result, cv2.COLOR_BGR2YUV)
# equalize the histogram of the Y channel
img_yuv[:, :, 0] = cv2.equalizeHist(img_yuv[:, :, 0])
# convert the YUV image back to RGB format
equalized_image = cv2.cvtColor(img_yuv, cv2.COLOR_YUV2BGR)
img_result = cv2.addWeighted(img_result, 0.98, equalized_image,
0.02, 0)
# Sharpen n times
for s in range(0):
blurred = cv2.GaussianBlur(img_result, (3, 3), 0)
img_result = cv2.addWeighted(img_result, 1.5, blurred,
-0.5, 0)
# Generate image from numpy array and save it into dream folder
result = PIL.Image.fromarray(img_result, mode='RGB')
result.save('dream/{}/img_{}.jpg'.format(dream_name, i + 1))
created_count += 1
if created_count > max_count:
break
