roxxers
/
VaporWaveArt
mirror of https://github.com/TimChinenov/VaporWaveArt
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
Browse Source

style(main): fixed several style issues 

Fixed style issues to make the project PEP8 conform
pull/5/head
the-wastl 5 years ago
parent
df8cc4aa80
commit
2cbcb0e3f2
1 changed files with 200 additions and 187 deletions
Split View Show Diff Stats
  1. +200
    -187
      main.py

+ 200
- 187
main.py View File

@@ -5,161 +5,168 @@
# To run the program call the following command in terminal
# python main.py

#To change the image being used, modify code on line 208
# To change the image being used, modify code on line 208
import cv2
import numpy as np
import random as rd
import os
from datetime import datetime

#The following function is used to determine the placement of
#text, at the moment it is incomplete
#function takes corners and text

# The following function is used to determine the placement of
# text, at the moment it is incomplete
# function takes corners and text
# and resturns top left corner that
# centers text and the angle needed
def posAndAngle(pts,text):
#find left top most coordinate
def pos_and_angle(pts):
# find left top most coordinate
dist = np.inf
left = pts[0]
# left = pts[0]
for cr in pts:
if (cr[0]**2+cr[1]**2)**0.5 < dist:
dist = (cr[0]**2+cr[1]**2)**0.5
left = cr
#first find angle
return 1;
if (cr[0] ** 2 + cr[1] ** 2) ** 0.5 < dist:
dist = (cr[0] ** 2 + cr[1] ** 2) ** 0.5
# left = cr
# first find angle
return 1


def addElements(img):
#get the number of elements
allfiles = os.listdir("elements/black/")
numFiles = len(allfiles)
#get dimensions of main image
imh,imw,imd = img.shape
#randomize number of elements added
numElements = rd.randint(2,4)
#create a set to prevent element repetition
def add_elements(img):
# get the number of elements
all_files = os.listdir("elements/black/")
num_files = len(all_files)
# get dimensions of main image
imh, imw, imd = img.shape
# randomize number of elements added
num_elements = rd.randint(2, 4)
# create a set to prevent element repetition
usedels = set({})
for num in range(numElements):
for num in range(num_elements):
file_name = "elements/black/ele_b"
choice = rd.randint(1,numFiles)
choice = rd.randint(1, num_files)
usedels.add(choice)
#run again if element has been used already
# run again if element has been used already
while choice not in usedels:
choice = rd.randint(1,numFiles)
choice = rd.randint(1, num_files)

file_name += str(choice) + ".png"
element = cv2.imread(file_name,-1)
element = cv2.imread(file_name, -1)
if element is None:
print(file_name+ " failed to load image")
print(file_name + " failed to load image")
continue
h,w,d = element.shape
#adjust size if too big
if h > imh*.5 or w > imw*.5:
element = cv2.resize(element,(int(.5*w),int(.5*h)))
h,w,d = element.shape
#refuse to use this image, if this failed
h, w, d = element.shape
# adjust size if too big
if h > imh * .5 or w > imw * .5:
element = cv2.resize(element, (int(.5 * w), int(.5 * h)))
h, w, d = element.shape
# refuse to use this image, if this failed
if h > imh or w > imw:
print("Element too big, moving on")
continue

#get x coord and y coord on the image
xpos = rd.randint(1,imw-w-1)
ypos = rd.randint(1,imh-h-1)
#make alpha channel
alpha_s = element[:,:,2]/255.0
# get x coord and y coord on the image
xpos = rd.randint(1, imw - w - 1)
ypos = rd.randint(1, imh - h - 1)
# make alpha channel
alpha_s = element[:, :, 2] / 255.0
alpha_1 = 1.0 - alpha_s
for c in range(0,3):
img[ypos:ypos+h,xpos:xpos+w,c] = (alpha_s*element[:,:,c]+alpha_1*img[ypos:ypos+h,xpos:xpos+w,c])
for c in range(0, 3):
img[ypos:ypos + h, xpos:xpos + w, c] = (
alpha_s * element[:, :, c] + alpha_1 * img[ypos:ypos + h, xpos:xpos + w, c])


