You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
706 lines
27 KiB
706 lines
27 KiB
"""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
|
|
|
|
# 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.extend([self.config_file, 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.extend([str(self.height_line), str(self.height_base)])
|
|
|
|
# add parameters specific to the model type
|
|
if self.mode == "c":
|
|
param_list.extend([str(self.curv_rate_x), str(self.curv_rate_y)])
|
|
|
|
elif self.mode == "m":
|
|
param_list.extend(
|
|
[str(self.height_line), str(self.iter), str(self.finger_x),
|
|
str(self.finger_y), str(self.finger_z), str(self.finger_name)])
|
|
|
|
param_list.append(self.mode)
|
|
|
|
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
|
|
|
|
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":
|
|
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])):
|
|
bottom_vert_arr[i][j][2] = top_vert_arr[i][0][2]
|
|
if (bottom_vert_arr[i][j][2] < (top_vert_arr[0][j][2])):
|
|
bottom_vert_arr[i][j][2] = top_vert_arr[0][j][2]
|
|
|
|
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 = []
|
|
max_width = self.width - 1
|
|
max_height = self.height - 1
|
|
|
|
# Front side faces and vertices
|
|
for i in range(self.height - 1):
|
|
for j in range(self.width - 1):
|
|
|
|
vertices.extend([[top_vert_arr[i][j]], [top_vert_arr[i][j+1]],
|
|
[top_vert_arr[i+1][j]], [top_vert_arr[i+1][j+1]]])
|
|
count = self.append_faces(faces, count)
|
|
|
|
# Back side faces and vertices
|
|
for i in range(self.height - 1):
|
|
for j in range(self.width - 1):
|
|
|
|
vertices.extend([[bottom_vert_arr[i][j]], [bottom_vert_arr[i+1][j]],
|
|
[bottom_vert_arr[i][j+1]], [bottom_vert_arr[i+1][j+1]]])
|
|
count = self.append_faces(faces, count)
|
|
|
|
|
|
# Horizontal side faces and vertices
|
|
for i in range(self.height - 1):
|
|
|
|
vertices.extend([[top_vert_arr[i][0]], [top_vert_arr[i+1][0]],
|
|
[bottom_vert_arr[i][0]], [bottom_vert_arr[i+1][0]]])
|
|
count = self.append_faces(faces, count)
|
|
|
|
vertices.extend([[top_vert_arr[i+1][max_width]], [top_vert_arr[i][max_width]],
|
|
[bottom_vert_arr[i+1][max_width]], [bottom_vert_arr[i][max_width]]])
|
|
count = self.append_faces(faces, count)
|
|
|
|
# Vertical side faces and vertices
|
|
for j in range(self.width - 1):
|
|
|
|
vertices.extend([[top_vert_arr[0][j+1]], [top_vert_arr[0][j]],
|
|
[bottom_vert_arr[0][j+1]], [bottom_vert_arr[0][j]]])
|
|
count = self.append_faces(faces, count)
|
|
|
|
vertices.extend([[top_vert_arr[max_height][j]], [top_vert_arr[max_height][j+1]],
|
|
[bottom_vert_arr[max_height][j]], [bottom_vert_arr[max_height][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()
|