xlanro00/BP_DP-xlanro00
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added the option to pass filter parameters from command line and config, reworked most filters to match.

Browse Source
This commit is contained in:
Rostislav Lán
2022-12-19 18:29:33 +01:00
parent e2e5810c40
commit e7fef8c6b7
2 changed files with 148 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
src/filters.py
View File

@ -10,16 +10,25 @@ import cv2 as cv
# Parent class for all the filters
class filter:
'''
Parent class for all the filters
'''
def __init__(self, img):
self.img = img
class average(filter):
class convolve(filter):
''' Convolve using custom kernel,
if no kernel is given, use default 3x3 kernel for averaging'''
def __init__(self, img):
super().__init__(img)
def apply(self):
kernel = np.ones((3, 3), np.float32) / 9
def apply(self, params):
# Set default values
ksize = int(params["ksize"]) if params["ksize"] else 3
kernel = np.array(params["kernel"]) if params["kernel"] else np.ones((ksize, ksize), np.float32) / np.sqrt(ksize)
#print("with params: " + " ksize: " + str(ksize) + " kernel: \n" + str(kernel))
self.img = cv.filter2D(self.img, -1, kernel)
@ -27,88 +36,111 @@ class blur(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
self.img = cv.blur(self.img, (3, 3))
def apply(self, params):
# Set default values
if(params["anchor"]):
try:
anchor = tuple(map(int, params["anchor"].split(',')))
except AttributeError:
anchor = tuple(params["anchor"])
else:
anchor = (-1, -1)
ksize = int(params["ksize"]) if params["ksize"] else 3
#print("with params: " + " ksize: " + str(ksize) + " anchor: " + str(anchor))
self.img = cv.blur(self.img, ksize=(ksize, ksize), anchor=anchor)
class gaussian(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
self.img = cv.GaussianBlur(self.img, (3, 3), 0)
def apply(self, params):
# Set default values
ksize = int(params["ksize"]) if params["ksize"] else 3
sigmaX = float(params["sigmaX"]) if params["sigmaX"] else 0
sigmaY = float(params["sigmaY"]) if params["sigmaY"] else 0
#print("with params: " + " ksize: " + str(ksize) + " sigmaX: " + str(sigmaX) + " sigmaY: " + str(sigmaY))
self.img = cv.GaussianBlur(self.img, (ksize, ksize), sigmaX, sigmaY)
class median(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
self.img = cv.medianBlur(self.img, 1)
def apply(self, params):
# Set default values
ksize = int(params["ksize"]) if params["ksize"] else 3
#print("with params: " + " ksize: " + str(ksize))
self.img = cv.medianBlur(self.img, ksize)
class bilateral(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
self.img = cv.bilateralFilter(self.img, 1, 75, 75)
def apply(self, params):
# Set default values
d = int(params["d"]) if params["d"] else 1
sigmaColor = int(params["sigmaColor"]) if params["sigmaColor"] else 75
sigmaSpace = int(params["sigmaSpace"]) if params["sigmaSpace"] else 75
#print("with params: " + " d: " + str(d) + " sigmaColor: " + str(sigmaColor) + " sigmaSpace: " + str(sigmaSpace))
self.img = cv.bilateralFilter(self.img, d, sigmaColor, sigmaSpace)
class denoise(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
pass
#does not work
def apply(self, params):
# Set default values
h = int(params["h"]) if params["h"] else 20
tWS = int(params["templateWindowSize"]) if params["templateWindowSize"] else 7
sWS = int(params["searchWindowSize"]) if params["searchWindowSize"] else 21
#print("with params: " + " h: " + str(h) + " tWS: " + str(tWS) + " sWS: " + str(sWS))
self.img = np.uint8(self.img)
self.img = cv.fastNlMeansDenoising(
self.img, h=10, searchWindowSize=21, templateWindowSize=7)
self.img = cv.fastNlMeansDenoising(self.img, h, tWS, sWS)
class sharpen(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
def apply(self, params):
# Set default values
kernel = np.matrix(params["kernel"]) if params["kernel"] else np.array(
[[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
#print("with params: " + " kernel: \n" + str(kernel))
self.img = cv.filter2D(self.img, ddepth=-1, kernel=kernel)
class erode(filter):
class morph(filter):
''' General morphological operations.
Can be used with MORPH_OPEN, MORPH_CLOSE, MORPH_DILATE, MORPH_ERODE as op.
'''
def __init__(self, img):
super().__init__(img)
def apply(self):
kernel = np.ones((3, 3), np.uint8)
self.img = cv.erode(self.img, kernel, 1)
def apply(self, params):
# Set default values
kernel = np.matrix(params["kernel"]) if params["kernel"] else np.ones((3, 3), np.uint8)
iterations = int(params["iterations"]) if params["iterations"] else 1
op = getattr(cv, params["op"]) if params["op"] else cv.MORPH_OPEN
if(params["anchor"]):
try:
anchor = tuple(map(int, params["anchor"].split(',')))
except AttributeError:
anchor = tuple(params["anchor"])
else:
anchor = (-1, -1)
class dilate(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
kernel = np.ones((3, 3), np.uint8)
self.img = cv.dilate(self.img, kernel, 1)
# Erosion, then dilatation
class opening(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
kernel = cv.getStructuringElement(cv.MORPH_RECT, (3, 3))
self.img = cv.morphologyEx(self.img, cv.MORPH_CLOSE, kernel)
# Dilatation, then erosion
class closing(filter):
def __init__(self, img):
super().__init__(img)
def apply(self):
kernel = cv.getStructuringElement(cv.MORPH_RECT, (3, 3))
self.img = cv.morphologyEx(self.img, cv.MORPH_OPEN, kernel)
#print("with params: " + " kernel: \n" + str(kernel) + " anchor: " + str(anchor) + " iterations: " + str(iterations) + " op: " + str(op))
self.img = cv.morphologyEx(
self.img, op=op, kernel=kernel, anchor=anchor, iterations=iterations)

92
src/main.py
View File

@ -23,29 +23,42 @@ class apply_filters:
def __init__(self):
# Parse arguments from command line
self.parse_arguments()
self.input_file = self.args.input_file
self.output_file = self.args.output_file
self.dpi = self.args.dpi
self.filters = self.args.filters
self.mirror = self.args.mirror if self.args.mirror else 0
self.params = {}
self.filters = []
# Parse configuration from json file
if self.args.config:
self.config_file = self.args.config[0]
self.preset_name = self.args.config[1]
self.config = json.load(open(self.config_file))
print("Config loaded")
self.parse_conf()
# If no config file given, expect filters in command line
else:
self.filters = self.args.filters
print("No config file given, using command line arguments")
i = 0
for filter in self.args.filters:
if filter.find('=') == -1:
self.filters.append(filter)
i += 1
self.params[i] = {}
else:
key, value = filter.split('=')
self.params[i][key] = value
self.parse_params(self.params[i])
self.input_file = self.args.input_file
self.output_file = self.args.output_file
self.dpi = self.args.dpi
self.mirror = self.args.mirror if self.args.mirror else 0
#read as numpy.array
self.img = plt.imread(self.input_file)
self.img = cv.imread(self.input_file, cv.IMREAD_GRAYSCALE)
self.width = self.img.shape[1]
self.height = self.img.shape[0]
print(self.width, self.height)
#print(self.width, self.height)
fig = plt.figure(figsize = (self.width, self.height),
frameon = False, dpi = self.dpi / 100) # dpi is in cm
@ -57,14 +70,38 @@ class apply_filters:
if self.mirror:
self.mirror_image()
# Apply all filters
self.apply_filter(fig, ax)
# Apply all filters and save image
self.apply_filter()
self.save_image(fig, ax)
def check_param(self, params, key):
try:
params[key] = params[key]
except KeyError:
params[key] = None
def parse_params(self, params):
possible_params = {"h", "searchWindowSize","templateWindowSize",
"ksize", "kernel", "sigmaX" , "sigmaY",
"sigmaColor", "sigmaSpace", "d", "anchor", "iterations", "op"}
for key in possible_params:
self.check_param(params, key)
def parse_conf(self):
# Parse configuration file if given.
try:
self.filters = self.config[self.preset_name]
filter_array = self.config[self.preset_name]
for i, filter in enumerate(range(len(filter_array)), start=1):
self.filters.append(filter_array[filter]["name"])
self.params[i] = {}
for attribute, value in filter_array[filter].items():
if attribute != "name":
self.params[i][attribute] = value
self.parse_params(self.params[i])
except(KeyError):
print("Preset not found", file = sys.stderr)
@ -72,25 +109,27 @@ class apply_filters:
def parse_arguments(self):
# Parse arguments
parser = ap.ArgumentParser(prog = 'main.py', description =
'Program for processing a 2D image into 3D fingerprint.')
parser = ap.ArgumentParser(prog = 'main.py',
description = 'Program for processing a 2D image into 3D fingerprint.',
usage='%(prog)s [-h] [-m | --mirror | --no-mirror] input_file output_file dpi ([-c config_file preset | --config config_file preset] | [filters ...])')
# positional arguments
parser.add_argument("input_file", type = str, help = "Location with input file")
parser.add_argument("output_file", type = str, help = "Output file location")
parser.add_argument("dpi", type = int, help = "Scanner dpi")
parser.add_argument("input_file", type = str, help = "location with input file")
parser.add_argument("output_file", type = str, help = "output file location")
parser.add_argument("dpi", type = int, help = "scanner dpi")
# boolean switch
parser.add_argument('-m', "--mirror", help = "Mirror input image",
parser.add_argument('-m', "--mirror", help = "mirror input image",
type = bool, action = ap.BooleanOptionalAction)
# file with configuration containing presets, new preset name
# pair argument - give both or none
parser.add_argument('--config', nargs=2, metavar=('config_file', 'preset'),
help='Config file with presets, name of the preset')
parser.add_argument('-c','--config', nargs = 2, metavar = ('config_file', 'preset'),
help = 'pair: name of the config file with presets, name of the preset')
# array of unknown length, all filter names saved inside
parser.add_argument('filters', type = str, nargs = '*', help = "List of filter names")
parser.add_argument('filters', type = str, nargs = '*',
help="list of filter names and their parameters in form [filter_name1 param1=value1 param2=value2 filter_name2 param1=value1...]")
self.args = parser.parse_args()
@ -104,10 +143,7 @@ class apply_filters:
def resize_image(self):
# open image as python image object
print("Resize image", file = sys.stderr)
self.convert_dpi()
self.img = self.img.resize((np.array(self.width, self.height)).astype(int))
@ -119,16 +155,16 @@ class apply_filters:
self.img = cv.flip(self.img, 1) # 1 for vertical mirror
def apply_filter(self, fig, ax):
def apply_filter(self):
if len(self.filters) == 0:
# No filter given, just save the image
pass
else:
for filter_name in self.filters:
# Apply all filters
for i, filter_name in enumerate(self.filters):
filter = self.filter_factory(filter_name)
filter.apply(self)
self.save_image(fig, ax)
filter.apply(self, self.params[i+1])
def print_size(self, size):
@ -139,7 +175,7 @@ class apply_filters:
def save_image(self, fig, ax):
# Save processed image.
print("Saving image", file = sys.stderr)
ax.imshow(self.img)
ax.imshow(self.img, cmap="gray")
fig.savefig(fname=self.output_file)