1 Introduction↩︎

Generating diverse and high-quality virtual humans plays an important role in numerous applications, including VR/AR, visual effects, game production, etc. The advances in generative models have brought impressive advances to the state-of-the-art of generating 2D virtual avatars, such as images or videos. However, synthesizing 3D humans with high fidelity and large variations remains much under-explored due to the scarcity of 3D human data.

The conventional solution [3]–[6] for acquiring a 3D avatar from a real person is typically a time-consuming and cumbersome process, requiring a specialized capture system, substantial manual efforts, and extensive computation. To circumvent the requirement of collecting a large corpus of 3D ground-truth data, recent works utilize the differentiable rendering technique to train a 3D generative model in a 3D-unsupervised manner [7], [8]. Specifically, instead of using direct 3D supervision, adversarial losses are applied to the images rendered from the synthesized 3D content. However, due to the lack of dense multi-view images for each model, these methods can only encourage geometry-to-image consistency in the selected views while failing to produce plausible reconstruction in the unseen regions. In addition, the differentiable rendering process is computationally heavy, making the network training highly inefficient.

To resolve the above issues, in this work, we present Get3DHuman, a novel 3D generator that can faithfully synthesize high-fidelity clothed 3D humans with a diversity of shapes and textures. Our key observation is that 3D human generators can benefit from the inductive bias from a 2D human synthesizer and the prior knowledge learned through relevant 3D modeling tasks. In particular, to bypass the limited availability of 3D ground truths, we propose to leverage the generative power of 2D human synthesizers which have shown more promising and stable quality than their counterpart 3D generators. We further lift the rich prior from the 2D generator, i.e. StyleGAN-Human [1], to 3D by using the pixel-aligned reconstruction priors, i.e. the pre-trained PIFu network [9], through single-view human reconstruction. Thanks to the strong generalization ability of pixel-aligned implicit reconstructor, by feeding it with a myriad of photorealistic human images generated by StyleGAN-Human, we are able to obtain a vast number of 3D human models with highly diversified body shapes, apparel, poses, and textures. To further ensure the high quality of the generated shapes, we filter out inferior results via manual inspections.

We further materialize the above idea via a novel prior induction mechanism. Specifically, we first train a prior network to encode the 2D generator prior and the 3D reconstruction prior into three supervisory signals. That is, given a random latent code, the prior network would generate normal maps, depth maps, and shape and texture feature volumes of the 3D human corresponding to the input code (see Fig. 1). The input code is sampled from the latent space of StyleGAN-Human while the shape and texture feature volumes are consistent with the PIFu latent, and, hence, can be converted to the predicted human shape via the pre-trained PIFu decoder. We then supervise the training of the proposed 3D generators via three specially-tailored losses. First, a latent prior loss is introduced to provide direct supervision of the generated feature volumes for the shape and texture generation branches. Second, an adversarial loss is applied to the 3D feature volumes instead of the output signed distance field (SDF). This helps reduce the training complexity while ensuring the realism of the generated 3D humans. Lastly, normal maps and depth maps are used for supervising the generation of intermediate feature maps. Specifically, instead of directly transforming the input code into a 3D feature volume, we first map the code to 2D feature maps and then lift them into 3D feature volume. This additional intermediate supervision helps cast finer-grained geometry details as shown in our experiments (see Fig. 5). We further utilize a refinement module to improve the quality of our textured mesh as the texture prior is not always satisfactory.

Our method can support a wide range of applications, including shape generation, interpolation, shape re-texturing, and latent inversion from a single image. We evaluate Get3DHuman via extensive experiments and demonstrate that it strongly outperforms the state-of-the-art methods, both qualitatively and quantitatively.

To summarize, our main contributions include:

2 Related Work↩︎

Constructing generative models for images, videos or 3D models is a fundamental problem in the field of computer graphics and computer vision. Here, we only review and summarize the work related to 2D or 3D human generation that is relevant to our work.

