DOI: 10.5061/dryad.mkkwh719r
title: A "morphogenetic action" principle for 3D shape formation by the growth of thin sheets

description: How does growth encode form in developing organisms? Many
 different spatiotemporal growth profiles may sculpt tissues into the same
 target 3D shapes, but only specific growth patterns are observed in animal
 and plant development. In particular, growth profiles may differ
 in their degree of spatial variation and growth anisotropy, however, the
 criteria that distinguish observed patterns of growth from other possible
 alternatives are not understood. Here we exploit the mathematical
 formalism of quasiconformal transformations to formulate the problem of
 ``growth pattern selection'' quantitatively in the context of 3D
 shape formation by growing 2D epithelial sheets. We propose that
 nature settles on growth patterns that are the `simplest' in a
 certain way. Specifically, we demonstrate that growth pattern
 selection can be formulated as an optimization problem and solved for the
 trajectories that minimize spatiotemporal variation in areal growth rates
 and deformation anisotropy.  The result is a complete prediction
 for the growth of the surface, including not only a set of intermediate
 shapes, but also a prediction for cell displacement along those surfaces
 in the process of growth. Optimization of growth trajectories for
 both idealized surfaces and those observed in nature show that relative
 growth rates can be uniformized at the cost of introducing
 anisotropy. Minimizing the variation of programmed growth rates
 can therefore be viewed as a generic mechanism for growth pattern
 selection and may help to understand the prevalence of anisotropy in
 developmental programs.
description: Analysis of growing appendage in <em>Parhyale
 hawaiensis</em> The recording of the transgenic
 Parhyale embryo with a construct for heat-inducible expression of a
 nuclear marker (H2B-mRFPruby) was generated using multi-view lightsheet
 fluorescence microscopy (LSFM) with 7.5 minute time intervals beginning 3
 days after egg lay (AEL). More details regarding data acquisition and
 pre-processing can be found in [1]. Our analysis
 focused on a period of dramatic outgrowth in the T2 appendage from 95 −
 109h AEL and utilized tissue cartography methods to generate
 coarse-grained flow patterns on cells on the growing limb [2, 3].
 Down-sampled data volumes were effectively denoised using Ilastik [4] by
 training a classifier to distinguish tissue from background. The result of
 this step was a pixel probability map for each time point (with high
 values in tissue regions and low values in background regions).
 Segmented nuclei positions from [1] were then used to help
 distinguish the limb from surrounding tissue structures. Alpha shapes of
 the sparse nuclei locations were generated using MATLAB’s
 <strong>alphaShape</strong> function with a sufficiently high
 hole threshold to ensure that the resulting surfaces were water tight. The
 pixel probability maps were then multiplied by an exponentially decaying
 radial basis function of the distance to the alpha surface to suppress
 probability away from the actual limb. The original tracking from [1] was
 only logged every 45 minutes, so we linearly interpolated between these
 locations to take advantage of the full time resolution of the data set.
 The processed probability maps were then segmented using an active contour
 method [5]. The result was a binary level set indicating the location of
 all limb specific tissue. A point cloud approximating the mid-surface of
 the limb was obtained using a weighted locally optimal projection point
 cloud (WLOP) simplification algorithm [6]. In order to
 produce surface triangulations, we first estimated the boundary of the
 mid-surface point cloud using a custom modified version of the algorithm
 in [7]. Next, we found the point that was farthest from the boundary by
 calculating geodesic distances directly on the point cloud [8]. We then
 used the vector heat method [9] to compute the logarithmic map around this
 point. The logarithmic map is a local parameterization about a
 point, where for each point on the surface the magnitude of the log map
 gives the geodesic distance from the source, and the polar coordinate of
 the log map gives the direction at which a geodesic must leave the source
 to arrive at the point. This enabled us to embed the points in
 2D, construct a Delaunay triangulation, and then lift the triangulation
 back into 3D. Triangulated time-dependent surfaces were then mapped
 conformally into the unit disk using a custom-implementation of the
 discrete Ricci flow [10]. The conformal degrees of freedom in the
 time-dependent parameterization were pinned by finding an optimal Möbius
 transformation that matched the neighborhood structure of nuclei locations
 at subsequent times without explicit reference to nuclei identity
 [11]. Once pulled back into the plane, an updated
 tracking for the nuclei was performed in 2D using a custom built MATLAB
 GUI enabling the reconstruction of nuclear lineages and cell tracks. The
 3D displacement vectors between identified nuclei at subsequent times
 constituted a sparse set of surface velocities at isolated points. We once
 again employed the vector heat method to extend these velocities to the
 entire surface and then smooth them. These velocities were then used to
 compute the components of the growth tensor (i.e. the time derivative of
 the Lagrangian metric tensor) with respect to the instantaneous virtual
 isothermal parameterization of the surface. The infinitesimal change in
 deformation anisotropy γ from time <em>t</em> to
 <em>t</em>+1 could then be directly extracted from the growth
 tensor. We then computed the corresponding update to the 2D quasiconformal
 parameterization by feeding γ into a custom implementation of the Beltrami
 Holomorphic Flow algorithm [12]. The complete material flow was then
 assembled by iteratively propagating the surface mesh at the final time
 backwards along these quasiconformal mappings in the plane and pushing the
 resulting 2D parameterizations forward into 3D using the instantaneous
 conformal mappings and a natural neighbor interpolation scheme
 [13].
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- [1] C. Wolff, J.-Y. Tinevez, T. Pietzsch, E. Stamataki, B. Harich, L. Guignard, S. Preibisch, S. Shorte, P. J. Keller, P. Tomancak, and A. Pavlopoulos, "Multi-view light-sheet imaging and tracking with the MaMuT software reveals the cell lineage of a direct developing arthropod limb", <em>eLife</em> <strong>7</strong>, e34410 (2018). [2] I. Heemskerk and S. J. Streichan, "Tissue cartography: compressing bio-image data by dimensional reduction", <em>Nature Methods</em> <strong>12</strong>, 1139 (2015). [3] N. P. Mitchell and D. J. Cislo, "Tubular: tracking in toto deformations of dynamic tissues via constrained maps", <em>Nature Methods</em><strong> 20</strong>, 1980 (2023). [4] S. Berg, D. Kutra, T. Kroeger, C. N. Straehle, B. X. Kausler, C. Haubold, M. Schiegg, J. Ales, T. Beier, M. Rudy, K. Eren, J. I. Cervantes, B. Xu, F. Beuttenmueller, A. Wolny, C. Zhang, U. Koethe, F. A. Hamprecht, and A. Kreshuk, "ilastik: interactive machine learning for (bio)image analysis", <em>Nature Methods</em> <strong>16</strong>, 1226 (2019). [5] T. Chan and L. Vese, "Active contours without edges", <em>IEEE Transactions on Image Processing</em> <strong>10</strong>, 266 (2001). [6] H. Huang, D. Li, H. Zhang, U. Ascher, and D. Cohen-Or, "Consolidation of unorganized point clouds for surface reconstruction", <em>ACM Transactions on Graphics</em> <strong>28</strong>, 1 (2009). [7] C. Mineo, S. G. Pierce, and R. Summan, "Novel algorithms for 3d surface point cloud boundary detection and edge reconstruction", <em>Journal of Computational Design and Engineering</em> <strong>6</strong>, 81 (2019). [8] K. Crane, C. Weischedel, and M. Wardetzky, "The heat method for distance computation", <em>Commun. ACM</em> <strong>60</strong>, 90 (2017). [9] N. Sharp, Y. Soliman, and K. Crane, "The vector heat method", <em>ACM Trans. Graph.</em> <strong>38</strong> (2019). [10] W. Zeng and X. D. Gu, "Ricci Flow for Shape Analysis and Surface Registration", SpringerBriefs in Mathematics (Springer New York, New York, NY, 2013). [11] H. Le, T.-J. Chin, and D. Suter, "Conformal Surface Alignment with Optimal Möbius Search", in <em>2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR)</em>, Vol. 2016-Decem (IEEE, 2016) pp. 2507–2516. [12]  L. M. Lui, T. W. Wong, W. Zeng, X. Gu, P. M. Thompson, T. F. Chan, and S.-T. Yau, "Optimization of Surface Registrations Using Beltrami Holomorphic Flow", <em>Journal of Scientific Computing</em> <strong>50</strong>, 557 (2012). [13]  R. Sibson, "A brief description of natural neighbor interpolation", in<em> Interpreting Multivariate Data</em>, edited by V. Barnett (John Wiley & Sons, New York, 1981) pp. 21–36.
description: ## OptimalGrowthData ### External Code This repository relies on a modest
 amount of external code in order to run properly. Unfortunately, due to
 licensing concerns, that code cannot be directly included in this
 repository. If you want run the various scripts in this repository, you
 must first download the open source MATLAB software package
 [`gptoolbox`](https://github.com/alecjacobson/gptoolbox.git). Among a
 great deal of additional functionality, this package contains the
 `readOFF` function which enables users to open the many `.off` mesh files.
 Add these functions to the MATLAB path using: ```
 addpath(genpath('/Path/To/gptoolbox')); ``` Please note that you
 do not actually need to install `gptoolbox`. You merely have to clone the
 GitHub repository and add it to your path. If you would like to install
 it, please consult the extensive installation instructions on that GitHub
 page. ### Mesh Data Format Most of the data is surface mesh data stored in
 `.off` format. You can view these meshes using software like
 [Meshlab](https://www.meshlab.net/) or process them directly in MATLAB.
 All files in this repo are saved in the same format and can be loaded into
 the MATLAB workspace using the command ``` [V, F, U] =
 readOFF(meshFileName); ``` Where `V` is an *|V| X 3* list of 3D vertex
 coordinates, `F` is a *|F| X 3* face connectivity list and `U` is a *|U| X
 2* list of 2D vertex coordinates in the virtual isothermal
 parameterization of that surface (i.e. conformal texture coordinates). ##
 Directory Structure and Data Descriptions Below is a schematic of the data
 repository directory structure and a description of the various data
 files. For all files corresponding to the *Parhyale* data (e.g. the
 contents of `Measured_Parhyale_Leg_Meshes_and_Nuclei/` and
 `Optimized_Parhyale_Leg_Meshes/`) the time points run from `T0230 - T290`,
 where `T0230` corresponds to 101.6 h after egg lay (AEL) and the
 resolution is 7.5 min per timepoint. For all of the synthetic data (e.g.
 the contents of `Synthetic_Example_Meshes/`), there are 100 time points in
 arbitrary units. ``` OptimalGrowthData/ ├──
 Measured_Parhyale_Leg_Meshes_and_Nuclei/ │ ├──
 Annotated_Textured_Surface_T%04d.png │ ├── clip_iso_mesh_T%04d.off │ ├──
 Disk_MIP_T%04d.tif │ ├── isoClipGraph.mat │ └── lagrangian_mesh_T%04d.off
 ├── MINGOCpp_Reproducibility_Examples/ │ ├──
 Hemiellipsoid_Synthetic_Reporducibility_Example.mat │ ├──
 Hemisphere_Synthetic_Reporducibility_Example.mat │ ├──
 Parhyale_PMP_Reporducibility_Example.mat │ └──
 Parhyale_PP_Reproducibility_Example.mat ├── Optimized_Parhyale_Leg_Meshes/
 │ ├── mesh_conf_T%04d.off │ ├── mesh_pmp_T%04d.off │ └── mesh_pp_T%04d.off
 ├── Synthetic_Example_Meshes/ │ ├── Custom_Growth_Meshes/ | | └──
 custom_growth_mesh_T%04d.off │ ├── Ellipsoid_Meshes/ | | ├──
 ellipsoid_conformal_mesh_T%04d.off | | └──
 ellipsoid_optimal_mesh_T%04d.off │ └── Sphere_Meshes/ | | ├──
 sphere_conformal_mesh_T%04d.off | | └── sphere_optmal_mesh_T%04d.off ├──
 navigate_mesh_timepoints.mlapp ├──
 View_Measured_vs_Optimized_Mesh_Data_Script.m └──
 View_Parhyale_Leg_Nuclear_Tracking.m ``` ####
 Measured\_Parhyale\_Leg\_Meshes\_and\_Nuclei *
 `Annotated_Textured_Surface_T%04d.png`: Annotated images of the growing
 *Parhyale* limb in 3D with surface texture and nuclear tracking. See Fig.
 5e-h and Supplementary Movie 4. * `clip_iso_mesh_T%04d.off`: Isotropic
 surface meshes corresponding to the growing *Parhyale* limb. Note that
 meshes at different time points have different topologies. These meshes
 are suitable for surface rendering, but not for computations of Lagrangian
 dynamical quantities. * `Disk_MIP_T%04d.tif`: Conformal pullback images of
 the leg midsurfaces to the unit disk. * `isoClipGraph.mat`: A MATLAB
 `digraph` object containing details of the nuclear tracking. Nodes
 correspond to cells at a time $t$ and edges connect cells at time $t$ to
 the corresponding cells at time $t+1$. Fields are included for 3D nuclei
 positions, 2D nuclei positions in the unit disk, and 2D nuclei positions
 in the pixel space of the conformal pullbacks. *
 `lagrangian_mesh_T%04d.off`; Lagrangian surface meshes for the growing
 *Parhyale* limb. All meshes have identical topology such that a vertex
 represents a Lagrangian material parcel in the surface. All Lagrangian
 kinematic/geometric data (e.g. Lagrangian surface velocities) can be
 extracted from these meshes See Fig. 5i, Fig. 5m, Fig. 6a-c, and
 Supplementary Movie 5 #### MINGOCpp\_Reproducibility\_Examples These
 `.mat` files hold sufficient data to re-create the optimization results
 seen in in Figs. 4-6. These cannot actually be re-created using only the
 software contained in this repository. In order to actually run the
 optimizations you must download and install the
 [`MINGROCpp`](https://github.com/DillonCislo/MINGROCpp.git) software
 package. Instructions can be found on that Github page to install the
 package and run the corresponding optimizations. These files are also
 stored on the `MINGROCpp` Github repository and are only included here for
 completeness. All files contain the following variables: * `F`: *|F| X 3*
 face connectivity list. * `confMap3D`: *|V| X 3* vertex coordinate list of
 the conformal parameterization of the final target shape. * `fixIDx`: List
 of vertex IDs whose position remains fixed during optimization. *
 `initMap3D`: *|V| X 3* vertex coordinate list of the initial
 configuration. * `map3D`: *|V| X 3* optimized vertex coordinate list (i.e.
 the output of the optimization routine). * `mingrocOptions`: A struct
 containing the options used to run the optimization. * `mu`: *|V| X 1*
 list of vertex-based complex Beltrami coefficients associated to the
 optimized final configuration. * `w`: *|V| X 1* list of complex vertex
 coordinates in the virtual isothermal parameterization of the optimized
 final configuration. * `x`: *|V| X 2* list of 2D vertex coordinates for
 the Lagrangian parameterization. The included files are: *
 `Hemiellipsoid_Synthetic_Reporducibility_Example.mat`: Necessary data for
 the hemiellipsoidal surface optimiation (Fig. 4d-f) *
 `Hemisphere_Synthetic_Reporducibility_Example.mat`: Necessary data for the
 hemispherical surface optimization (Fig. 4a-c) *
 `Parhyale_PMP_Reporducibility_Example.mat`: Necessary data for the $(+-+)$
 *Parhyale* limb surface optimization (Fig. 5j, Fig. 5n, and Fig. 6e-g) *
 `Parhyale_PP_Reproducibility_Example.mat`: Necessary data for the $(++)$
 *Parhyale* limb surface optimization (Fig. 5k, Fig. 5o, and Fig. 6i-k)
 #### Optimized\_Parhyale\_Leg\_Meshes These meshes are Lagrangian, in the
 sense that all time points have identical topology such that a vertex
 represents a Lagrangian material parcel, but they do not have same
 topology as the `lagrangian_mesh_T%04d.off` meshes and cannot be directly
 compared without some processing. * `mesh_conf_T%04d.off`: Conformal
 growth trajectory for the growing *Parhyale* limb (Fig. 5l and Fig. 5p). *
 `mesh_pmp_T%04d.off`: Optimized (+-+) growth trajectory for the growing
 *Parhyale* limb (Fig. 5j, Fig. 5n, Fig. 6e-g, and Supplementary Movie 7).
 * `mesh_pp_T%04d.off`: Optimized (++) growth trajectory for the growing
 *Parhyale* limb (Fig. 5k, Fig. 5o, Fig. 6i-k, and Supplementary Movie 6).
 #### Synthetic\_Example\_Meshes Lagrangian meshes for the various
 synthetic examples shown in Fig. 4 and Supplementary Movies 1-3. Naming
 convention is self-explanatory. * `custom_growth_mesh_T%04d.off`: See Fig.
 4i and Supplementary Movie 3. * `ellipsoid_conformal_mesh_T%04d.off`: See
 Fig. 4d and Supplementary Movie 2. * `ellipsoid_optimal_mesh_T%04d.off`:
 See Fig. 4e-f and Supplementary Movie 2. *
 `sphere_conformal_mesh_T%04d.off`: See Fig. 4a and Supplementary Movie 1.
 * `sphere_optmal_mesh_T%04d.off`: See Fig. 4b-c and Supplementary Movie 1.
 #### Data Viewing Scripts Some simple scripts and apps to help view and
 process the data contained in this repository. All software tested in both
 MATLAB 2021a and MATLAB 2023a. * `navigate_mesh_timepoints.mlapp`: This
 MATLAB app can be used to view any of the mesh series. It's input
 arguments are a character vector specifying the file naming base and a
 logical value specifying whether to show mesh edges. For example, the
 following code can be executed in the repository's root directory:
 ``` addpath(genpath('/Path/To/gptoolbox')); meshFileBase =
 'Optimized_Parhyale_Leg_Meshes/mesh_conf_T%04d.off';
 navigate_mesh_timepoints(meshFileBase, false); ``` *
 `View_Measured_vs_Optimized_Mesh_Data_Script.m`: A script to compare the
 areal growth rates and deformation anisotropy for the measured *Parhyale*
 limb growth trajectories to the associated conformal growth trajectories,
 optimized $(+-+)$ trajectories, optimized $(++)$ trajectories. In order to
 run this script you must download the
 [`MINGROCpp`](https://github.com/DillonCislo/MINGROCpp.git) package (you
 do not necessarily have to install it -- just cloning it and adding it to
 the path should suffice). * `View_Parhyale_Leg_Nuclear_Tracking.m`: A
 script to view the the measured 3D surface of the growing *Parhyale* limb.
 The script will open a simple viewer that will display the limb and the 2D
 pullbacks with the nuclei locations tagged in both spaces. No
 functionality is included to display the textures on the 3D surface.