BP_DP-xlanro00/src/main.py

"""Main file of the project, contains filtering and stl generation functions

.. moduleauthor:: xlanro00

"""

# Import basic libraries
import argparse as ap
from os.path import exists
import hashlib

# Libraries for image processing
import numpy as np
import matplotlib.pyplot as plt
import cv2 as cv
from stl import mesh
import trimesh
import trimesh.transformations as tmtra
import trimesh.remesh as tmrem

# Import custom image filter library
import filters as flt
import config_parser as cp
import log
import math


class fingerprint_app:
    '''Main class for the application.
    '''

    def __init__(self):
        # Parse arguments from command line
        self.parse_arguments()

        # List and dict for filters and corresponding parameters
        self.filters = []
        self.params = {}

        # Parse configuration from json config file
        if self.args.config:
            self.config_file, self.preset_name = self.args.config
            cp.parse_conf(self.preset_name, self.filters,
                          self.params, self.config_file)

        elif self.args.filters:
            filter_index = 0
            log.print_message(
                "No config file given, using command line arguments")

            # Otherwise expect filters from command line
            for filter_part in self.args.filters:
                # If no '=' char in filter, it is a new filter name
                if filter_part.find('=') == -1:
                    self.filters.append(filter_part)
                    filter_index += 1
                    # create empty dict for params
                    self.params[filter_index] = {}
                # Otherwise it's a parameter for current filter
                else:
                    key, value = filter_part.split('=')
                    self.params[filter_index][key] = value

                cp.parse_params(self.params[filter_index])

            # If database flag is set, save filters to database as a new preset
            if self.args.database:
                cp.save_preset(self.filters, self.params,
                               self.args.database[0])

        else:
            log.print_message("No filters given, saving original image")

        # Set input and output file paths, dpi and mirror flag for easier readability
        self.input_file = self.args.input_file
        self.output_file = self.args.output_file
        self.dpi = self.args.dpi
        self.mirror = True if self.args.mirror else False

        if exists(self.input_file):
            self.run_filtering()
        else:
            log.error_exit("Input file " + self.input_file +
                           " does not exist")

        if self.args.stl:
            self.parse_stl()

    def parse_arguments(self):
        '''Parse arguments from command line using argparse library.
        '''

        parser = ap.ArgumentParser(prog='main.py',
                                   description='Program for transforming a 2D image into 3D fingerprint.',
                                   usage='%(prog)s [-h] [-m | --mirror | --no-mirror] input_file output_file dpi ([-c | --config config_file preset] | [filters ...]) [-s | --stl p height_line height_base | --stl c height_line curv_rate_x curv_rate_y | --stl m height_line iter finger_x finger_y finger_z] [-d | --database database_filename]')

        # positional arguments
        parser.add_argument("input_file", type=str, help="input file path")
        parser.add_argument("output_file", type=str, help="output file path")
        parser.add_argument("dpi", type=int, help="dpi of used scanner")

        # boolean switch argument
        parser.add_argument('-m', '--mirror', type=bool, action=ap.BooleanOptionalAction,
                            help="switch to mirror input image")

        # another boolean switch argument, this time with value, name of the new file and dimensions
        parser.add_argument('-s', "--stl", type=str, nargs='*',
                            help="create stl model from processed image")

        # configuration file containing presets, preset name
        # pair argument - give both or none
        parser.add_argument('-c', '--config', nargs=2,
                            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 and their parameters in form [filter_name1 param1=value param2=value filter_name2 param1=value...]")

        parser.add_argument('-d', '--database', nargs=1,
                            help='switch to store presets in config database')

        self.args = parser.parse_args()

    def parse_stl(self):
        '''Parse arguments for stl generation.
        '''
        # Get stl filename
        self.stl_path = self.output_file.rsplit('/', 1)[0] + '/'
        self.mode = self.args.stl[0]
        log.print_message("Stl generation in", self.mode, "mode")

        # Default values for stl generation parameters
        def_val = {"hl": 2, "hb": 10, "crx": 2, "cry": 2, "it": 2,
                   "fx": 0, "fy": 0, "fz": 0, "f": "res/finger_backup/finger-mod.stl"}

        # Get mode and model parameters
        if self.mode == 'p':
            
            self.height_line = float(self.args.stl[1]) if len(
                self.args.stl) > 1 else def_val.get("hl")
            self.height_base = float(self.args.stl[2]) if len(
                self.args.stl) > 2 else def_val.get("hb")
            
            if len(self.args.stl) < 3:
                log.print_message(
                    "Warning: Too few arguments, using some default values")
            log.print_message("Base height:", self.height_base,
                                "mm, lines depth/height:", self.height_line, "mm")

        elif self.mode == 'c':

            self.height_line = float(self.args.stl[1]) if len(
                self.args.stl) > 1 else def_val.get("hl")
            self.height_base = float(self.args.stl[2]) if len(
                self.args.stl) > 2 else def_val.get("hb")
            self.curv_rate_x = float(self.args.stl[3]) if len(
                self.args.stl) > 3 else def_val.get("crx")
            self.curv_rate_y = float(self.args.stl[4]) if len(
                self.args.stl) > 4 else def_val.get("cry")
            
            if len(self.args.stl) < 5:
                log.print_message(
                    "Warning: Too few arguments, using some default values")
            log.print_message("Line height:", self.height_line, "mm, base height:", self.height_base,
                                "mm, x axis curvature:", self.curv_rate_x, ", y axis curvature:", self.curv_rate_y)
            
        elif self.mode == 'm':

            self.height_line = float(self.args.stl[1]) if len(
                self.args.stl) > 1 else def_val.get("hl")/10
            self.iter = int(self.args.stl[2]) if len(
                self.args.stl) > 2 else def_val.get("it")
            self.finger_x = float(self.args.stl[3]) if len(
                self.args.stl) > 3 else def_val.get("fx")
            self.finger_y = float(self.args.stl[4]) if len(
                self.args.stl) > 4 else def_val.get("fy")
            self.finger_z = float(self.args.stl[5]) if len(
                self.args.stl) > 5 else def_val.get("fz")
            self.finger_name = str(self.args.stl[6]) if len(
                self.args.stl) > 6 else def_val.get("f")
            
            if len(self.args.stl) < 6:
                log.print_message(
                    "Warning: Too few arguments, using some default values")
            log.print_message("Line height:", self.height_line, "mm, iterations:", self.iter,
                                ", finger position:", self.finger_x, self.finger_y, self.finger_z, "mm, finger model:", self.finger_name)

        else:
            log.error_exit("Unrecognized generation mode")

        self.run_stl()

# ------------------------- FILTERING -------------------------#

    def run_filtering(self):
        '''Read input file, store as numpy.array, uint8, grayscale.
        Call function to apply the filters and a function to save it to output file.
        '''

        self.img = cv.imread(
            self.input_file, cv.IMREAD_GRAYSCALE).astype(np.uint8)

        # Gets empty figure and ax with dimensions of input image
        self.height, self.width = self.img.shape
        self.fig, ax = self.get_empty_figure()

        if self.mirror is True:
            self.mirror_image()

        # Apply all filters and save image
        self.apply_filters()
        self.save_image(self.fig, ax)
        plt.close()

    def get_empty_figure(self):
        '''Return empty figure with one ax, which has dimensions of the input image.
        '''

        size = (self.width/self.dpi, self.height/self.dpi)
        fig = plt.figure(figsize=size, frameon=False, dpi=self.dpi)
        ax = plt.Axes(fig, [0., 0., 1., 1.])
        ax.set_axis_off()
        fig.add_axes(ax)
        return fig, ax

    def mirror_image(self):
        '''Mirror image using opencv.
        Should be used to cancel implicit mirroring.
        '''

        log.print_message("Mirroring image")
        self.img = cv.flip(self.img, 1)  # 1 for vertical mirror

    def apply_filters(self):
        '''Apply filters to image one by one.
        In case none were given, pass and save original image to the output file.
        '''

        if len(self.filters) != 0:
            for i, filter_name in enumerate(self.filters):
                # Get filter class from filter.py, use the apply method
                try:
                    filter = getattr(flt, filter_name)
                except AttributeError:
                    log.error_exit("Filter " + filter_name + " not found")
                log.print_message("Applying filter:", filter_name)
                for param in self.params[i+1]:
                    if self.params[i+1][param] is not None:
                        log.print_message("\twith parameter", param,
                                          "=", str(self.params[i+1][param]))

                filter.apply(self, self.params[i+1])
        else:
            pass

    def save_image(self, fig, ax):
        '''Save processed image to the output file.

        :param fig: figure used to render image.
        :param ax: Ax used to render image.
        '''

        log.print_message("Saving image to", self.output_file)

        # Colormap must be set to grayscale to avoid color mismatch.
        ax.imshow(self.img, cmap="gray")
        fig.savefig(fname=self.output_file)

# ------------------------- STL GENERATION -------------------------#

    def run_stl(self):
        '''Choose correct generation code based on mode.
        '''

        self.prepare_heightmap()
        # create ID for the model from all its parameters
        self.get_ID()

        # Create a mesh using one of two modes
        if self.mode == "p":
            self.make_stl_planar()

        elif self.mode == "c":
            self.make_stl_curved()

        elif self.mode == "m":
            # Load the finger model
            self.finger = trimesh.load(self.finger_name)
            self.make_stl_map()

        plt.show()
        self.save_stl()

    def prepare_heightmap(self):
        '''Scale image values to get values from 0 to 255. 
        Check validity of dimension parameters.
        Then compute base and papilar lines height.
        Prepare meshgrid, array which later serves to store point coordinates.
        '''

        if self.img.dtype != np.uint8:
            log.print_message("Converting heightmap to uint8")
            self.img = self.img / np.max(self.img) * 255
            self.img = self.img.astype(np.uint8)

        if self.mode == "p":
            if self.height_base <= 0:
                log.error_exit("Depth of plate height must be positive")

            if self.height_line + self.height_base <= 0:
                log.error_exit("Line depth must be less than plate thickness")

        if self.mode == "c":
            # Don't need to check curvature, check only heights
            if self.height_base <= 0 or self.height_line <= 0:
                log.error_exit("Base and line height must both be positive")

        if self.mode == "m":
            if self.height_line <= 0:
                log.error_exit("Line height must be positive")
            if self.iter < 0:
                log.error_exit("Number of iterations must be positive orr zero")
            self.height_base = 0

        # TODO: curved height base could be done here?
        # Transform image values to get a heightmap
        self.img = (self.height_base + (1 - self.img/255)
                    * self.height_line)

        # This sets the size of stl model and number of subdivisions / triangles
        x = np.linspace(0, self.width * 25.4 / self.dpi, self.width)
        y = np.linspace(0, self.height * 25.4 / self.dpi, self.height)

        self.meshgrid = np.meshgrid(x, y)

    def write_stl_header(self):
        '''Write parameter string to stl header.
        This header is 80 bytes long, so the data needs to be shortened to fit.
        If the parameter string is too long, a warning is printed and the data is truncated.
        '''

        # Truncate if necessary
        if (len(self.param_string) >= 80):
            self.param_string = self.param_string[:80]
            log.print_message("Warning: Parameter string too long, truncating")

        # Overwrite stl header (which is only 80 bytes)
        log.print_message("Writing info to stl header")
        with open(self.stl_filename, "r+") as f:
            f.write(self.param_string)

    def get_ID(self):
        '''Get a unique ID for the model, which is used in filename and on the model backside.
        Also create parameter string for stl header, which is used to create ID using hash function MD5.
        '''

        # these are the same for all types of models
        param_list = [self.input_file, str(self.dpi)]

        # add parameters specific to the model creation process
        if self.args.config:
            param_list.append(self.config_file)
            param_list.append(self.preset_name)
        else:
            # add filters with their params
            filter_list = []
            for i in range(len(self.filters)):
                tmp_params = []
                for j in self.params[i+1]:
                    if self.params[i+1][j] != None:
                        tmp_params.append(
                            str(j[:1] + ":" + str(self.params[i+1][j])))
                tmp_params = ",".join(tmp_params)
                tmp = str(self.filters[i][0:1] + self.filters[i][-1:])
                if tmp_params != "":
                    tmp = tmp + ";" + str(tmp_params)
                filter_list.append(tmp)
            filter_string = ">".join(filter_list)
            param_list.append(filter_string)

        # these are the same for all types of models
        param_list.append(str(self.height_line))
        param_list.append(str(self.height_base))

        # add parameters specific to the model type
        if self.mode == "c":
            param_list.append(str(self.curv_rate_x))
            param_list.append(str(self.curv_rate_y))

        if self.mode == "m":
            param_list.append(str(self.height_line))
            param_list.append(str(self.iter))
            param_list.append(str(self.finger_x))
            param_list.append(str(self.finger_y))
            param_list.append(str(self.finger_z))
            param_list.append(str(self.finger_name))

        if self.mode == "p":
            param_list.append("P")
        elif self.mode == "c":
            param_list.append("C")
        elif self.mode == "m":
            param_list.append("M")

        if self.args.mirror:
            param_list.append("F")

        # string that will later be put inside the header of an stl file
        # fill the rest with the ending char to rewrite any leftover header
        # this is done for easier parsing of the header
        self.param_string = "\\".join(param_list)
        self.param_string = self.param_string + \
            "\n" * (80 - len(self.param_string))

        # hash the param string to get unique ID, this will be put in filename and on the back of the model
        # not using built-in hash function because it's seed cannot be set to constant number
        # don't need to worry about collisions and security, just need a relatively unique ID
        self.id = str(hashlib.md5(
            self.param_string.encode('utf-8')).hexdigest())[:10]

    def append_faces(self, faces, c):
        '''Add faces to the list of faces.

        :param faces: Array with faces.
        :param c: Indices of currently added faces.
        '''

        faces.append([c, c + 1, c + 2])
        faces.append([c + 1, c + 3, c + 2])
        return c + 4

    def engrave_text(self, bottom_vert_arr, top_vert_arr):
        '''Engrave text on the back of the model.
        Create an empty image, fill it with color and draw text on it.

        :param bottom_vert_arr: Bottom vertex array.
        :param top_vert_arr: Top vertex array
        '''

        fig, ax = self.get_empty_figure()

        # paint the background black
        ax.plot([0, 1], [0, 1], c="black", lw=self.width)

        # extract filename
        text = self.stl_path.split("/")[-1].split(".")[0] + self.id
        fontsize = 28

        # create text object, paint it white
        t = ax.text(0.5, 0.5, text, ha="center", va="center",
                    fontsize=fontsize, c="white", rotation=90, wrap=True, clip_on=True)

        # adjust fontsize to fit text in the image
        # matplotlib does not support multiline text, wrapping is broken
        rend = fig.canvas.get_renderer()
        while (t.get_window_extent(rend).width > self.width or t.get_window_extent(rend).height > self.height):
            fontsize -= 0.3
            t.set_fontsize(fontsize)

        # update figure, read pixels and reshape to 3d array
        fig.canvas.draw()
        data = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)
        data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
        plt.close()
        
        # scale inscription layer to suitable height
        data = (data/255)/10

        # add the bottom array
        OFFSET = 0.01
        
        for i in range(self.height):
            if self.mode == "p":
                for j in range(self.width):
                    bottom_vert_arr[i][j][2] = data[i][j][0]
            elif self.mode == "c":
                # TODO: this is very badly written, fix it, why is teh offset needed at all?
                # TODO: this sometimes generates invalid mesh, fix it
                for j in range(self.width):
                    bottom_vert_arr[i][j][2] += data[i][j][0]
                    if (bottom_vert_arr[i][j][2] < (top_vert_arr[i][0][2])-OFFSET):
                        bottom_vert_arr[i][j][2] = top_vert_arr[i][0][2]-OFFSET
                    if (bottom_vert_arr[i][j][2] < (top_vert_arr[0][j][2])-OFFSET):
                        bottom_vert_arr[i][j][2] = top_vert_arr[0][j][2]-OFFSET

        return bottom_vert_arr

    def create_stl_mesh(self, faces, vertices):
        '''Create mesh from faces and vertices arrays.

        :param faces: Vector of face indices
        :param vertices: Vector of vertices
        '''

        # Convert lists to numpy arrays
        faces = np.array(faces)
        vertices = np.array(vertices)
        c = 0

        # Create the mesh - vertices.shape (no_faces, 3, 3)
        self.stl_model = mesh.Mesh(
            np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
        for i, face in enumerate(faces):
            for j in range(3):
                self.stl_model.vectors[i][j] = vertices[face[j], :]
            
            # Prints out generation progress
            if i % 100 == 0:
                percentage = round(i/len(faces) * 100, 2)
                if percentage > c:
                    log.print_message("Creating model " + str(c) + "%")
                    c += 10
        
        log.print_message("Model creation finished")

    def create_faces(self, top_vert_arr, bottom_vert_arr):
        '''Create faces for the model.
        Iterate over all vertices, append to vector and create faces from indices.
        
        :param bottom_vert_arr: Bottom vertex array.
        :param top_vert_arr: Top vertex array
        '''

        count = 0
        vertices = []
        faces = []

        # Front side faces
        for i in range(self.height - 1):
            for j in range(self.width - 1):

                vertices.append([top_vert_arr[i][j]])
                vertices.append([top_vert_arr[i][j+1]])
                vertices.append([top_vert_arr[i+1][j]])
                vertices.append([top_vert_arr[i+1][j+1]])
                count = self.append_faces(faces, count)

        # Back side faces
        for i in range(self.height - 1):
            for j in range(self.width - 1):

                vertices.append([bottom_vert_arr[i][j]])
                vertices.append([bottom_vert_arr[i+1][j]])
                vertices.append([bottom_vert_arr[i][j+1]])
                vertices.append([bottom_vert_arr[i+1][j+1]])
                count = self.append_faces(faces, count)

        # Horizontal side faces
        for i in range(self.height - 1):

            vertices.append([top_vert_arr[i][0]])
            vertices.append([top_vert_arr[i+1][0]])
            vertices.append([bottom_vert_arr[i][0]])
            vertices.append([bottom_vert_arr[i+1][0]])
            count = self.append_faces(faces, count)
            max = self.width - 1

            vertices.append([top_vert_arr[i+1][max]])
            vertices.append([top_vert_arr[i][max]])
            vertices.append([bottom_vert_arr[i+1][max]])
            vertices.append([bottom_vert_arr[i][max]])
            count = self.append_faces(faces, count)

        # Vertical side faces
        for j in range(self.width - 1):

            vertices.append([top_vert_arr[0][j+1]])
            vertices.append([top_vert_arr[0][j]])
            vertices.append([bottom_vert_arr[0][j+1]])
            vertices.append([bottom_vert_arr[0][j]])
            count = self.append_faces(faces, count)
            max = self.height - 1

            vertices.append([top_vert_arr[max][j]])
            vertices.append([top_vert_arr[max][j+1]])
            vertices.append([bottom_vert_arr[max][j]])
            vertices.append([bottom_vert_arr[max][j+1]])
            count = self.append_faces(faces, count)

        return faces, vertices

    def make_stl_planar(self):
        '''Create vertices from meshgrid, add z coordinates from processed image heightmap.
        '''

        # Add the image matrix to the 2D meshgrid and create 1D array of 3D points
        tmp_vert_arr = np.vstack(list(map(np.ravel, self.meshgrid))).T
        top_vert_arr = np.concatenate(
            (tmp_vert_arr, (self.img / 10).reshape(-1, 1)), axis=1)

        # Convert 1D array back to matrix of 3D points
        top_vert_arr = top_vert_arr.reshape(self.height, self.width, 3)

        # Prepare image with plotted text for the backside of the lithophane
        bottom_vert_arr = np.copy(top_vert_arr)

        # Engrave text on the back of the model
        self.engrave_text(bottom_vert_arr, top_vert_arr)

        # Create all vertices, faces
        faces, vertices = self.create_faces(top_vert_arr, bottom_vert_arr)

        # Add the created vertices and faces to a mesh
        self.create_stl_mesh(faces, vertices)

    def make_stl_curved(self):
        '''Compute curved surface offset.
        Create vertices from meshgrid, add z coordinates from processed image heightmap.
        '''

        # Calculate the curved surface values
        x = np.arange(self.width)
        y = np.arange(self.height)[:, np.newaxis]
        x = (2*x / self.width) - 1
        z = np.sqrt(1 - x**2) * self.curv_rate_x**2
        z = np.tile(z, (self.height, 1))
        z *= np.sqrt((1 - ((self.height - y) / self.height)**2)
                    * self.curv_rate_y**2)
        z = z.reshape(-1, 1)

        # Make a copy of z for the bottom side
        z_cpy = z.copy()

        # Reshape img and add it to height values
        self.img = (self.img / 10).reshape(-1, 1)
        z += self.img

        vert_arr_tmp = np.vstack(list(map(np.ravel, self.meshgrid))).T

        # for top side
        top_vert_arr = np.concatenate((vert_arr_tmp, z), axis=1)
        top_vert_arr = top_vert_arr.reshape(self.height, self.width, 3)

        # for bottom side
        bottom_vert_arr = np.concatenate((vert_arr_tmp, z_cpy), axis=1)
        bottom_vert_arr = bottom_vert_arr.reshape(self.height, self.width, 3)

        # Engrave text on the back of the model
        self.engrave_text(bottom_vert_arr, top_vert_arr)

        # Create all vertices, faces
        faces, vertices = self.create_faces(top_vert_arr, bottom_vert_arr)

        # Add the created vertices and faces to a mesh
        self.create_stl_mesh(faces, vertices)

    def make_stl_map(self):
        '''Map fingerprint to a given finger model.
        '''

        # Conversion constants for mm and pixels
        mm2px = self.dpi/25.4
        px2mm = 25.4/self.dpi

        # Finds the image pixel closest to finger vertice in 2D plane
        def find_nearest(ver1, ver2, img):
            searched_point = np.array([ver1, ver2])

            min1 = math.floor(ver1*mm2px)
            max1 = math.ceil(ver1*mm2px)
            min2 = math.floor(ver2*mm2px)
            max2 = math.ceil(ver2*mm2px)
            min_dist_point = img[min2][min1]

            for i in range(min2, max2 - 1):
                for j in range(min1, max1 - 1):
                    if np.linalg.norm(img[i][j] - searched_point) < min_dist_point:
                        min_dist_point = img[i][j]
            return min_dist_point

        # Implicitly translate finger model to match middle of the fingerprint
        # This can be modified using finger_x, y and z parameters
        x = (self.width * px2mm / 2) + self.finger_x
        y = (self.height * px2mm / 2) + self.finger_y
        z = self.finger_z
        matrix = tmtra.translation_matrix([x, y, z])
        self.finger.apply_transform(matrix)

        # Subdivide the finger mesh to allow for more precision
        # This can be skipped if the model is already dense enough
        vertices, faces = tmrem.subdivide_loop(
            self.finger.vertices, self.finger.faces, iterations=self.iter)

        # For logging progress
        c = 0
        for k, vertice in enumerate(vertices):
            # Skip vertices under plane xy
            # also skip vertices under the fingerprint image, 
            # they are all unused
            if vertice[2] < 0 or vertice[1] > self.height * px2mm:
                continue

            # This is the easiest way to avoid indexing errors
            # Those errors are caused by vertices outside of the image
            # When this occurs, input parameters need to be adjusted
            try:
                # Find the closest point in the image
                # To the 2D image projection of vertice, add its value
                point = find_nearest(vertice[0], vertice[1], self.img)
            except IndexError:
                log.error_exit("Fingerprint image is outside of the finger model")

            vertices[k][2] += point

            # Prints out generation progress
            if k % 1000 == 0:
                percentage = round(k/len(vertices) * 100, 2)
                if percentage > c:
                    log.print_message("Carving finger: " + str(c) + "%")
                    c += 10

        self.stl_model = trimesh.Trimesh(vertices, faces)
        log.print_message("Carving finger finished")

    def save_stl(self):
        '''Save final mesh to stl file.
        '''

        # Create output file name, save it and write header with file info
        self.stl_filename = self.output_file.split(
            ".")[0] + "_" + self.id + ".stl"
        if (self.mode == "m"):
            self.stl_model.export(file_obj=self.stl_filename)
        else:
            self.stl_model.save(self.stl_filename)

        log.print_message("Saving model to", self.stl_filename)
        self.write_stl_header()


fingerprint_app()