2D Human Generation. In recent years, generative adversarial networks (GANs) [10] has been successfully applied to the task of image synthesis. Many methods have built photorealism generative models of 2D human faces [11]–[13]. Based on the success of these efforts, faces can also be efficiently edited  [14]–[16]. On another line, some researchers attempt to generate 2D images of dressed humans from sketch, pose, or text conditions [17]–[21]. The recent works of [1], [22] have built large-scale datasets and resorted to StyleGAN to achieve impressive 2D human generation results. The success in 2D image generation and editing has inspired research in 3D generation.

3D Human Modeling. As a common representation, parametric human model, like [23]–[30], controls a template through a series of low-dimensional parameters to obtain a 3D naked human body, with which the modeling can be performed by regression approaches. These works are further extended to model dressed human [31], [32], by introducing vertices’ movements on the template meshes. Some other representations are also proposed for dealing with more complex clothed bodies, like point clouds [33]–[35], radiance fields [36]–[39] and implicit fields [40]–[43]. In particular, the implicit field representation has become a powerful tool for modeling 3D (clothed) human shapes, as it can capture arbitrary resolutions and fine-grained details.

PIFu [9] first proposes a pixel-aligned implicit function to extract local features from images to complete human body digitization. They are further expanded to PIFuHD [2], which uses predicted normal maps and a multi-level architecture to generate higher resolution and richer details consistent with the input image.

3D Human Generation. Early approaches aimed to extend GANs to voxel [44], [45], point cloud [46]–[48], implicit [40], [41]. However, these works focus mainly on generating geometry, not appearance.

EG3D [7] proposes to generate multi-view images of a 3D face via introducing an efficient tri-plane representation and a neural rendering design with the help of a pretrained StyleGAN.

Following EG3D, there are also some methods aiming to full-body human generation [49], [50]. Since their adversarial losses are only applied to the rendered images and there is no explicit supervision on the geometry, making the produced shape is far from satisfactory. Similar to our work, GET3D [8] also targets to generate textured 3D meshes. Specifically, it generates an SDF field and a texture field by two latent codes and performs simultaneous optimization of the two fields by adversarial loss on 2D rendered images. In our work, we focus on 3D textured human models and aim to generate 3D textured meshes with diverse human poses and appearances.

Recently, a concurrent work HumanGen [51] is posted on the Internet. Although it also involves the prior of StyleGAN-Human and PIFu for generative model construction, we have a key difference: HumanGen only builds a generative model to produce a texture field from a code where the geometry is directly borrowing from the prior, while ours aims to use two codes to generate both shape field and texture field. In this fashion, different from HumanGen, we truly built a latent space for 3D textured humans.

3 Method↩︎

Fig. 1 shows the overall network of the proposed 3D generator network. Get3DHuman contains parallel shape and texture branches, which is facilitated by a prior network branch during training. Take the shape branch as an example, given a shape latent code, Get3DHuman generates a shape feature \(F_s\), a shape feature volume \(F_{sv}\), and produces a high-quality human shape represented as an SDF (Sec. 3.1). Sec. 3.2 details our prior-facilitated learning of this 3D generator. Sec. 3.3 describes the texture network and its training. Finally, training details including data preparation, and training strategy are described in Sec. 3.5.

3.1 The Proposed 3D Generator↩︎

As shown in Fig. 1 top, it contains three parts, including a StyleGAN-like Mapping & Synthesis stage (\(g_{s}\)), a feature encoder stage (\(g_{sv}\)), and a PIFu-style geometry decoder (\(f_{s}\)). Given a shape latent code \({z}_s\) drawn from a Gaussian distribution, we first use a StyleGAN2 network [12] \(g_s\) to generate a shape feature \(F_s\), which is fed into a hourglass-style [52] fully convolutional feature encoder \(g_{sv}\) to extract a shape feature volume \(F_{sv}\). : \[\begin{gather} \label{eq:shape95gen1} \setlength{\abovedisplayskip}{3pt} \setlength{\belowdisplayskip}{3pt} F_{s} = g_{s}(z_{s}), \\ F_{sv} = g_{sv}(F_{s}), \end{gather}\tag{1}\] where \(z_{s}\) is the random shape latent code, \(F_{s}\) and \(F_{sv}\) are the intermediate pixel-aligned high-dimensional shape feature image and shape feature volume, respectively. With the shape feature volume, a PIFu [9] shape decoder \(f_s\) is used to evaluate the signed distance \(s\in\mathbb{R}\) given a query point \(p\in\mathbb{R}^3\) and its corresponding feature. : \[\begin{align} \label{eq:shape95gen3} \setlength{\abovedisplayskip}{3pt} \setlength{\belowdisplayskip}{3pt} f_{s}(F_{sv}(x), d(p)) = s : s\in\mathbb{R}, \end{align}\tag{2}\] where \(p \in \mathbb{R}^3\) is the 3D query point, \(F_{sv}(x)\) is the image feature at \(p\)’s projected location \(x=\pi(p)\) on the image plane, \(d(p)\) is the depth value of \(p\) in the camera frame, and \(f_{s}\) is the PIFu shape decoder (MLPs) that is pretrained like [2] and fixed.

