diff --git a/face_reconstruction/optim/bfm.py b/face_reconstruction/optim/bfm.py index a32c23f..3e57590 100644 --- a/face_reconstruction/optim/bfm.py +++ b/face_reconstruction/optim/bfm.py @@ -35,8 +35,8 @@ - Parameters (BFMOptimizationParameters): Syntactic sugar. Provides an interface to translate between a list of parameters (theta) and an object of - meaningful attributes, e.g., divided into shape coefficients, expression coefficients and camera pose - + meaningful attributes, e.g., divided into shape coefficients, expression coefficients, color coefficients + and camera pose """ @@ -54,9 +54,11 @@ def __init__(self, bfm: BaselFaceModel, n_params_shape, n_params_expression, + n_params_color, fix_camera_pose=False, weight_shape_params=1.0, weight_expression_params=1.0, + weight_color_params=1.0, rotation_mode='lie'): """ @@ -70,20 +72,27 @@ def __init__(self, Specifies that only the first `n_params_expression` parameters of the expression model will be optimized for. These are the parameters that have the biggest impact on the face model. The remaining coefficients will be held constant to 0. + :param n_params_color: + Specifies that only the first `n_params_color` parameters of the expression model will be optimized for. + These are the parameters that have the biggest impact on the face model. + The remaining coefficients will be held constant to 0. :param fix_camera_pose: Whether the camera pose should be optimized for :param weight_shape_params: Specifies how much more changing a shape coefficient parameter will impact the loss :param weight_expression_params: Specifies how much more changing an expression coefficient parameter will impact the loss + :param weight_color_params: + Specifies how much more changing a color coefficient parameter will impact the loss """ self.bfm = bfm self.n_params_shape = n_params_shape self.n_params_expression = n_params_expression - self.n_params_color = 0 # Currently, optimizing for color is not supported + self.n_params_color = n_params_color self.fix_camera_pose = fix_camera_pose self.weight_shape_params = weight_shape_params self.weight_expression_params = weight_expression_params + self.weight_color_params = weight_color_params assert rotation_mode in ['quaternion', 'lie'], f'Rotation mode has to be either lie or quaternion. ' \ f'You gave {rotation_mode}' @@ -96,12 +105,14 @@ def __init__(self, lower_bounds = [] lower_bounds.extend([-float('inf') for _ in range(n_params_shape)]) lower_bounds.extend([-float('inf') for _ in range(n_params_expression)]) + lower_bounds.extend([-float('inf') for _ in range(n_params_color)]) lower_bounds.extend([-1, -1, -1, -1, -float('inf'), -float('inf'), -float('inf')]) self.lower_bounds = np.array(lower_bounds) upper_bounds = [] upper_bounds.extend([float('inf') for _ in range(n_params_shape)]) upper_bounds.extend([float('inf') for _ in range(n_params_expression)]) + upper_bounds.extend([float('inf') for _ in range(n_params_color)]) upper_bounds.extend([1, 1, 1, 1, float('inf'), float('inf'), float('inf')]) self.upper_bounds = np.array(upper_bounds) @@ -126,12 +137,14 @@ def create_optimization_context(loss, initial_params, max_nfev=100, verbose=2, x def create_parameters(self, shape_coefficients: np.ndarray = None, expression_coefficients: np.ndarray = None, + color_coefficients: np.ndarray = None, camera_pose: np.ndarray = None ): return BFMOptimizationParameters( self, shape_coefficients=shape_coefficients, expression_coefficients=expression_coefficients, + color_coefficients=expression_coefficients, camera_pose=camera_pose) def create_parameters_from_other(self, parameters): @@ -144,6 +157,7 @@ def create_sparse_loss(self, fixed_camera_pose: np.ndarray = None, fixed_shape_coefficients: np.ndarray = None, fixed_expression_coefficients: np.ndarray = None, + fixed_color_coefficients: np.ndarray = None, regularization_strength: float = None ): return SparseOptimizationLoss( @@ -154,6 +168,7 @@ def create_sparse_loss(self, fixed_camera_pose=fixed_camera_pose, fixed_shape_coefficients=fixed_shape_coefficients, fixed_expression_coefficients=fixed_expression_coefficients, + fixed_color_coefficients=fixed_color_coefficients, regularization_strength=regularization_strength) def create_sparse_loss_3d(self, @@ -187,15 +202,21 @@ def create_combined_loss_3d(self, nearest_neighbor_mode: NearestNeighborMode, distance_type: DistanceType, weight_sparse_term: float = 1, + weight_color_term: float = 1, regularization_strength: float = None, - pointcloud_normals: np.ndarray = None + pointcloud_normals: np.ndarray = None, + pointcloud_colors: np.ndarray = None, ): return CombinedLoss3D(self, bfm_landmark_indices=bfm_landmark_indices, img_landmark_points_3d=img_landmark_points_3d, pointcloud=pointcloud, nearest_neighbors=nearest_neighbors, nearest_neighbor_mode=nearest_neighbor_mode, - distance_type=distance_type, weight_sparse_term=weight_sparse_term, - regularization_strength=regularization_strength, pointcloud_normals=pointcloud_normals) + distance_type=distance_type, + weight_sparse_term=weight_sparse_term, + weight_color_term=weight_color_term, + regularization_strength=regularization_strength, + pointcloud_normals=pointcloud_normals, + pointcloud_colors=pointcloud_colors) def create_sparse_keyframe_loss(self, bfm_landmark_indices_list: List[np.ndarray], img_landmark_points_3d_list: List[np.ndarray], @@ -230,7 +251,7 @@ class BFMOptimizationContext: Encapsulates the context of a single optimization run. Needed in order to hold the initial parameters as the theta list that is communicated to the optimizer only contains the parameters that are to be optimized. Fixed parameters, i.e., those specified as initial parameters that are outside the n_shape_coefficients or - n_expression_coefficients bounds, can then be obtained from this context wrapper. + n_expression_coefficients or n_color_coefficients bounds, can then be obtained from this context wrapper. """ def __init__(self, loss, initial_params, max_nfev=100, verbose=2, x_scale='jac'): @@ -318,12 +339,14 @@ def _apply_params_to_model(self, theta): shape_coefficients = parameters.shape_coefficients expression_coefficients = parameters.expression_coefficients + color_coefficients = parameters.color_coefficients camera_pose = parameters.camera_pose face_mesh = self.optimization_manager.bfm.draw_sample( shape_coefficients=shape_coefficients, expression_coefficients=expression_coefficients, - color_coefficients=[0 for _ in range(self.optimization_manager.n_color_coefficients)]) + color_coefficients=color_coefficients, + ) bfm_vertices = add_column(np.array(face_mesh.vertices), 1) bfm_vertices = camera_pose @ bfm_vertices.T return bfm_vertices.T, face_mesh @@ -372,6 +395,7 @@ def __init__( fixed_camera_pose: np.ndarray = None, fixed_shape_coefficients: np.ndarray = None, fixed_expression_coefficients: np.ndarray = None, + fixed_color_coefficients: np.ndarray = None, regularization_strength=None): """ :param optimization_manager: @@ -394,6 +418,7 @@ def __init__( self.fixed_shape_coefficients = fixed_shape_coefficients self.fixed_expression_coefficients = fixed_expression_coefficients + self.fixed_color_coefficients = fixed_color_coefficients def loss(self, theta, *args, **kwargs): parameters = self.create_parameters_from_theta(theta) @@ -408,6 +433,11 @@ def loss(self, theta, *args, **kwargs): else: expression_coefficients = self.fixed_expression_coefficients + if self.fixed_color_coefficients is None: + color_coefficients = parameters.color_coefficients + else: + color_coefficients = self.fixed_color_coefficients + if self.optimization_manager.fix_camera_pose: camera_pose = self.fixed_camera_pose else: @@ -416,7 +446,8 @@ def loss(self, theta, *args, **kwargs): face_mesh = self.optimization_manager.bfm.draw_sample( shape_coefficients=shape_coefficients, expression_coefficients=expression_coefficients, - color_coefficients=[0 for _ in range(self.optimization_manager.n_color_coefficients)]) + color_coefficients=color_coefficients, + ) landmark_points = np.array(face_mesh.vertices)[self.bfm_landmark_indices] face_landmark_pixels = self.renderer.project_points(camera_pose, landmark_points) residuals = face_landmark_pixels - self.img_landmark_pixels @@ -538,8 +569,10 @@ def __init__(self, optimization_manager: BFMOptimization, nearest_neighbor_mode: NearestNeighborMode, distance_type: DistanceType, weight_sparse_term: float = 1, + weight_color_term: float = 1, regularization_strength: float = None, - pointcloud_normals: np.ndarray = None): + pointcloud_normals: np.ndarray = None, + pointcloud_colors: np.ndarray = None): super(CombinedLoss3D, self).__init__(optimization_manager, regularization_strength) self.bfm_landmark_indices = bfm_landmark_indices self.img_landmark_points_3d = img_landmark_points_3d @@ -548,7 +581,9 @@ def __init__(self, optimization_manager: BFMOptimization, self.nearest_neighbor_mode = nearest_neighbor_mode self.distance_type = distance_type self.pointcloud_normals = pointcloud_normals + self.pointcloud_colors = pointcloud_colors self.weight_sparse_term = weight_sparse_term + self.weight_color_term = weight_color_term def loss(self, theta, *args, **kwargs): bfm_vertices, face_mesh = self._apply_params_to_model(theta) @@ -589,6 +624,16 @@ def loss(self, theta, *args, **kwargs): landmark_points = bfm_vertices[self.bfm_landmark_indices] residuals.extend(self.weight_sparse_term * (landmark_points[:, :3] - self.img_landmark_points_3d)) + # Color residuals + if self.pointcloud_colors is not None: + if self.nearest_neighbor_mode == NearestNeighborMode.FACE_VERTICES: + mesh_colors = np.array(face_mesh.colors) + pointcloud_colors = self.pointcloud_colors[self.nearest_neighbors] + elif self.nearest_neighbor_mode == NearestNeighborMode.POINTCLOUD: + mesh_colors = np.array(face_mesh.colors)[self.nearest_neighbors] + pointcloud_colors = self.pointcloud_colors + residuals.extend(self.weight_color_term * (mesh_colors - pointcloud_colors)) + residuals = np.array(residuals).reshape(-1) if self.regularization_strength is not None: regularization_terms = self._compute_regularization_terms( @@ -724,6 +769,7 @@ def __init__(self, optimization_manager: BFMOptimization, shape_coefficients: np.ndarray, expression_coefficients: np.ndarray, + color_coefficients: np.ndarray, camera_pose: np.ndarray): """ Defines all the parameters that will be optimized for @@ -733,6 +779,8 @@ def __init__(self, The part of the parameters that describes the shape coefficients :param expression_coefficients: The part of the parameters that describes the expression coefficients + :param color_coefficients: + The part of the parameters that describes the color coefficients :param camera_pose: The part of the parameters that describes the 4x4 camera pose matrix """ @@ -743,6 +791,7 @@ def __init__(self, n_color_coefficients = optimization_manager.n_color_coefficients n_params_shape = optimization_manager.n_params_shape n_params_expression = optimization_manager.n_params_expression + n_params_color = optimization_manager.n_params_color assert shape_coefficients is not None or n_params_shape == 0, "If n_params_shape > 0 then shape coefficients have to be provided" if shape_coefficients is None: @@ -751,14 +800,21 @@ def __init__(self, assert expression_coefficients is not None or n_params_expression == 0, "If n_params_expression > 0 then expression coefficients have to be provided" if expression_coefficients is None: expression_coefficients = [] - # Shape and expression coefficients are multiplied by their weight to enforce that changing them + + assert color_coefficients is not None or n_params_color == 0, "If n_params_color > 0 then color coefficients have to be provided" + if color_coefficients is None: + color_coefficients = [] + # Shape, expression & color coefficients are multiplied by their weight to enforce that changing them # will have a higher impact depending on the weight self.shape_coefficients = np.hstack( [shape_coefficients, np.zeros((n_shape_coefficients - len(shape_coefficients)))]) self.expression_coefficients = np.hstack([expression_coefficients, np.zeros((n_expression_coefficients - len(expression_coefficients)))]) - self.color_coefficients = np.zeros(n_color_coefficients) + self.color_coefficients = np.hstack([ + color_coefficients, + np.zeros((n_color_coefficients - len(color_coefficients))), + ]) assert camera_pose is not None or optimization_manager.fix_camera_pose, "Camera pose may only be None if it is fixed" if camera_pose is not None: @@ -773,6 +829,7 @@ def from_theta(optimization_manager: Union[BFMOptimization, BFMOptimizationConte Contains a list of parameters that are interpreted as follows. The 1st `n_shape_params` are shape coefficients The next `n_expression_params` are expression coefficients + The next `n_color_params` are expression coefficients The final 7 parameters are the quaternion defining the camera rotation (4 params) and the translation (3 params) """ context = None @@ -782,22 +839,30 @@ def from_theta(optimization_manager: Union[BFMOptimization, BFMOptimizationConte n_params_shape = optimization_manager.n_params_shape n_params_expression = optimization_manager.n_params_expression + n_params_color = optimization_manager.n_params_color if context is None: # No access to initial or fixed parameters # Just reconstruct coefficients from what is there in the theta list - shape_coefficients = theta[:n_params_shape] * optimization_manager.weight_shape_params - expression_coefficients = theta[n_params_shape:n_params_shape + n_params_expression] \ - * optimization_manager.weight_expression_params + start, end = 0, n_params_shape + shape_coefficients = theta[start:end] * optimization_manager.weight_shape_params + start, end = end, end + n_params_expression + expression_coefficients = theta[start:end] * optimization_manager.weight_expression_params + start, end = end, end + n_params_color + color_coefficients = theta[start:end] * optimization_manager.weight_color_params else: # Access to initial or fixed parameters # Combine initial parameters and what is there in the theta list + start, end = 0, n_params_shape shape_coefficients = context.initial_params.shape_coefficients - shape_coefficients[:n_params_shape] = theta[:n_params_shape] * optimization_manager.weight_shape_params + shape_coefficients[:n_params_shape] = theta[start:end] * optimization_manager.weight_shape_params + start, end = end, end + n_params_expression expression_coefficients = context.initial_params.expression_coefficients - expression_coefficients[:n_params_expression] = theta[n_params_shape:n_params_shape + n_params_expression] \ - * optimization_manager.weight_expression_params - i = n_params_shape + n_params_expression + expression_coefficients[:n_params_expression] = theta[start:end] * optimization_manager.weight_expression_params + start, end = end, end + n_params_color + color_coefficients = context.initial_params.color_coefficients + color_coefficients[:n_params_color] = theta[start:end] * optimization_manager.weight_color_params + i = n_params_shape + n_params_expression + n_params_color if optimization_manager.fix_camera_pose: camera_pose = None @@ -820,6 +885,7 @@ def from_theta(optimization_manager: Union[BFMOptimization, BFMOptimizationConte optimization_manager=optimization_manager, shape_coefficients=shape_coefficients, expression_coefficients=expression_coefficients, + color_coefficients=color_coefficients, camera_pose=camera_pose) def with_new_manager(self, optimization_manager: BFMOptimization): @@ -827,17 +893,20 @@ def with_new_manager(self, optimization_manager: BFMOptimization): optimization_manager=optimization_manager, shape_coefficients=self.shape_coefficients, expression_coefficients=self.expression_coefficients, + color_coefficients=self.color_coefficients, camera_pose=self.camera_pose ) def to_theta(self): theta = [] - # To translate the parameters back into a theta list, shape and expression coefficients have to be divided - # again by their weights + # To translate the parameters back into a theta list, shape, + # expression & color coefficients have to be divided again by their weights theta.extend(self.shape_coefficients[:self.optimization_manager.n_params_shape] / self.optimization_manager.weight_shape_params) theta.extend(self.expression_coefficients[:self.optimization_manager.n_params_expression] / self.optimization_manager.weight_expression_params) + theta.extend(self.color_coefficients[:self.optimization_manager.n_params_color] + / self.optimization_manager.weight_color_params) if not self.optimization_manager.fix_camera_pose: mode = self.optimization_manager.rotation_mode diff --git a/face_reconstruction/optim/icp.py b/face_reconstruction/optim/icp.py index 5641ea2..bb8ecd5 100644 --- a/face_reconstruction/optim/icp.py +++ b/face_reconstruction/optim/icp.py @@ -97,6 +97,7 @@ def run_icp_combined(optimizer: BFMOptimization, face_model: BaselFaceModel, initial_params: BFMOptimizationParameters, weight_sparse_term=1, + weight_color_term=1, max_iterations=20, max_nfev=20, tolerance=0.001, @@ -104,6 +105,7 @@ def run_icp_combined(optimizer: BFMOptimization, distance_type=DistanceType.POINT_TO_POINT, l2_regularization: float = None, pointcloud_normals: np.ndarray = None, + pointcloud_colors: np.ndarray = None, return_cost_history=False): """ Runs ICP with a combined loss function (Sparse + Dense term) @@ -115,8 +117,10 @@ def run_icp_combined(optimizer: BFMOptimization, nearest_neighbor_mode=nearest_neighbor_mode, distance_type=distance_type, weight_sparse_term=weight_sparse_term, + weight_color_term=weight_color_term, regularization_strength=l2_regularization, - pointcloud_normals=pointcloud_normals) + pointcloud_normals=pointcloud_normals, + pointcloud_colors=pointcloud_colors) return _run_icp(optimizer=optimizer, loss_factory=loss_factory, pointcloud=pointcloud, diff --git a/notebooks/17_3d_RGB_Residuals.ipynb b/notebooks/17_3d_RGB_Residuals.ipynb new file mode 100644 index 0000000..ddfb430 --- /dev/null +++ b/notebooks/17_3d_RGB_Residuals.ipynb @@ -0,0 +1,1139 @@ +{ + "metadata": { + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + }, + "orig_nbformat": 2, + "kernelspec": { + "name": "python3", + "display_name": "Python 3.8.5 64-bit ('base': conda)", + "metadata": { + "interpreter": { + "hash": "f885d9ea473b43450fa85565458447ac0f5843782b62f238d578524bb14a4685" + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 2, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\\\\wsl$\\Ubuntu-18.04\\home\\erinc\\projects\\3d-scanning\\3D-FaceReconstruction\n" + ] + } + ], + "source": [ + "%cd ..\n", + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "source": [ + "# 0. Imports" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pyrender\n", + "import open3d\n", + "from sklearn.neighbors import NearestNeighbors\n", + "from scipy import optimize\n", + "\n", + "from face_reconstruction.data.biwi import BiwiDataLoader\n", + "from face_reconstruction.data.iphone import IPhoneDataLoader\n", + "from face_reconstruction.model import BaselFaceModel\n", + "from face_reconstruction.landmarks import load_bfm_landmarks, detect_landmarks\n", + "from face_reconstruction.graphics import (\n", + " draw_pixels_to_image,\n", + " register_rgb_depth,\n", + " backproject_points,\n", + " interpolate_around,\n", + " SimpleImageRenderer,\n", + " setup_standard_scene,\n", + " get_perspective_camera,\n", + " backproject_image,\n", + ")\n", + "from face_reconstruction.optim import (\n", + " BFMOptimization,\n", + " BFMOptimizationRGB,\n", + " DistanceType,\n", + " NearestNeighborMode,\n", + " nearest_neighbors,\n", + " run_icp,\n", + " run_icp_combined,\n", + ")\n", + "from face_reconstruction.utils.math import add_column, geometric_median\n", + "from face_reconstruction.plots import PlotManager, plot_reconstruction_error" + ] + }, + { + "source": [ + "# 1. Face Model" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "bfm = BaselFaceModel.from_h5(\"model2019_face12.h5\")\n", + "bfm_landmarks = load_bfm_landmarks(\"model2019_face12_landmarks_v2\")\n", + "bfm_landmark_indices = np.array(list(bfm_landmarks.values()))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "n_shape_coefficients = bfm.get_n_shape_coefficients()\n", + "n_expression_coefficients = bfm.get_n_expression_coefficients()\n", + "n_color_coefficients = bfm.get_n_color_coefficients()" + ] + }, + { + "source": [ + "# 2. Input RGB-D Image " + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "run_id = 0\n", + "frame_id = 0\n", + "\n", + "#loader = BiwiDataLoader(run_id)\n", + "loader = IPhoneDataLoader()\n", + "\n", + "frame = loader.get_frame(frame_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "img = frame.get_color_image()\n", + "depth_img = frame.get_depth_image()\n", + "img_width = loader.get_image_width()\n", + "img_height = loader.get_image_height()\n", + "intrinsics = frame.get_intrinsics()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "if isinstance(loader, IPhoneDataLoader):\n", + " depth_threshold = 0.5 # Drop all points behind that threshold\n", + " \n", + " intrinsics = frame.get_intrinsics()\n", + " points = backproject_image(intrinsics, depth_img)\n", + " points_to_render = points[:, :3]\n", + " points_to_render *= 1000 # meter to millimeter\n", + " colors = img.reshape(-1, 3) # Just flatten color image\n", + " \n", + " foreground_mask = depth_img.reshape(-1) < depth_threshold\n", + " pointcloud = points_to_render[foreground_mask]\n", + " colors = colors[foreground_mask]\n", + "else:\n", + " # Registration\n", + " pointcloud, colors, screen_positions = register_rgb_depth(\n", + " frame.get_depth_image(),\n", + " frame.get_color_image(),\n", + " biwi_loader.get_depth_intrinsics(),\n", + " biwi_loader.get_rgb_intrinsics(),\n", + " biwi_loader.get_rgb_extrinsics(),\n", + " )\n", + "pointcloud[:, 2] = -pointcloud[:, 2] # Invert z-coordinate for easier rendering (point cloud will be right in front of camera)" + ] + }, + { + "source": [ + "## 2.1. Compute Normals of Pointcloud" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "pc = open3d.geometry.PointCloud(\n", + " points=open3d.utility.Vector3dVector(pointcloud),\n", + ")\n", + "pc.estimate_normals()\n", + "pointcloud_normals = np.asarray(pc.normals)" + ] + }, + { + "source": [ + "# 3. Detect 3D Landmarks" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "landmarks_img, face_pos = detect_landmarks(img, return_face_pos=True)\n", + "face_pos = face_pos[0] # Assume there is only one face" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a depth image for easier querying of depth values\n", + "if isinstance(loader, IPhoneDataLoader):\n", + " rgb_depth_img = depth_img\n", + "else:\n", + " rgb_depth_img = np.zeros((img_height, img_width))\n", + " for point, screen_position in zip(pointcloud, screen_positions):\n", + " rgb_depth_img[screen_position[1], screen_position[0]] = -point[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# As RGB and depth channels are not aligned, we might not have exact depth information for every pixel in the color channel. Hence, we have to interpolate\n", + "interpolation_size = 1\n", + "rgb_depth_values = [\n", + " interpolate_around(rgb_depth_img, pixel, interpolation_size)\n", + " for pixel in landmarks_img\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "landmark_points_3d = backproject_points(intrinsics, rgb_depth_values, landmarks_img)\n", + "landmark_points_3d_render = np.array(landmark_points_3d)\n", + "landmark_points_3d_render[:,2] = -landmark_points_3d_render[:,2] # Invert z-coordinate for easier rendering (landmarks will be right in front of camera)\n", + "if isinstance(loader, IPhoneDataLoader):\n", + " landmark_points_3d_render *= 1000 # meter to millimeter" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "landmark_points_3d_median = geometric_median(landmark_points_3d_render)\n", + "distances_from_median = np.linalg.norm(\n", + " landmark_points_3d_render - landmark_points_3d_median,\n", + " axis=1,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "threshold_landmark_deviation = 500 # It can happen that depth information is bad and back-projected landmark points are far away from the other. These should be ignored\n", + "valid_landmark_points_3d = np.where(\n", + " (\n", + " np.array(rgb_depth_values) != 0\n", + " ) & (\n", + " distances_from_median < threshold_landmark_deviation\n", + " )\n", + ")[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "There are 3 pixels without depth information.\n" + ] + } + ], + "source": [ + "pixels_without_depth = 68 - len(valid_landmark_points_3d)\n", + "if pixels_without_depth > 0:\n", + " print(f\"There are {pixels_without_depth} pixels without depth information.\")" + ] + }, + { + "source": [ + "## 3.1 Restrict Pointcloud to Facial Points " + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "face_depth_values = []\n", + "face_pixels = []\n", + "for x in range(face_pos.left(), face_pos.right() + 1):\n", + " for y in range(face_pos.top(), face_pos.bottom() + 1):\n", + " pixel = [x, y]\n", + " face_depth_value = interpolate_around(\n", + " rgb_depth_img, pixel, interpolation_size,\n", + " )\n", + " if face_depth_value > 0:\n", + " face_depth_values.append(face_depth_value)\n", + " face_pixels.append(pixel)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "face_pointcloud = backproject_points(\n", + " intrinsics, face_depth_values, face_pixels,\n", + ")\n", + "face_pointcloud[:, 2] = -face_pointcloud[:, 2]\n", + "face_pointcloud_colors = np.array([img[y, x] for x, y in face_pixels])\n", + "if isinstance(loader, IPhoneDataLoader):\n", + " face_pointcloud *= 1000 # Meters to Millimeters" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "body_depth_values = []\n", + "body_pixels = []\n", + "for x in range(img_width):\n", + " for y in range(img_height):\n", + " if (\n", + " x < face_pos.left() or x > face_pos.right()\n", + " ) or (\n", + " y < face_pos.top() or y > face_pos.bottom()\n", + " ):\n", + " pixel = [x, y]\n", + " body_depth_value = interpolate_around(\n", + " rgb_depth_img, pixel, interpolation_size,\n", + " )\n", + " if body_depth_value > 0:\n", + " body_depth_values.append(body_depth_value)\n", + " body_pixels.append(pixel)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "body_pointcloud = backproject_points(\n", + " intrinsics, body_depth_values, body_pixels,\n", + ")\n", + "body_pointcloud[:, 2] = -body_pointcloud[:, 2]\n", + "body_pointcloud_colors = np.array([img[y, x] for x, y in body_pixels])\n", + "if isinstance(loader, IPhoneDataLoader):\n", + " body_pointcloud *= 1000 # Meters to Millimeters" + ] + }, + { + "source": [ + "# 4. ICP" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "source": [ + "## 4.1 Sparse Reconstruction" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "n_params_shape_sparse = 3 # 20\n", + "n_params_expression_sparse = 3 # 10\n", + "n_params_color_sparse = 3 # 20\n", + "weight_shape_params_sparse = 100 # 10000\n", + "weight_expression_params_sparse = 100 # 1000\n", + "weight_color_params_sparse = 1000 # 1000\n", + "l2_regularization_sparse = 10000 # regularizes only face model parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "sparse_optimizer = BFMOptimization(\n", + " bfm, \n", + " n_params_shape=n_params_shape_sparse,\n", + " n_params_expression=n_params_expression_sparse,\n", + " n_params_color=n_params_color_sparse,\n", + " weight_shape_params=weight_shape_params_sparse,\n", + " weight_expression_params=weight_expression_params_sparse,\n", + " weight_color_params=weight_color_params_sparse,\n", + " rotation_mode='lie',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from math import sin, cos\n", + "from numpy.linalg import det\n", + "\n", + "initial_camera_pose = np.eye(4)\n", + "initial_camera_pose[2, 3] = -100 # position face already on pointcloud\n", + "\n", + "if sparse_optimizer.rotation_mode == 'lie':\n", + " theta = 0.0001\n", + " initial_camera_pose[:3, :3] = np.array([\n", + " [1, 0, 0],\n", + " [0, cos(theta), -sin(theta)],\n", + " [0, sin(theta), cos(theta)],\n", + " ])\n", + " assert abs(det(initial_camera_pose) - 1.0) < 0.00001 \n", + "\n", + "initial_params = sparse_optimizer.create_parameters(\n", + " [0 for _ in range(n_shape_coefficients)],\n", + " [0 for _ in range(n_expression_coefficients)],\n", + " [0 for _ in range(n_color_coefficients)],\n", + " initial_camera_pose,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 4.4337e+06 6.58e+06 \n", + " 1 2 2.2036e+06 2.23e+06 9.16e+01 3.48e+06 \n", + " 2 3 1.8213e+05 2.02e+06 1.99e+02 2.86e+05 \n", + " 3 4 2.2983e+04 1.59e+05 9.07e+01 1.95e+05 \n", + " 4 5 1.4880e+04 8.10e+03 2.10e+01 1.38e+05 \n", + " 5 6 1.3964e+04 9.16e+02 9.04e+00 5.60e+04 \n", + " 6 7 1.3897e+04 6.66e+01 1.30e+00 5.28e+04 \n", + " 7 8 1.3894e+04 3.66e+00 4.81e-01 3.16e+04 \n", + " 8 9 1.3887e+04 6.29e+00 2.57e-02 2.62e+04 \n", + " 9 17 1.3887e+04 0.00e+00 0.00e+00 2.62e+04 \n", + "`xtol` termination condition is satisfied.\n", + "Function evaluations 17, initial cost 4.4337e+06, final cost 1.3887e+04, first-order optimality 2.62e+04.\n" + ] + } + ], + "source": [ + "sparse_loss = sparse_optimizer.create_sparse_loss_3d(\n", + " bfm_landmark_indices[valid_landmark_points_3d],\n", + " landmark_points_3d_render[valid_landmark_points_3d],\n", + " regularization_strength=l2_regularization_sparse\n", + ")\n", + "sparse_context = sparse_optimizer.create_optimization_context(\n", + " sparse_loss,\n", + " initial_params,\n", + ")\n", + "result = sparse_context.run_optimization(sparse_loss, initial_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "assert (\n", + " sparse_context.create_parameters_from_theta(\n", + " initial_params.to_theta()\n", + " ).camera_pose - initial_params.camera_pose < 1e-8\n", + ").all(), \"OptimizationParameters is ill-defined\"" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "params_sparse = sparse_context.create_parameters_from_theta(result.x)" + ] + }, + { + "source": [ + "## 4.2 Dense Reconstruction with ICP\n", + "### (With RGB Space Residuals)" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# FACE_VERTICES: every face vertex will be assigned\n", + "# its nearest neighbor in pointcloud\n", + "# POINTCLOUD: every point in pointcloud will be assigned\n", + "# its nearest neighbor in face model\n", + "nn_mode = NearestNeighborMode.FACE_VERTICES\n", + "distance_type = DistanceType.POINT_TO_POINT\n", + "icp_iterations = 5\n", + "optimization_steps_per_iteration = 15\n", + "l2_regularization_dense = 100 # 10000 for Lie" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "n_params_shape_dense = 30 # 20\n", + "n_params_expression_dense = 30 # 10\n", + "n_params_color_dense = 30 # 20\n", + "weight_shape_params_dense = 100 # 10000, 10000000000 for POINT_TO_PLANE\n", + "weight_expression_params_dense = 100 # 1000, 10000000000 for POINT_TO_PLANE\n", + "weight_color_params_dense = 10000" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "dense_optimizer = BFMOptimization(\n", + " bfm, \n", + " n_params_shape=n_params_shape_dense,\n", + " n_params_expression=n_params_expression_dense,\n", + " n_params_color=n_params_color_dense,\n", + " weight_shape_params=weight_shape_params_dense, \n", + " weight_expression_params=weight_expression_params_dense,\n", + " weight_color_params=weight_color_params_dense,\n", + " rotation_mode='lie',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 7.5809e+07 2.76e+11 \n", + " 1 2 1.3433e+07 6.24e+07 3.08e+00 8.33e+08 \n", + " 2 3 1.3332e+07 1.00e+05 2.84e+00 2.69e+08 \n", + " 3 4 1.3296e+07 3.57e+04 2.67e-01 8.74e+07 \n", + " 4 5 1.3273e+07 2.34e+04 1.91e-01 3.65e+07 \n", + " 5 6 1.3254e+07 1.87e+04 2.40e-01 1.82e+07 \n", + " 6 7 1.3241e+07 1.39e+04 2.16e-01 9.59e+06 \n", + " 7 8 1.3230e+07 1.09e+04 1.38e-01 9.07e+06 \n", + " 8 9 1.3221e+07 8.50e+03 1.50e-01 4.14e+06 \n", + " 9 10 1.3214e+07 6.69e+03 1.83e-01 4.18e+06 \n", + " 10 11 1.3208e+07 5.99e+03 2.17e-01 4.40e+06 \n", + " 11 12 1.3202e+07 6.07e+03 1.12e-01 3.76e+06 \n", + " 12 13 1.3198e+07 4.19e+03 2.58e-01 2.83e+06 \n", + " 13 14 1.3194e+07 3.92e+03 1.93e-01 5.17e+06 \n", + " 14 15 1.3191e+07 3.23e+03 1.29e-01 4.44e+06 \n", + "The maximum number of function evaluations is exceeded.\n", + "Function evaluations 15, initial cost 7.5809e+07, final cost 1.3191e+07, first-order optimality 4.44e+06.\n", + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 1.3242e+07 3.50e+09 \n", + " 1 2 1.3155e+07 8.68e+04 9.06e-01 1.83e+08 \n", + " 2 3 1.3147e+07 8.17e+03 2.14e-01 3.83e+07 \n", + " 3 4 1.3142e+07 4.79e+03 1.98e-01 1.98e+07 \n", + " 4 5 1.3138e+07 4.02e+03 1.64e-01 1.68e+07 \n", + " 5 6 1.3135e+07 2.95e+03 1.73e-01 3.89e+06 \n", + " 6 7 1.3132e+07 2.75e+03 1.58e-01 3.49e+06 \n", + " 7 8 1.3130e+07 2.24e+03 1.72e-01 4.20e+06 \n", + " 8 9 1.3128e+07 2.11e+03 1.44e-01 4.91e+06 \n", + " 9 10 1.3126e+07 1.93e+03 1.90e-01 6.40e+06 \n", + " 10 11 1.3124e+07 1.75e+03 1.96e-01 4.60e+06 \n", + " 11 12 1.3123e+07 1.34e+03 9.35e-02 4.64e+06 \n", + " 12 13 1.3122e+07 1.24e+03 7.41e-02 3.57e+06 \n", + " 13 14 1.3121e+07 9.31e+02 1.05e-01 3.33e+06 \n", + " 14 15 1.3119e+07 1.42e+03 1.80e-01 4.45e+06 \n", + "The maximum number of function evaluations is exceeded.\n", + "Function evaluations 15, initial cost 1.3242e+07, final cost 1.3119e+07, first-order optimality 4.45e+06.\n", + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 1.3079e+07 2.48e+09 \n", + " 1 2 1.2994e+07 8.54e+04 6.90e-01 8.89e+07 \n", + " 2 3 1.2990e+07 3.52e+03 3.06e-01 2.82e+07 \n", + " 3 4 1.2988e+07 2.43e+03 2.88e-01 1.08e+07 \n", + " 4 5 1.2986e+07 1.78e+03 1.99e-01 4.97e+06 \n", + " 5 6 1.2985e+07 1.35e+03 1.18e-01 3.89e+06 \n", + " 6 7 1.2983e+07 1.38e+03 1.17e-01 4.95e+06 \n", + " 7 8 1.2982e+07 1.18e+03 2.14e-01 4.37e+06 \n", + " 8 9 1.2981e+07 1.06e+03 1.36e-01 3.50e+06 \n", + " 9 10 1.2980e+07 9.89e+02 8.88e-02 3.27e+06 \n", + " 10 11 1.2979e+07 9.20e+02 1.79e-01 4.28e+06 \n", + " 11 12 1.2978e+07 9.10e+02 1.74e-01 3.29e+06 \n", + " 12 13 1.2978e+07 8.24e+02 9.59e-02 2.66e+06 \n", + " 13 14 1.2977e+07 6.66e+02 1.46e-01 3.29e+06 \n", + " 14 15 1.2976e+07 6.63e+02 2.40e-01 3.75e+06 \n", + "The maximum number of function evaluations is exceeded.\n", + "Function evaluations 15, initial cost 1.3079e+07, final cost 1.2976e+07, first-order optimality 3.75e+06.\n", + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 1.3050e+07 2.01e+09 \n", + " 1 2 1.3001e+07 4.84e+04 6.85e-01 4.25e+07 \n", + " 2 3 1.2999e+07 2.41e+03 3.49e-01 8.47e+06 \n", + " 3 4 1.2997e+07 1.69e+03 1.72e-01 4.20e+06 \n", + " 4 5 1.2996e+07 1.09e+03 3.10e-01 3.58e+06 \n", + " 5 6 1.2995e+07 1.08e+03 1.43e-01 3.35e+06 \n", + " 6 7 1.2994e+07 8.77e+02 1.70e-01 6.25e+06 \n", + " 7 8 1.2993e+07 8.25e+02 1.80e-01 4.31e+06 \n", + " 8 9 1.2993e+07 6.11e+02 4.88e-02 4.08e+06 \n", + " 9 10 1.2992e+07 9.37e+02 2.07e-01 5.35e+06 \n", + " 10 11 1.2991e+07 6.08e+02 1.16e-01 4.73e+06 \n", + " 11 12 1.2991e+07 5.39e+02 9.86e-02 3.49e+06 \n", + " 12 13 1.2990e+07 6.00e+02 2.02e-01 4.65e+06 \n", + " 13 14 1.2989e+07 5.29e+02 1.17e-01 4.37e+06 \n", + " 14 15 1.2989e+07 5.83e+02 2.01e-01 5.67e+06 \n", + "The maximum number of function evaluations is exceeded.\n", + "Function evaluations 15, initial cost 1.3050e+07, final cost 1.2989e+07, first-order optimality 5.67e+06.\n", + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 1.3071e+07 7.48e+08 \n", + " 1 2 1.3035e+07 3.55e+04 5.82e-01 4.87e+07 \n", + " 2 3 1.3033e+07 1.68e+03 2.86e-01 4.68e+06 \n", + " 3 4 1.3032e+07 1.27e+03 2.21e-01 6.44e+06 \n", + " 4 5 1.3031e+07 9.21e+02 2.04e-01 7.54e+06 \n", + " 5 6 1.3030e+07 9.29e+02 2.31e-01 2.99e+06 \n", + " 6 7 1.3029e+07 9.27e+02 3.28e-01 3.27e+06 \n", + " 7 8 1.3029e+07 7.84e+02 9.14e-02 4.50e+06 \n", + " 8 9 1.3028e+07 4.75e+02 9.71e-02 6.86e+06 \n", + " 9 10 1.3028e+07 5.86e+02 3.21e-01 5.46e+06 \n", + " 10 11 1.3027e+07 5.77e+02 1.99e-01 3.58e+06 \n", + " 11 12 1.3026e+07 5.72e+02 8.33e-02 4.97e+06 \n", + " 12 13 1.3026e+07 4.01e+02 1.33e-01 3.06e+06 \n", + " 13 14 1.3025e+07 5.31e+02 2.55e-01 2.94e+06 \n", + " 14 15 1.3025e+07 5.37e+02 1.56e-01 3.63e+06 \n", + "The maximum number of function evaluations is exceeded.\n", + "Function evaluations 15, initial cost 1.3071e+07, final cost 1.3025e+07, first-order optimality 3.63e+06.\n" + ] + } + ], + "source": [ + "weight_sparse_term = 1\n", + "weight_color_term = 200\n", + "\n", + "params_combined, distances, dense_param_history = run_icp_combined(\n", + " dense_optimizer, \n", + " bfm_landmark_indices[valid_landmark_points_3d],\n", + " landmark_points_3d_render[valid_landmark_points_3d],\n", + " face_pointcloud,\n", + " bfm,\n", + " params_sparse.with_new_manager(dense_optimizer),\n", + " max_iterations=icp_iterations, \n", + " nearest_neighbor_mode=nn_mode, \n", + " distance_type=distance_type,\n", + " weight_sparse_term=weight_sparse_term,\n", + " weight_color_term=weight_color_term,\n", + " max_nfev=optimization_steps_per_iteration,\n", + " l2_regularization=l2_regularization_dense,\n", + " pointcloud_normals=pointcloud_normals,\n", + " pointcloud_colors=face_pointcloud_colors/255.0,\n", + ")" + ] + }, + { + "source": [ + "# 5. Render Face Reconstruction" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "params_render = params_combined" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "face_mesh = bfm.draw_sample(\n", + " shape_coefficients=params_render.shape_coefficients,\n", + " expression_coefficients=params_render.expression_coefficients,\n", + " color_coefficients=params_render.color_coefficients,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def setup_scene(\n", + " show_pointcloud=True,\n", + " show_mask=True,\n", + " show_pointcloud_face=False,\n", + " cut_around_face=4,\n", + "):\n", + " bfm_vertices = params_render.camera_pose @ add_column(\n", + " face_mesh.vertices, 1\n", + " ).T\n", + " distances, indices = nearest_neighbors(pointcloud, bfm_vertices[:3, :].T)\n", + " pointcloud_mask = distances > cut_around_face\n", + " \n", + " perspective_camera = get_perspective_camera(\n", + " intrinsics, img_width, img_height,\n", + " )\n", + " scene = setup_standard_scene(perspective_camera)\n", + " if show_pointcloud and show_pointcloud_face:\n", + " scene.add(\n", + " pyrender.Mesh.from_points(\n", + " pointcloud[pointcloud_mask],\n", + " colors=colors[pointcloud_mask],\n", + " ),\n", + " )\n", + " if show_mask:\n", + " scene.add(\n", + " pyrender.Mesh.from_trimesh(\n", + " bfm.convert_to_trimesh(face_mesh),\n", + " ),\n", + " pose=params_render.camera_pose,\n", + " )\n", + " if not show_pointcloud and show_pointcloud_face:\n", + " scene.add(\n", + " pyrender.Mesh.from_points(\n", + " face_pointcloud,\n", + " colors=face_pointcloud_colors,\n", + " ),\n", + " )\n", + " if show_pointcloud and not show_pointcloud_face:\n", + " scene.add(\n", + " pyrender.Mesh.from_points(\n", + " body_pointcloud,\n", + " colors=body_pointcloud_colors,\n", + " ),\n", + " )\n", + " return scene" + ] + }, + { + "source": [ + "## 5.1. Interactive 3D Rendering" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "scene = setup_scene(\n", + " show_pointcloud=True,\n", + " show_mask=True,\n", + " show_pointcloud_face=True,\n", + " cut_around_face=8,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Viewer(width=192, height=256)" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ], + "source": [ + "pyrender.Viewer(\n", + " scene,\n", + " use_raymond_lighting=True,\n", + " viewport_size=(img_width, img_height),\n", + ")" + ] + }, + { + "source": [ + "## 5.2. Render mask onto Input Image" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "scene = setup_scene(show_pointcloud=False, show_mask=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "r = pyrender.OffscreenRenderer(img_width, img_height)\n", + "color, depth = r.render(scene)\n", + "r.delete()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-02-23T16:29:10.669159\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.4, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "img_with_mask = np.array(img)\n", + "img_with_mask[depth != 0] = color[depth != 0]\n", + "plt.imshow(img_with_mask)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 38 + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-02-23T16:29:11.392159\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.4, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "plt.imshow(img)" + ] + }, + { + "source": [ + "# 6. Diagnostics" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def store_param_history(plot_manager, param_history):\n", + " for i, params in enumerate(param_history):\n", + " face_mesh = bfm.draw_sample(\n", + " shape_coefficients=params.shape_coefficients,\n", + " expression_coefficients=params.expression_coefficients,\n", + " color_coefficients=params.color_coefficients,\n", + " )\n", + " translation = np.zeros((4, 4))\n", + " translation[2, 3] = -150\n", + "\n", + " perspective_camera = get_perspective_camera(\n", + " intrinsics, img_width, img_height,\n", + " )\n", + " scene = setup_standard_scene(perspective_camera)\n", + " scene.add(\n", + " pyrender.Mesh.from_points(\n", + " pointcloud,\n", + " colors=colors,\n", + " ),\n", + " pose=np.eye(4) + translation,\n", + " )\n", + " scene.add(\n", + " pyrender.Mesh.from_trimesh(\n", + " bfm.convert_to_trimesh(face_mesh),\n", + " ),\n", + " pose=params.camera_pose + translation,\n", + " )\n", + "\n", + " r = pyrender.OffscreenRenderer(img_width * 2, img_height * 2)\n", + " color, depth = r.render(scene)\n", + " r.delete()\n", + "\n", + " fig = plt.figure(figsize=(8, 12))\n", + " plt.imshow(color)\n", + " plot_manager.save_current_plot(f\"iteration_{i:05d}.jpg\")\n", + " plt.close()" + ] + }, + { + "source": [ + "## 6.1. Render Optimization Parameters per Step (Sparse) " + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "plot_manager = PlotManager.new_run(\"3d_sparse_reconstruction/fitting\")\n", + "store_param_history(plot_manager, sparse_context.get_param_history())\n", + "plot_manager.generate_video('iteration_', '.jpg')" + ] + }, + { + "source": [ + "## 6.2. Render Optimization Parameters per Step (Dense) " + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "plot_manager = PlotManager.new_run(\"3d_dense_reconstruction/fitting\")\n", + "store_param_history(plot_manager, dense_param_history)\n", + "plot_manager.generate_video('iteration_', '.jpg')" + ] + }, + { + "source": [ + "## 6.3. Reconstruction Error" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "plot_manager = PlotManager(\"reconstruction_error\")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "scene = setup_scene(show_pointcloud=False, show_mask=True)\n", + "r = pyrender.OffscreenRenderer(img_width, img_height)\n", + "color, depth = r.render(scene)\n", + "r.delete()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "diff_img = np.abs(depth_img * 1000 - depth)\n", + "diff_img[depth == 0] = None" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-02-23T16:30:37.351776\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.4, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "plt.imshow(diff_img)\n", + "plt.colorbar()\n", + "plt.clim(0, 50);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([ 3.80840621, 0.04647589, -1.02898768, 0.05051727, 0.38810754,\n", + " -2.05815784, -0.83174345, 2.38231227, 0.05410276, -1.63962742,\n", + " -3.1516355 , 0.62286155, -0.50224901, -0.66143396, -0.61374345,\n", + " 1.60328632, -2.74153056, -0.07178942, -1.62855546, 3.06203022,\n", + " 0.85460254, 0.39867293, -0.18572284, -0.81832088, 1.87975054,\n", + " -1.53856994, -0.34519237, 1.82177137, -1.41537652, 2.88724122,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. ])" + ] + }, + "metadata": {}, + "execution_count": 46 + } + ], + "source": [ + "dense_param_history[-1].color_coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ] +} \ No newline at end of file