def faceGlitch(img,face):
height,width,d = img.shape
#pixels segments of 40
div = rd.randint(10,100)
strp = int(round(face[3]/(div*1.0)))
numGlitches = face[3]/strp
for itr in range(0,numGlitches):
#play with the second parameter to increase "glitchiness"
rng = rd.randint(15,100)
rightExt = face[0]+face[2]+rng
leftExt = face[0]+face[2]-rng
#make sure extremes don't go out of bounds
if leftExt < 0:
leftExt = 0
if rightExt >= width:
rightExt = width
#randomize static direction
#1 moves left, 2 moves right
dec = rd.randint(1,2)
if dec%2 == 0:
backBound = face[0]+rng
def face_glitch(img, face):
height, width, d = img.shape
# pixels segments of 40
div = rd.randint(10, 100)
strp = int(round(face[3] / (div * 1.0)))
num_glitches = face[3] / strp
for itr in range(0, num_glitches):
# play with the second parameter to increase "glitchiness"
rng = rd.randint(15, 100)
right_ext = face[0] + face[2] + rng
left_ext = face[0] + face[2] - rng
# make sure extremes don't go out of bounds
if left_ext < 0:
left_ext = 0
if right_ext >= width:
right_ext = width
# randomize static direction
# 1 moves left, 2 moves right
dec = rd.randint(1, 2)
back_bound = face[0] + rng
if dec % 2 == 0:
diff = 0
#make corrections if glitch falls outside of image
if face[0]+face[2]+rng >= width:
diff = face[0]+face[2]+rng - (width)
img[face[1]+(itr*strp):face[1]+(itr*strp+strp),(face[0]+rng):rightExt] = img[face[1]+(itr*strp):face[1]+(itr*strp+strp),face[0]:face[0]+face[2]-diff]
# make corrections if glitch falls outside of image
if face[0] + face[2] + rng >= width:
diff = face[0] + face[2] + rng - width
img[face[1] + (itr * strp):face[1] + (itr * strp + strp), (face[0] + rng):right_ext] = \
img[face[1] + (itr * strp):face[1] + (itr * strp + strp), face[0]:face[0] + face[2] - diff]
else:
backBound = face[0]-rng
diff = 0
#make corrections if glitch falls outside of image
if backBound < 0:
diff = abs(backBound)
backBound = 0
img[face[1]+(itr*strp):face[1]+(itr*strp+strp),(backBound):leftExt] = img[face[1]+(itr*strp):face[1]+(itr*strp+strp),face[0]:face[0]+face[2]-diff]
# make corrections if glitch falls outside of image
if back_bound < 0:
diff = abs(back_bound)
back_bound = 0
img[face[1] + (itr * strp):face[1] + (itr * strp + strp), back_bound:left_ext] = \
img[face[1] + (itr * strp):face[1] + (itr * strp + strp), face[0]:face[0] + face[2] - diff]

def faceDrag(img,face):
h,w,d = img.shape
#0 is horizontal 1 is veritical
ornt = rd.randint(0,2)

def face_drag(img, face):
h, w, d = img.shape
# 0 is horizontal 1 is veritical
ornt = rd.randint(0, 2)
if ornt == 0:
line = rd.randint(face[1]+25,face[1]+face[3]-25)
#0 is up 1 is down
dir = rd.randint(0,2)
if dir == 0:
img[0:line,face[0]:face[0]+face[2]] = img[line,face[0]:face[0]+face[2]]
line = rd.randint(face[1] + 25, face[1] + face[3] - 25)
# 0 is up 1 is down
direction = rd.randint(0, 2)
if direction == 0:
img[0:line, face[0]:face[0] + face[2]] = img[line, face[0]:face[0] + face[2]]
else:
img[line:h,face[0]:face[0]+face[2]] = img[line,face[0]:face[0]+face[2]]
img[line:h, face[0]:face[0] + face[2]] = img[line, face[0]:face[0] + face[2]]
else:
line = rd.randint(face[0]+25,face[0]+face[2]-25)
#0 is left 1 is right
dir = rd.randint(0,2)
if dir == 0:
img[face[1]:face[1]+face[3],0:line] = img[face[1]:face[1]+face[3],line:line+1]
line = rd.randint(face[0] + 25, face[0] + face[2] - 25)
# 0 is left 1 is right
direction = rd.randint(0, 2)
if direction == 0:
img[face[1]:face[1] + face[3], 0:line] = img[face[1]:face[1] + face[3], line:line + 1]
else:
img[face[1]:face[1]+face[3],line:w] = img[face[1]:face[1]+face[3],line:line+1]
img[face[1]:face[1] + face[3], line:w] = img[face[1]:face[1] + face[3], line:line + 1]