3.2 Prior-Facilitated Learning↩︎

Besides adversarial loss, we propose to fully utilize the prior information from well-trained networks to facilitate the training of the 3D GAN due to limited training data and the complexity of this task. Specifically, we first utilize image-latent pairs from StyleGAN-Human to learn the latent space better since it already has a reasonable structure after training. Then, we extract intermediate features using the PriorNet branch supervision to guide the training, which can also be seen as a kind of deep supervision. In the following, we first describe how to extract helpful prior information and then describe the training losses.

Prior extraction. The prior network is the concatenation of a StyleGAN-Human [12] generator and a PIFuHD-like [2], [9] 3D reconstructor (see Fig. 1). So, given a latent code, a full body human image is first synthesized by the StyleGAN-Human generator. Then the following 3D reconstructor takes as input the synthesized image and extracts a normal map \(N\), a depth map \(D\), a shape feature volume \(F_{sv}\), and a texture feature volume \(F_{tv}\), which are used as supervisory signals since they contain helpful human prior information.

Shape losses. Given a latent code, the shape generator produces intermediate shape feature \(F_{s}\) and shape feature volume \(F_{sv}\), and the final SDF \(s\) (see Fig. 1). Our training losses include a latent adversarial loss \(\mathcal{L}_{Adv^{sv}}\) applied on the shape feature volume \(F_{sv}\), a SDF loss \(\mathcal{L}_{SDF}\), a latent prior loss \(\mathcal{L}_{sv}\) applied on the shape feature volume, a depth loss \(\mathcal{L}_{D}\) and a normal loss \(\mathcal{L}_{N}\) applied on the first four channels of the intermediate shape feature \(F_{s}\). The loss terms are detailed in the following.

SDF loss \(\mathcal{L}_{SDF}\). We sample \(M\) points per iteration, including near surface points (obtained from depth map) and random points, and apply L1 loss on them. The SDF value is predicted by a pretrained and fixed PIFu MLP decoder [9] \(s = f_{s}(F_{sv}(x), d(p_{i}))\), where \(x=\pi(p)\) is the 2D projection of query point \(p\) and \(d(p)\) is the depth value of \(p\) in the camera coordinate space. \[\setlength{\abovedisplayskip}{3pt} \setlength{\belowdisplayskip}{3pt} \mathcal{L}_{SDF} = \frac{1}{M}\sum_{i}^{M}||\hat{s} - s||_1\]

Latent prior loss \(\mathcal{L}_{sv}\). To take full use of the prior knowledge, we also apply constraints on the intermediate features as follows. Another potential benefit is the sampled 3D points in the previous SDF loss are too sparse while this feature field loss can provide supervision on the whole feature maps. \[\mathcal{L}_{sv} = ||F_{sv} - F_{sv}^{gt}||_1\]

Geometry loss. We force several channels of the intermediate feature maps to predict helpful 2.5D information (i.e. normal) since these feature maps are pixel-aligned (i.e. the spatial information is retained). This operation is similar to deep supervision [53] and helps the learning processing. \[\begin{align} \mathcal{L}_{N\&D} = & \lambda_{N}||\hat{F}_{s(c:1,2,3)} - N||_1 + \\& \lambda_{D}||\hat{F}_{s(c:4)} - D||_1 \end{align}\] where \(\hat{F}_{s(c:1,2,3)}\) and \(\hat{F}_{s(c:4)}\) are the first three and fourth channels of the predicted shape feature \(F_s\), \(D\) and \(N\) is the pseudo groundtruth normal map and depth map.

