def is_apply_all_expr(expr_str):
match = re.findall('(?<=apply-all \[)(.*)] to (.*)', expr_str)
if (len(match) != 1):
raise hiphop_error("ParserError", 'Invalid syntax for `apply-all` expression.')
match_funcs, match_id = match[0]
lambda_funcs = []
new_funcs = match_funcs.split(",")
for new_func in new_funcs:
new_lambda = make_lambda_func(new_func.strip())
if (isinstance(new_lambda, hiphop_error)):
raise hiphop_error("ParserError", 'Unable to make lambda function for {}'.format(new_func))
lambda_funcs.append(new_lambda)
return apply_all_expr(lambda_funcs, match_id)
def openfile(filename, id):
# print("Open file function called. Parameters: {}, {}".format(filename, id))
img = cv2.imread(filename)
if (img is None):
raise hiphop_error("OpenImageError", "Filename does not exist.")
saved_vars.add_var(id, img)
def is_save_expr(expr_str):
if 'genfilename' in expr_str:
gen = True
genMax = 2
else:
gen = False
genMax = 1
# print(gen)
expr_arr = expr_str.split('"', maxsplit=genMax)
expr_arr.insert(1, env_vars['wd'])
if gen:
fileType = expr_arr[3]
newFile = genFilename(fileType)
expr_arr[2] = newFile
# print(newFile)
expr_arr.pop()
# print(expr_arr)
expr_str = ''.join(expr_arr)
# print(expr_str)
match_id = re.findall('(?<=save )(.*)(?= as)', expr_str)
match_filename = re.findall('(?<=save ).*(?<= as ")(.*)"', expr_str)
# print("filename: {}; id: {}".format(match_filename[0], match_id[0]))
if (len(match_filename) != 1 or len(match_id) != 1):
raise hiphop_error("ParserError",
'Invalid syntax for `save` expression.')
else:
return save_expr(match_id[0], match_filename[0])
def parse_line(self, expr):
tokens = expr.split()
if tokens[0] == "open":
open_expr = is_open_expr(expr)
open_expr.evaluate()
elif tokens[0] == "reload":
load_expr = is_load_expr(expr)
load_expr.evaluate()
elif tokens[0] == "apply":
apply_expr = is_apply_expr(expr)
apply_expr.evaluate()
elif tokens[0] == "save":
save_expr = is_save_expr(expr)
save_expr.evaluate()
elif tokens[0] == "apply-all":
apply_all_expr = is_apply_all_expr(expr)
apply_all_expr.evaluate()
elif tokens[0] == "save-macro":
save_macro = is_save_macro_expr(expr)
save_macro.evaluate()
elif tokens[0] == "set":
set_expr = is_set_expr(expr)
set_expr.evaluate()
elif tokens[0] == "get":
get_expr = is_get_expr(expr)
get_expr.get()
# elif is_identifier(expr):
# pass
else:
raise hiphop_error("ParseError", "Unable to parse line")
def is_save_macro_expr(expr_str):
match = re.findall('(?<=save-macro \[)(.*)] as (.*)', expr_str)
if (len(match) != 1):
raise hiphop_error("ParserError", 'Invalid syntax for `save-macro` expression.')
match_funcs, match_id = match[0]
return save_macro_expr(match_funcs, match_id)
def impose(id, overlay, px, py):
img = saved_vars.get_var(id)
other_image = saved_vars.get_var(overlay)
# Mask ranges from 0 to width / height of overlay
mask = np.zeros(img.shape, dtype=np.bool)
mask[:other_image.shape[0], :other_image.shape[1]] = True
locs = np.where(mask != 0) # Get the non-zero mask locations
# Following conditional logic is equivalent to copyTo from other languages
# TODO implement overflow logic to cutoff instead of wrap
# Background is colored but overlay is grayscale
if len(img.shape) == 3 and len(other_image.shape) != 3:
img[locs[0] + px, locs[1] + py] = other_image[locs[0], locs[1], None]
# Both overlay and background are grayscale
elif (len(img.shape) == 3 and len(other_image.shape) == 3) or \
(len(img.shape) == 1 and len(other_image.shape) == 1):
img[locs[0] + px, locs[1] + py] = other_image[locs[0], locs[1]]
# Otherwise, we can't do this
else:
raise hiphop_error("InvalidFunctionError",
"Incompatible input and output dimensions.")
saved_vars.add_var(id, img, saved_vars.get_path(id))
return
def is_save_expr(expr_str):
match_id = re.findall('(?<=save )(.*)(?= as)', expr_str)
match_filename = re.findall('(?<=save ).*(?<= as ")(.*)"', expr_str)
# print("filename: {}; id: {}".format(match_filename[0], match_id[0]))
if (len(match_filename) != 1 or len(match_id) != 1):
raise hiphop_error("ParserError", 'Invalid syntax for `save` expression.')
else:
return save_expr(match_id[0], match_filename[0])
def is_load_expr(expr_str):
# even though reloading is just opening, the syntax is different,
# which requires this check
args = expr_str.split()
if len(args) > 2:
raise hiphop_error("ParserError",
"Invalid syntax for `reload` expression.")
else:
return open_expr(saved_vars.get_path(args[1]), args[1])
def is_apply_expr(expr_str):
match = re.findall('(?<=apply )(.*)( to )(.*)', expr_str)
if (len(match) != 1):
raise hiphop_error("ParserError", 'Invalid syntax for `apply` expression.')
match_func, _, match_id = match[0]
match_function= match_func.split()
match_funcname, match_args = match_function[0], match_function[1:]
# print("funcname: {}; args: {}; id: {}".format(match_funcname, match_args, match_id))
return apply_expr(match_funcname, match_args, match_id)
def is_open_expr(expr_str):
# For one line of the program, if valid program return object,
# otherwise False
match_filename = re.findall('(?<=open ")(.*)(?=" as)', expr_str)
match_id = re.findall('(?<=open ")*(?<=" as )(.*)$', expr_str)
if (len(match_filename) != 1 or len(match_id) != 1):
raise hiphop_error("ParserError", 'Invalid syntax for `open` expression.')
else:
return open_expr(match_filename[0], match_id[0])
def is_get_expr(expr_str):
# get expressions allow users to retrieve values of existing
# environment variables
args = expr_str.split()
if len(args) > 2:
raise hiphop_error("ParserError",
"Invalid syntax for `get` expression.")
else:
envVar = args[1]
return get_expr(envVar)
def __init__(self, funcs, id):
self.funcs = []
# Parse the string of functions into lambda functions
new_funcs = funcs.split(",")
for new_func in new_funcs:
lambda_func = make_lambda_func(new_func.strip())
if (isinstance(lambda_func, hiphop_error)):
raise hiphop_error("FunctionNotFound", "Could not create lambda function.")
self.funcs.append(lambda_func)
self.id = id
def is_open_expr(expr_str):
# For one line of the program, if valid program return object,
# otherwise False
expr_arr = expr_str.split('"', maxsplit=1)
expr_arr.insert(1, env_vars['wd'])
expr_str = ''.join(expr_arr)
# print(expr_str)
match_filename = re.findall('(?<=open ")(.*)(?=" as)', expr_str)
match_id = re.findall('(?<=open ")*(?<=" as )(.*)$', expr_str)
if (len(match_filename) != 1 or len(match_id) != 1):
raise hiphop_error("ParserError",
'Invalid syntax for `open` expression.')
else:
return open_expr(match_filename[0], match_id[0])
def make_lambda_func(str):
# From a string representation, creates a lambda function
# ie. grayscale 50
func_tokens = str.split(" ")
funcname, func_args = func_tokens[0], func_tokens[1:]
# print("Making lambda function - funcname: {}, args: {}".format(funcname, func_args))
if (funcname == "blur"):
if (len(func_args) != 1):
raise hiphop_eval_error("InvalidFunctionError", "Invalid number of arguments for `blur`")
return lambda img: blur(img, int(func_args[0]))
elif (funcname == "grayscale"):
if (len(func_args) != 0):
raise hiphop_eval_error("InvalidFunctionError", "Invalid number of arguments for `grayscale`")
return lambda img: grayscale(img)
elif (funcname == "erode"):
if (len(func_args) != 1):
raise hiphop_eval_error("InvalidFunctionError", "Invalid number of argments for `erode`")
return lambda img: erode(img, int(func_args[0]))
elif (funcname == "dilate"):
if (len(func_args) != 1):
raise hiphop_eval_error("InvalidFunctionError", "Invalid number of argments for `erode`")
return lambda img: dilate(img, int(func_args[0]))
elif (funcname == "outline"):
if (len(func_args) != 1):
raise hiphop_error("InvalidFunctionError", -1, "Invalid number of argments for `outline`")
return lambda img: outline(img, int(func_args[0]))
elif (funcname == "filtercolor"):
if (len(func_args) != 6):
raise hiphop_eval_error("InvalidFunctionError", "Invalid number of arguments for `filtercolor lowR lowG lowB highR highG highB`")
return lambda img: filtercolor(img, int(func_args[0]), int(func_args[1]), int(func_args[2]),
int(func_args[3]), int(func_args[4]), int(func_args[5]))
elif (funcname == "scale"):
if (len(func_args) != 2):
raise hiphop_eval_error("InvalidFunctionError", "Invalid number of argments for `scale`")
return lambda img: scale(img, float(func_args[0]), float(func_args[1]))
elif (funcname == "crop"):
if (len(func_args) != 4):
raise hiphop_eval_error("InvalidFunctionError", "Invalid number of arguments for `crop widthlow widthhigh heightlow heighthigh`")
return lambda img: crop(img, float(func_args[0]), float(func_args[1]), float(func_args[2]), float(func_args[3]))
else:
raise hiphop_eval_error("InvalidFunctionError", "Function name does not exist.")
def wave(id, direction, amplitude):
img = saved_vars.get_var(id)
img_output = np.zeros(img.shape, dtype=img.dtype)
rows, cols, mask = img.shape
if direction == "v":
# print("Dir v")
for i in range(rows):
for j in range(cols):
offset_x = int(int(amplitude) * np.sin(2 * 3.14 * i / 180))
offset_y = 0
if j + offset_x < rows:
img_output[i, j] = img[i, (j + offset_x) % cols]
else:
img_output[i, j] = 0
elif direction == "h":
# print("Dir h")
for i in range(rows):
for j in range(cols):
offset_x = 0
offset_y = int(int(amplitude) * np.sin(2 * 3.14 * j / 150))
if i + offset_y < rows:
img_output[i, j] = img[(i + offset_y) % rows, j]
else:
img_output[i, j] = 0
elif direction == "m":
for i in range(rows):
for j in range(cols):
offset_x = int(int(amplitude) * np.sin(2 * 3.14 * i / 150))
offset_y = int(int(amplitude) * np.cos(2 * 3.14 * j / 150))
if i + offset_y < rows and j + offset_x < cols:
img_output[i, j] = img[(i + offset_y) % rows,
(j + offset_x) % cols]
else:
img_output[i, j] = 0
else:
raise hiphop_error("InvalidFunctionError", "Invalid parameters.")
saved_vars.add_var(id, img_output, saved_vars.get_path(id))
return