def eyeCensor(img,eyes):
def eye_censor(img, eyes):
if len(eyes) < 2:
print("Failed to generate censor, less than two eyes present")
return
cenH = 40
#get centroids of eyes
c1 = np.array([eyes[0][0] + eyes[0][2]/2.0,eyes[0][1] + eyes[0][3]/2.0])
c2 = np.array([eyes[1][0] + eyes[1][2]/2.0,eyes[1][1] + eyes[1][3]/2.0])
#find the corners of the bar
#find vector of the two centroids
vec = c1-c2
#unitize vector
vec = vec/(vec[0]**2.0+vec[1]**2.0)**0.5
#perpendicular vector
perVec = np.array([vec[1],vec[0]*(-1)])
#change these value to adjust height and width of
#censor bar
wEx = 40
# cenH = 40
# get centroids of eyes
c1 = np.array([eyes[0][0] + eyes[0][2] / 2.0, eyes[0][1] + eyes[0][3] / 2.0])
c2 = np.array([eyes[1][0] + eyes[1][2] / 2.0, eyes[1][1] + eyes[1][3] / 2.0])
# find the corners of the bar
# find vector of the two centroids
vec = c1 - c2
# unitize vector
vec = vec / (vec[0] ** 2.0 + vec[1] ** 2.0) ** 0.5
# perpendicular vector
per_vec = np.array([vec[1], vec[0] * (-1)])
# change these value to adjust height and width of
# censor bar
w_ex = 40
mag = 75
cr1 = perVec*wEx+c1
cr2 = c1 - perVec*wEx
cr3 = perVec*wEx+c2
cr4 = c2 - perVec*wEx
cr1 += vec*mag
cr2 += vec*mag
cr3 -= vec*mag
cr4 -= vec*mag
#round all values
pts = np.array([cr1,cr2,cr4,cr3])
cv2.fillPoly(img,np.array([pts],dtype=np.int32),(0,0,0))
cr1 = per_vec * w_ex + c1
cr2 = c1 - per_vec * w_ex
cr3 = per_vec * w_ex + c2
cr4 = c2 - per_vec * w_ex
cr1 += vec * mag
cr2 += vec * mag
cr3 -= vec * mag
cr4 -= vec * mag
# round all values
pts = np.array([cr1, cr2, cr4, cr3])
cv2.fillPoly(img, np.array([pts], dtype=np.int32), (0, 0, 0))
#########################################################
#The following code is incomplete. It's purpose is to randomly
#add text to the censor bar
#roll to see if to add text
# The following code is incomplete. It's purpose is to randomly
# add text to the censor bar
# roll to see if to add text
# textc = rd.randint(0,2)
# textc = 1
# if textc == 1:
@@ -174,122 +181,124 @@ def eyeCensor(img,eyes):
# cv2.putText(img,use,(int(cr1[0]),int(cr1[1])), font, 1,(255,255,255),2,cv2.LINE_AA)
############################################################

def eyeDrag(img,eyes):
#make sure there are only two eyes per face

def eye_drag(img, eyes):
# make sure there are only two eyes per face
if len(eyes) > 2:
eye1 = eyes[0]
eye2 = eyes[0]
size = 0
for itr in range(0,len(eyes)):
if eyes[itr][2]*eyes[itr][3] > size:
size = eyes[itr][2]*eyes[itr][3]
for itr in range(0, len(eyes)):
if eyes[itr][2] * eyes[itr][3] > size:
size = eyes[itr][2] * eyes[itr][3]
eye1 = eyes[itr]
size = 0
for itr in range(0,len(eyes)):
if eyes[itr][2]*eyes[itr][3] > size and not np.array_equal(eyes[itr],eye1):
size = eyes[itr][2]*eyes[itr][3]
for itr in range(0, len(eyes)):
if eyes[itr][2] * eyes[itr][3] > size and not np.array_equal(eyes[itr], eye1):
size = eyes[itr][2] * eyes[itr][3]
eye2 = eyes[itr]
eyes = [eye1,eye2]
eyes = [eye1, eye2]

#there should only be two eyes now
# there should only be two eyes now
for eye in eyes:
#find width of eye
# find width of eye
iwid = eye[2]
strp = int(round(iwid/20.))
numGlitches = int(eye[2]/strp)
line = rd.randint(1,eye[3])
strp = int(round(iwid / 20.))
num_glitches = int(eye[2] / strp)
line = rd.randint(1, eye[3])
line += eye[1]
line = int(eye[1] + eye[3]/2)
for itr in range(0,numGlitches):
#edit the second parameter to change eye drop chance
drop = rd.randint(10,200)
#if the line drop is too low, shorten it
line = int(eye[1] + eye[3] / 2)
for itr in range(0, num_glitches):
# edit the second parameter to change eye drop chance
drop = rd.randint(10, 200)
# if the line drop is too low, shorten it
if line + drop > img.shape[0]:
drop = img.shape[0] - line
img[line:line+drop,eye[0]+itr*strp:eye[0]+itr*strp+strp] = img[line,eye[0]+itr*strp:eye[0]+itr*strp+strp]
img[line:line + drop, eye[0] + itr * strp:eye[0] + itr * strp + strp] = \
img[line, eye[0] + itr * strp:eye[0] + itr * strp + strp]