Latent adversarial loss \(\mathcal{L}_{Adv^{sv}}\). \(\mathcal{D}_{sv}\) is a discriminator taking the shape volume as input. We use the non-saturating GAN loss proposed in StyleGAN2 [12] and R1 regularization [10], [54]. \[\mathcal{L}_{Adv^{sv}} = \mathcal{L}_{GAN^{sv}} + \lambda_{Reg} \mathcal{L}_{Reg^{sv}}\]

In summary, the total shape loss \(\mathcal{L}_{Shape}\) is \[\label{eq:shape95loss} \begin{align} \mathcal{L}_{Shape} = & \lambda_{SDF} \mathcal{L}_{SDF} + \lambda_{sv} \mathcal{L}_{sv} + \lambda_{N} \mathcal{L}_{N} + \\ & \lambda_{D} \mathcal{L}_{D} + \lambda_{Adv^{sv}} \mathcal{L}_{Adv^{sv}} \end{align}\tag{3}\] where \(\lambda_{(\cdot)}\)s are the corresponding loss weights. After training, the shape generator is fixed during the later texture branch learning.

3.3 Texture Generator & Training Losses↩︎

The texture branch is almost a mirror of the shape branch except for several small differences.

Texture generator. The texture branch consists of a StyleGAN-style generator \(g_t\), a feature encoder \(g_{tv}\), a PIFu-style texture decoder \(f_t\), and a texture volume discriminator \(\mathcal{D}_{tv}\). The texture branch is similar to the shape branch except it is additionally conditioned on intermediate features from the shape branch (see Fig. 1 and Eqs. 1 2 ). : \[\begin{gather} \setlength{\abovedisplayskip}{3pt} \setlength{\belowdisplayskip}{3pt} F_{t} = g_{t}(z_{t}), \\ F_{tv} = g_{tv}(F_{t} \oplus F_{s}), \\ f_{t}((F_{tv}(x) \oplus F_{sv}(x)), d(p)) = c \in [0, 1]^3, \end{gather}\] where \(z_{t}\) is texture latent code, \(\oplus\) represents channel-wise concatenation to introduce intermediate features (i.e. \(F_{s}\), \(F_{sv}(x)\)) from the shape branch. Similarly, \(f_{t}\) is the PIFu texture decoder (MLPs) that is pretrained like [9] and fixed. The texture discriminator is also similar to the shape discriminator but with 512 input channels.

Texture losses. Similar to the shape branch, given a texture latent code, the texture branch first generates a texture feature (\(F_{t}\)) and a texture feature volume (\(F_{tv}\)). Different from the shape branch, it also takes as input intermediate shape features (e.g. \(F_s\), \(F_{sv}\)) that are generated using the same latent code \(z\) (i.e. \(z_s\) = \(z_t\)). At the same time, the texture branch use the same latent code to predict a texture feature (\(F_{t}\)). Similarly, the individual texture losses are as follows: \[\begin{gather} \setlength{\abovedisplayskip}{3pt} \setlength{\belowdisplayskip}{3pt} \mathcal{L}_{RGB} = \frac{1}{M}\sum_{i}^{M}||\hat{c} - c||_1, \\ \mathcal{L}_{tv} = ||F_{tv} - F_{tv}^{gt}||_1, \\ \mathcal{L}_{Adv^{tv}} = \mathcal{L}_{GAN^{tv}} + \lambda_{Reg} \mathcal{L}_{Reg^{tv}}, \label{eq:texture95losses} \end{gather}\tag{4}\] The overall texture loss \(\mathcal{L}_{Texture}\) is: \[\mathcal{L}_{Texture} \;=\; \lambda_{RGB} \mathcal{L}_{RGB} \;+ \lambda_{tv} \mathcal{L}_{tv} \;+ \lambda_{Adv^{tv}} \mathcal{L}_{Adv^{tv}} \label{eq:total95texture95loss}\tag{5}\] where \(\lambda_{(\cdot)}\)s are the corresponding loss weights. Note that we fix the shape branch and train the texture branch.

