def meme(self, top_text=" ", bottom_text=" ", filename=""):
if len(top_text) < 2:
top_text = " "
if len(bottom_text) < 2:
bottom_text = " "
img = ImageOps.expand(Image.open(filename), border=80, fill='white')
image_size = img.size
# find biggest font size that works
font_size = int(image_size[1] / 10)
font = ImageFont.truetype(
STATICFILES_DIRS[0] + "/fonts/impact-opt.ttf", font_size)
top_text_size = font.getsize(top_text)
bottom_text_size = font.getsize(bottom_text)
while top_text_size[0] > image_size[0] - 20 or bottom_text_size[
0] > image_size[0] - 20:
font_size = font_size - 1
font = ImageFont.truetype(
STATICFILES_DIRS[0] + "/fonts/Impact.ttf", font_size)
top_text_size = font.getsize(top_text)
bottom_text_size = font.getsize(bottom_text)
# find top centered position for top text
top_text_x = (image_size[0] / 2) - (top_text_size[0] / 2)
top_text_y = 0
top_text_position = (top_text_x, top_text_y)
# find bottom centered position for bottom text
bottom_text_x = (image_size[0] / 2) - (bottom_text_size[0] / 2)
bottom_text_y = image_size[1] - bottom_text_size[1]
bottom_text_position = (bottom_text_x, bottom_text_y)
draw = ImageDraw.Draw(img)
# draw outlines
# there may be a better way
# outline_range = int(font_size / 10)
outline_range = 0
for x in range(-outline_range, outline_range + 1):
for y in range(-outline_range, outline_range + 1):
draw.text((top_text_position[0] + x, top_text_position[1] + y),
top_text, (0, 0, 0),
font=font)
draw.text(
(bottom_text_position[0] + x, bottom_text_position[1] + y),
bottom_text, (0, 0, 0),
font=font)
draw.text(top_text_position, top_text, (0, 0, 0), font=font)
draw.text(bottom_text_position, bottom_text, (0, 0, 0), font=font)
output_path = str(uuid.uuid4().hex) + ".png"
img.save(output_path)
obj = Upload(provider=OBJECT_STORAGE_PROVIDER,
credentials=OBJECT_STORAGE_CREDENTIALS,
file=output_path)
cloud_url = obj.upload_file()
os.remove(os.getcwd() + '/' + output_path)
return cloud_url
def meme(self, image_path):
# base_dir = BASE_DIR
# base_dir += '/' if not base_dir == '/' else ''
image_path = image_path
# thug life meme mask image path
mask_path = STATICFILES_DIRS[0] + "/images/mask.png"
# haarcascade path
casc_path = STATICFILES_DIRS[
0] + "/xml/haarcascade_frontalface_default.xml"
# cascade classifier object
face_cascade = cv2.CascadeClassifier(casc_path)
# read input image
image = cv2.imread(image_path)
print(os.listdir())
print(image, image_path)
# convert image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# detect faces in grayscale image
faces = face_cascade.detectMultiScale(gray, 1.15)
# open input image as PIL image
background = Image.open(image_path)
# paste mask on each detected face in input image
for (x, y, w, h) in faces:
# just to show detected faces
cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2)
# imshow('face detected', image)
# waitKey(50)
# open mask as PIL image
mask = Image.open(mask_path)
# resize mask according to detected face
mask = mask.resize((w, h), Image.ANTIALIAS)
# define o
# ffset for mask
offset = (x, y)
# paste mask on background
background.paste(mask, offset, mask=mask)
# paste final thug life meme
file_name = os.path.basename(image_path)
output_path = "thug_" + str(file_name.split(".")[0]) + ".png"
background.save(output_path)
obj = Upload(provider=OBJECT_STORAGE_PROVIDER,
credentials=OBJECT_STORAGE_CREDENTIALS,
file=output_path)
cloud_url = obj.upload_file()
os.remove(os.getcwd() + '/' + output_path)
return cloud_url
def __upload_avatar(self):
""" Upload the avatar """
form = self.params
self.user['image_tmp'] = form['image_uploaded']
if self.message or not self.user['image_tmp']:
return False
file_name = os.path.join(UP_AVATARS_TMP_FOLDER, self.user['image_tmp'])
if os.path.exists(file_name):
with open(file_name) as image:
up = Upload(self.user['username'], image)
up.avatar_upload(self.user['_id'])
self.list_images = up.names_list
return True
self.message = g.users_msg('error_upload_2')
return False
def upload_avatar():
""" """
name = secure_filename(request.headers.get('X-File-Name'))
extension = name.rsplit('.', 1)[1].lower()
up = Upload()
path_image = up.ajax_upload(UP_AVATARS_TMP_FOLDER, extension)
if not up.allowed_file():
success = False
message = g.users_msg('error_upload_1')
else:
up.thumb((128, 128), os.path.join(UP_AVATARS_TMP_FOLDER, path_image))
if path_image != 'error':
success = True
message = path_image
data = {"success": success, "message": message}
return jsonify(data)
def upload(self):
# recv info code {'info': "upload", "code": "", "filename": filename, "filesize": filesize, "hash": fileHashCode }
# check file is exist
try:
fileInfo = self.session.query(self.file).filter(
and_(self.file.uid == self.userid,
self.file.hashcode == self.recvInfo['hash'])).first()
# self.session.add(self.file(uid= self.userid, name= downloadFileName, size= downloadFileSize, hashcode= downloadFileHashCode,updatetime= currentTime, postfix= postfix))
except Exception as e:
remsg = {
'info': 'upload',
'code': self.recvInfo['code'],
'status': '1',
'reason': str(e)
}
self.sendMsg(remsg)
else:
if fileInfo:
self.log.info(fileInfo.__dict__)
remsg = {
'info': 'upload',
'code': self.recvInfo['code'],
'status': '1',
'reason': 'file has exsited'
}
self.sendMsg(remsg)
else:
self.log.info('start create data of file')
uploadFileInfo = self.recvInfo
fileHashCode = uploadFileInfo['hash']
fileName, postfix = utils.seperateFileName(
uploadFileInfo['filename'])
fileSize = uploadFileInfo['filesize']
currentTime = utils.getCurrentTime()
encryption = uploadFileInfo['encryption']
encryption_type = uploadFileInfo['encryption_type']
encsize = uploadFileInfo['encsize']
# to do
# to determeine whether have repeat value in db
try:
self.session.add(
self.file(uid=self.userid,
name=fileName,
size=fileSize,
encryption=encryption,
encryption_type=encryption_type,
encsize=encsize,
hashcode=fileHashCode,
updatetime=currentTime,
postfix=postfix))
except Exception as e:
remsg = {
'info': 'upload',
'code': uploadFileInfo['code'],
'status': '1',
'reason': str(e)
}
self.sendMsg(remsg)
authToken = utils.generateAuthToken()
if self.settings.default.cluster == '1':
data_channel_info = ('127.0.0.1', 2334)
self.r.set(authToken, 0)
else:
retInfo = self.createDataSock() #return (int, port)
if retInfo[0] == 1:
self.log.info('createDataSock fails: {}'.format(
retInfo[1]))
data_channel_info = (self.settings.server.bind_address,
retInfo[1])
remsg = {
'info': 'upload',
'code': uploadFileInfo['code'],
'status': '0',
'token': authToken,
'dataAddress': data_channel_info
}
retInfo = self.sendMsg(remsg)
if retInfo[0] == 1:
self.log.info('sendMsg fails: {}'.format(retInfo[1]))
elif self.settings.default.cluster != '1':
if uploadFileInfo['encryption'] == 1:
uploadFileSize = uploadFileInfo['encsize']
else:
uploadFileSize = uploadFileInfo['filesize']
self.uploadProcess = Upload(self.sslContext,
self.dataSocket, fileHashCode,
uploadFileSize, authToken)
self.uploadProcess.start()
def upload(self, filepath):
filename = utils.getBaseNameByPath(filepath)
filesize = utils.getSizeByPath(filepath)
# check if need to encrypt files
if self.encryption is True:
retInfo = self.crypt.encrypt(str(self.encryption_cipher).strip(),
filepath,
mode=str(
self.encryption_type).strip())
if retInfo[0] == 0:
enctryptedFilePath = retInfo[1]
else:
return (1, retInfo[1])
encryptedFileSize = utils.getSizeByPath(enctryptedFilePath)
fileHashCode = utils.calculateHashCodeForFile(enctryptedFilePath)
uploadCmdCode = {
'info': "upload",
"code": "",
"filename": filename,
"filesize": filesize,
"encryption": 1,
"encsize": encryptedFileSize,
"encryption_type": self.encryption_type,
"hash": fileHashCode
}
else:
fileHashCode = utils.calculateHashCodeForFile(filepath)
uploadCmdCode = {
'info': "upload",
"code": "",
"filename": filename,
"filesize": filesize,
"encryption": 0,
"encryption_type": "0",
"encsize": "0",
"hash": fileHashCode
}
uploadInfo = self.sendMsg(uploadCmdCode)
if uploadInfo[0] == 1:
self.log.info(uploadInfo[1])
else:
retInfo = self.recvMsg()
if retInfo[0] == 1:
return (1, retInfo[1])
elif self.recvInfo['status'] == '0':
uploadAuthCode = self.recvInfo['token']
remoteDataInfo = self.recvInfo['dataAddress']
self.log.info(
'recv upload auth token is : {}'.format(uploadAuthCode))
self.log.info('remote open data info : {}:{}'.format(
remoteDataInfo[0], remoteDataInfo[1]))
if self.encryption:
filepath = enctryptedFilePath
self.uploadProcess = Upload(remoteDataInfo, filepath,
uploadAuthCode, uploadCmdCode)
self.uploadProcess.signal.p.connect(self.setUpbarValue)
self.uploadProcess.start()
return (0, 'ok')
else:
return (1, self.recvInfo['reason'])