if __name__ == "__main__":
#seed the random generator
def main():
# seed the random generator
rd.seed(datetime.now())
#load files for facial and eye cascade
# load files for facial and eye cascade
face_cascade = cv2.CascadeClassifier('cascade/haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('cascade/haarcascade_eye.xml')

#load main image from local file
# load main image from local file
img = cv2.imread("testImgs/testface9.png")
height,width,depth = img.shape
# height, width, depth = img.shape

#turn image gray for detecting face and eyes
# turn image gray for detecting face and eyes
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#find all the faces in the image
# find all the faces in the image
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

#go through each face
# go through each face
for face in faces:
y = face[1]
x = face [0]
w = face [2]
h = face [3]
roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]
#find each eye. Modify second and third parameter if
#feature detection is poor
x = face[0]
w = face[2]
h = face[3]
roi_gray = gray[y:y + h, x:x + w]
# roi_color = img[y:y + h, x:x + w]
# find each eye. Modify second and third parameter if
# feature detection is poor
eyes = eye_cascade.detectMultiScale(roi_gray, 1.2, 6)
for eye in eyes:
eye[0] += face[0]
eye[1] += face[1]

#randomize which face modification will be performed
faceMod = rd.randint(0,4)
# randomize which face modification will be performed
face_mod = rd.randint(0, 4)
# if there are no eyes, just re-roll
if faceMod >= 3 and len(eyes) == 0:
faceMod = rd.randint(0,2)
if face_mod >= 3 and len(eyes) == 0:
face_mod = rd.randint(0, 2)

#0 - no mod
#1 - face glitch
#2 - face drag
#3 - eye censor
#4 - eye drag
if faceMod == 1:
faceGlitch(img,face)
elif faceMod == 2:
faceDrag(img,face)
elif faceMod == 3:
eyeCensor(img,eyes)
elif faceMod == 4:
eyeDrag(img,eyes)
# 0 - no mod
# 1 - face glitch
# 2 - face drag
# 3 - eye censor
# 4 - eye drag
if face_mod == 1:
face_glitch(img, face)
elif face_mod == 2:
face_drag(img, face)
elif face_mod == 3:
eye_censor(img, eyes)
elif face_mod == 4:
eye_drag(img, eyes)

# Add elements to image
addElements(img)
#if there are no faces, just add more elements!
add_elements(img)
# if there are no faces, just add more elements!
if len(faces) < 1:
addElements(img)
add_elements(img)

#randomize if high contrast is used
choice = rd.randint(0,1)
# randomize if high contrast is used
choice = rd.randint(0, 1)
if choice == 1:
#edit alpha and beta to adjust contrast levels
# edit alpha and beta to adjust contrast levels
img = cv2.convertScaleAbs(img, alpha=1.2, beta=35)

#randomize if high noise is used
choice = rd.randint(0,1)
# randomize if high noise is used
choice = rd.randint(0, 1)
if choice == 1:
row,col,ch= img.shape
row, col, ch = img.shape
mean = 0
#edit var to modify the amount of noise in the image
# edit var to modify the amount of noise in the image
var = 15
sigma = var**1
gauss = np.random.normal(mean,sigma,(row,col,ch))
gauss = gauss.reshape(row,col,ch)
sigma = var ** 1
gauss = np.random.normal(mean, sigma, (row, col, ch))
gauss = gauss.reshape(row, col, ch)
noisy = (img + gauss)
cv2.normalize(noisy, noisy, 0, 1, cv2.NORM_MINMAX)
cv2.normalize(noisy, noisy, 0, 1, cv2.NORM_MINMAX)
img = noisy

#The following code is useful to determine if faces and eyes
#are being read correctly. Uncommenting will draw boxes around
#found features.
# The following code is useful to determine if faces and eyes
# are being read correctly. Uncommenting will draw boxes around
# found features.
# for (x,y,w,h) in faces:
# cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
# roi_gray = gray[y:y+h, x:x+w]
@@ -298,6 +307,10 @@ if __name__ == "__main__":
# eyes = eye_cascade.detectMultiScale(roi_gray, 1.2, 6)
# for (ex,ey,ew,eh) in eyes:
# cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
cv2.namedWindow("pic",cv2.WINDOW_NORMAL)
cv2.imshow("pic",img)
cv2.namedWindow("pic", cv2.WINDOW_NORMAL)
cv2.imshow("pic", img)
cv2.waitKey(0)


if __name__ == "__main__":
main()

Write Preview
Loading…
Cancel
Save