3.4 Refinement Module↩︎

A textured mesh can be obtained from the two implicit fields similar to PIFu [9]. However, due to limited training data, the reconstruction prior learned in the texture field is not always satisfactory. For example, the rendered images could be blurry or sometimes erroneous, which means the corresponding textured meshes extracted from the implicit fields could also be problematic.

To obtain high-quality mesh colors, we propose an extra refinement module, which consists of an image refinement step and a (mesh) texture update step.

Image refinement. The image refinement is realized as an image-to-image (I2I) translation task using a UNet-style [55] network \(g_{r}\). \[\label{eq:refine} \setlength{\abovedisplayskip}{3pt} \setlength{\belowdisplayskip}{3pt} I_{r} = g_{r}(I_{c})\tag{6}\] where \(g_{r}\) is the network, \(I_{c}\) is the rendered image from shape and texture volumes, and \(I_{r}\) is the refined image for later texture extraction. We impose L1 loss and perceptual loss [56] between the refined result and the ground truth image \(I^{gt}\) during training. The loss \(\mathcal{L}_{r}\) is defined as: \[\begin{align} \mathcal{L}_{\text{r}}= & \lambda_{r} ||I_{r} - I^{gt}||_1 + \\& \lambda_{P} \sum_l\left\|\Phi^l(I_{r})-\Phi^l(I^{gt})\right\|_2^2, \end{align} \label{eq:I2I95loss}\tag{7}\] where \(\Phi^l\) denotes the multi-level feature extraction operation using a pretrained VGG network, \(\lambda_{(\cdot)}\)s are the corresponding loss weights.

After image refinement, we can get an person image in the same pose but with sharper and more correct face/cloth details (see Fig. 4).

Vertex-color refinement. With the improved multi-view images, we can paint the extracted mesh \(\mathcal{M}\) with new colors accordingly. Specifically, we utilize surface tracking [57] to render multi-view depth maps paired with those images. With paired depth maps and their corresponding refined images, we can obtain a high-quality colored point cloud \(\mathcal{P}\) via 2D-to-3D projection. Finally, for every mesh vertex \(v\), we paint it with the color of its nearest neighbor point in the colored point cloud \(\mathcal{P}\).

3.5 Data Preparation & Training↩︎

Collecting & filtering data. Three different types of data are used in this work, including 396 high-quality 3D human models, real-world Internet images, and StyleGAN-Human [1] synthesized images. More concretely, the 3D human models are purchased from RenderPeople [58], which include both 3D mesh models and high-resolution texture maps that could be rendered into photorealistic images. The real images are crawled from the Internet and 14,097 are left after a manual selection to exclude extreme poses and oddly shaped costumes that can not be handled by reconstruction prior. The synthesized images are generated using StyleGAN-Human [1] and 69,099 are left after a manual selection to exclude images with obvious artifacts (e.g. distorted body parts).

Extracting pseudo-GT. We extract pseudo-GT for a given image using two prior networks, a human image synthesis network [59] and a single-view reconstruction network [9], which are trained using our RenderPeople data. For a real image, the corresponding pseudo-GT includes a real image, a depth map, a normal map, the shape volume \(\mathcal{F}_{sv}\), and the texture volume \(\mathcal{F}_{tv}\). For a synthesized image, we also stored its corresponding latent code. A pretrained PIFu decoder can easily extract 3D or texture information from specific feature volumes. After the aforementioned pre-processing, we randomly choose 500 (real) and 1500 (synthesis) pseudo-GT for evaluation and use the remaining 81,196 samples during training.

Network training. We train the shape branch, the texture branch, and the refinement network in three separate stages.

In the \(1st\) stage, we only train the shape branch (with the PIFu shape decoder \(f_s\) fixed). Specifically, we train the shape branch using the shape reconstruction losses in Eq. 3 . The \(\lambda_{(\cdot)}\)s are set to \(\{20, 40, 20, 20, 1\}\), empirically. We found the weight of the adversarial loss has an obvious influence on the synthesized 3D models. For example, using too large adversarial loss usually produces unrealistic high-frequency noise, and using too small adversarial loss usually results in overly-smoothed 3D models, showing similar trends to Fig. 3.

In the \(2nd\) stage, we train the texture branch with the shape branch and the PIFu texture decoder \(f_t\) fixed. The prior losses \(\mathcal{L}_{RGB}\), \(\mathcal{L}_{tv}\) and the adversarial loss \(\mathcal{L}_{adv^{tv}}\) in Eq. 5 are applied simultaneously. The \(\lambda_{(\cdot)}\)s are set to \(\{20, 40, 1\}\), empirically. Note that examples generated with both paired shape-texture latent codes (i.e. \(z_s = z_t\)) and unpaired latent codes (i.e. \(z_s \neq z_t\)) will be used for adversarial training so that we can obtain different and reasonable textures for the same shape latent code, which enables the re-texturing application.

In the \(3rd\) stage, we only train the I2I refinement network \(g_{r}\) with all the other parts fixed. The L1 loss \(\mathcal{L}_{r}\) and the perceptual loss \(\mathcal{L}_{P}\) in Eq. 7 are applied simultaneously. The \(\lambda_{(\cdot)}\)s are set to \(\{1, 1\}\). Note that \(360^{\circ}\) images rendered from RenderPeople data are additionally used for training in this stage.

4 Experiments↩︎

In Sec. [sec:metrics], we first introduce the quantitative evaluation used in our experiments. In Sec. 4.1, we compare the proposed method with other state-of-the-art methods, showing that our method generates more diverse and higher-quality textured meshes. We conduct ablation studies of our method to verify the effectiveness of the adversarial loss, the reconstruction prior, and the refinement module in Sec. 4.2. Finally, we demonstrate three downstream applications of our method in Sec. 4.3, including re-texture the generated meshes, interpolation between two latent codes, and inversion from the real-world image.

Geometry evaluation. Similar to any 3D GAN, we adopt Fréchet point cloud distance (FPD) [60] to evaluate the diversity and quality of the generated shapes. We use Chamfer Distance based (\(d_{CD}\)) Coverage (COV) and Minimum Matching (MMD) following [8], [46] to evaluate the similarity between a set of generated meshes and the reference set of pseudo-GT meshes. See our Supp. for detailed settings.

Texture evaluation. To evaluate the quality of the generated textures, we used the common Fréchet Inception Distance (FID) metric on 2D images directly generated from the model and FID\(_{3D}\) on 2D images rendered using the textured 3D mesh model. we randomly choose 10k real images and 40k synthetic images as references to calculate the FID.

4.1 Comparisons with State-of-the-art Methods↩︎

Baselines. We compare our Get3DHuman with three state-of-the-art methods, including EG3D [7], SDF-StyleGAN [59], and GET3D [8]. EG3D is a 3D-aware image generation method focusing more on the rendered image rather than the geometry. SDF-StyleGAN, which only generates geometry, is a StyleGAN2-based network plus local and global shape discriminators that take as input SDF values and gradients. GET3D, similar to ours, also uses shape and texture branches. Its shape branch utilizes a differentiable surface extraction method (i.e. DMTet [61]) and its texture branch is based on EG3D. Different to ours, its supervisions are purely applied on 2D renderings (i.e. images, silhouettes). The original GET3D [8] paper is trained in a T-posed RenderPeople dataset. We have attempted to train GET3D with our purchased non-T-posed RenderPeople data. However, the results are poor in terms of geometry and textures, possibly due to the large pose space and limited training data. Its results could possibly be improved with more training data, but high-quality 3D data are expensive and difficult to obtain.

For a fair comparison, all these three approaches are trained with our pseudo-GT data. We utilize shape and texture fields to render images to train EG3D and GET3D and get the SDF fields to train SDF-StyleGAN.

Results. Tab. 1 shows quantitative comparisons and Fig. 2 visualizes the results. Our results beat the others by a substantial margin, especially on COV, MMD, and FID. We can easily observe the differences from the visual comparisons.

SDF-StyleGAN, which is only able to generate shapes, generates a little better-looking shapes than EG3D. But it often generates disconnected regions so that artifacts are frequently observed in the elbows and ankles.

EG3D focuses more on rendering high-quality images and cannot produce a reasonable geometry sometimes. The textured mesh does not look good because the geometries are problematic.

GET3D results and our results look better since the shapes are clear and contain more details while having less artifacts. Compared to ours, GET3D generates over-smoothed shapes with more artifacts and its textures are not are sharp as ours. This is also reflected by the FID (54.39 vs 61.69) and FID\(_{3D}\) scores (69.70 vs 88.15) in Tab 1. Since the geometry generated by EG3D is not accurate enough, the FID\(_{3D}\) is much higher (221.73) than other methods.

4.2 Ablation Studies↩︎

Ablation study on the adversarial and prior. The proposed method consists of two kinds of losses, i.e. adversarial losses and prior losses. Each type of loss is able to obtain a certain result. Ablative experiments, including “Adv. only”, “Prior only” and “Adv. & Prior” with or without refinement, are conducted to demonstrate their effectiveness in Tab. 2. Fig. 3 shows some examples synthesized using random latent code. Only using adversarial losses in training (Adv. only) easily produces results that contain high-frequency noise, i.e. unrealistic details. Only using prior losses (Prior only) usually produces overly-smoothed results, which has been observed in 2D image synthesis too. Ours (Adv. & Prior) produces the best results with plausible details on both the geometry and the texture. When refinement module is included, the final textured mesh further gets a huge improvement in Fig. 4.

Ablation on normal guidance. The explicit use of normal map in 3D reconstruction networks has been demonstrated very helpful [2]. Thus, we introduce a normal map as guidance for the intermediate feature maps to guide the later geometry generation and conduct ablative experiments using only prior losses. Results are shown in Fig. 5. With the help of this normal supervision, more plausible details, especially the separation between upper-/lower-body clothes, emerge on the generated shapes, demonstrating the effectiveness of using the normal map as guidance.

Ablation on refinement module. Because the reconstruction prior might be inaccurate and sometimes leads to the unrealistic appearance, especially in the face area. To this end, we designed a refinement module. Tab. 2 and Fig. 4 illustrate the effectiveness of the refinement module in improving the appearance.

4.3 Applications↩︎

Re-texturing the generated meshes. The shape/texture latent codes could be different in our two-branch 3D generator. In fact, we intentionally include some unpaired shape-texture latent codes (i.e. different values for the shape/texture latent codes) during training and apply adversarial loss on their generations during training. Since the texture branch does not affect the shape branch, the generated shape is completely fixed when the shape latent code is given. Thus, we can randomly sample texture latent code with the shape latent code fixed, resulting in a useful re-texturing application. Two examples are shown in Fig. 6. Our Get3DHuman successfully paint the 3D models with different and reasonable texture and takes the conditioned geometry into consideration.

Interpolation on shape and appearance. With our prior-facilitate learning, our method learns a better structured latent space \(z\). Thus, we can produce reasonable interpolations given two reference latent codes. Specifically, we linearly interpolate two random codes and generate textured 3D models accordingly. Smooth and valid transition models with plausible details are produced as shown in Fig. 7.

Inversion results. Get3DHuman is also able to perform image inversion similar to StyleGAN shown in Fig. 8. Given a human image, we first extract its shape/texture field features using the prior network, which are used as the optimization targets to search its corresponding shape/texture latent codes in the latent space. Note that we use shape/texture field features instead of the reference image when conducting this inversion. When the optimization is done, a textured human model resembling its reference image is produced. Compared to previous 3D reconstruction methods (e.g. PIFu), we can easily manipulate these results through latent space editing (e.g. re-texturing, interpolation).

5 Conclusion↩︎

In the paper, We introduced Get3DHuman, a novel 3D human generator that is able to synthesize diverse and high-quality clothed 3D humans. It utilizes the priors of the well-trained 2D human generator and 3D reconstructor. Numerous experiments have shown that our method greatly outperforms other methods and can support a wide range of applications, including shape interpolation, re-texturing, and single-view reconstruction via latent inversion.

Limitations. Our method is only able to synthesize simple standing-pose models, which is restricted by the StyleGAN-Human generator in our prior network.

References↩︎