Konstantinos Tertikas

Despoina Paschalidou

Boxiao Pan

Jeong Joon Park

Mikaela Angelina Uy

Ioannis Z Emiris
email: emiris@di.uoa.grpaschald

Yannis Avrithis

Leonidas Guibas
email: guibas@stanford.edu

PartNeRF: Generating

Keywords:

published or not. The documents may come   L'archive ouverte pluridisciplinaire

Introduction

Generating realistic and editable 3D content is a longstanding problem in computer vision and graphics that has recently gained more attention due to the increased demand for 3D objects in AR/VR, robotics and gaming applications. However, manual creation of 3D models is a laborious endeavor that requires technical skills from highly experienced artists and product designers. On the other hand, editing 3D shapes, typically involves re-purposing existing 3D models, by manually changing faces and vertices of a mesh and modifying its respective UV-map [START_REF] Schmidt | State of the art in artistic editing of appearance, lighting and material[END_REF]. To accommodate this process, several recent works introduced generative models that go beyond generation and allow editing the generated instances [START_REF] Cheng | Cross-modal 3d shape generation and manipulation[END_REF][START_REF] Deng | Deformed implicit field: Modeling 3d shapes with learned dense correspondence[END_REF][START_REF] Lazova | Control-nerf: Editable feature volumes for scene rendering and manipulation[END_REF][START_REF] Li | SP-GAN: sphere-guided 3d shape generation and manipulation[END_REF]69,85,[START_REF] Sun | Fenerf: Face editing in neural radiance fields[END_REF][START_REF] Yang | Learning object-compositional neural radiance field for editable scene rendering[END_REF][START_REF] Yang | Dsm-net: Disentangled structured mesh net for controllable generation of fine geometry[END_REF][START_REF] Yuan | Nerf-editing: Geometry editing of neural radiance fields[END_REF]. Shape editing involves making local changes on the shape and the appearance of different parts of an object. Therefore, having a basic understanding of the decomposition of the object into parts facilitates controlling what to edit.

While Generative Adversarial Networks (GANs) [START_REF] Goodfellow | Generative adversarial nets[END_REF] have emerged as a powerful tool for synthesizing photorealistic images [8, [START_REF] Choi | Stargan: Unified generative adversarial networks for multi-domain image-to-image translation[END_REF][START_REF] Choi | Stargan v2: Diverse image synthesis for multiple domains[END_REF][START_REF] Karras | Progressive growing of GANs for improved quality, stability, and variation[END_REF][START_REF] Karras | Aliasfree generative adversarial networks[END_REF][START_REF] Karras | Analyzing and improving the image quality of StyleGAN[END_REF], scaling them to 3D data is non-trivial as they ignore the physics of image formation process along a viewing direction. To address this, 3Daware GANs incorporate 3D representations such as voxel grids [START_REF] Henzler | Escaping plato's cave: 3d shape from adversarial rendering[END_REF][START_REF] Nguyen-Phuoc | Hologan: Unsupervised learning of 3d representations from natural images[END_REF][START_REF] Nguyen-Phuoc | Blockgan: Learning 3d object-aware scene representations from unlabelled images[END_REF] in generative settings or combine them with differentiable renderers [START_REF] Liao | Towards unsupervised learning of generative models for 3d controllable image synthesis[END_REF][START_REF] Zhang | Image gans meet differentiable rendering for inverse graphics and interpretable 3d neural rendering[END_REF]. While they faithfully recover the geometry and appearance, they do not allow changing specific parts of the object.

Inspired by the rapid evolution of neural implicit rendering techniques [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF], recent works [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF][START_REF] Gu | Stylenerf: A style-based 3d aware generator for highresolution image synthesis[END_REF]85,[START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF][START_REF] Xue | GIRAFFE HD: A high-resolution 3d-aware generative model[END_REF] proposed to combine them with GANs in order to allow for multi-view-consistent generations of high quality. Despite their impressive performance on novel view synthesis, their editing capabilities are limited. To this end, editing operations in the latent space have been explored [START_REF] Elsner | Intuitive shape editing in latent space[END_REF][START_REF] Jang | Codenerf: Disentangled neural radiance fields for object categories[END_REF]69,[START_REF] Yang | Neumesh: Learning disentangled neural mesh-based implicit field for geometry and texture editing[END_REF][START_REF] Yuan | Nerf-editing: Geometry editing of neural radiance fields[END_REF] but these approaches lack intuitive control over the shape. By decomposing shapes into parts, other works facilitate structure-aware shape manipulations [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF][START_REF] Mo | Structedit: Learning structural shape variations[END_REF][START_REF] Petrov | ANISE: assembly-based neural implicit surface reconstruction[END_REF][START_REF] Wu | PQ-NET: A generative part seq2seq network for 3d shapes[END_REF]. However, they require 3D supervision during training and can only operate on textureless shapes.

To address these limitations, we devise PartNeRF, a novel part-aware generative model, implemented as an autodecoder [6]. Our model enables part-level control, which facilitates various editing operations on the shape and appearance of the generated instance. These operations include rigid and non-rigid transformations on the object parts, part mixing from different objects, removing/adding parts and editing the appearance of specific parts of the object.

Our key idea is to represent the objects using a set of locally defined Neural Radiance Fields (NeRFs) that are arranged such that the object can be plausibly rendered from a novel view. To enable part-level control, we enforce a hard assignment between parts and rays that ensures that altering one part does not affect the shape and appearance of other parts. Our model does not require any explicit 3D supervision; we only assume supervision from images and object masks captured from known cameras. We evaluate Part-NeRF on various ShapeNet categories and demonstrate that it can generate textured shapes of higher fidelity than methods that assume 3D supervision as well as approaches that rely on NeRFs. Furthermore, we showcase various editing operations that were not previously possible.

In summary, we make the following contributions: We propose the first part-aware generative model that parametrizes parts as NeRFs. Among the existing generative pipelines that consider the decomposition of objects into parts, our work is the first that does not require explicit 3D supervision and enables editing operations both on the shape and the texture of the generated object. Code and data is available at https://ktertikas.github.io/part nerf.

Related Work

We now discuss the most relevant literature on 3D generative models in the context of generating editable shapes.

Neural Implicit Representations: Neural Implicit Representations [START_REF] Chen | Learning implicit fields for generative shape modeling[END_REF][START_REF] Mescheder | Occupancy networks: Learning 3d reconstruction in function space[END_REF][START_REF] Park | Deepsdf: Learning continuous signed distance functions for shape representa-tion[END_REF] have demonstrated impressive capabilities on various tasks ranging from 3D reconstruction with [START_REF] Oechsle | Learning implicit surface light fields[END_REF][START_REF] Oechsle | UNISURF: unifying neural implicit surfaces and radiance fields for multi-view reconstruction[END_REF][START_REF] Saito | Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization[END_REF][START_REF] Saito | Pifuhd: Multi-level pixel-aligned implicit function for high-resolution 3d human digitization[END_REF] and without texture [START_REF] Atzmon | Controlling neural level sets[END_REF]4,[START_REF] Chen | Learning implicit fields for generative shape modeling[END_REF][START_REF] Chibane | Implicit functions in feature space for 3d shape reconstruction and completion[END_REF][START_REF] Gropp | Implicit geometric regularization for learning shapes[END_REF][START_REF] Jiang | Local implicit grid representations for 3d scenes[END_REF][START_REF] Mescheder | Occupancy networks: Learning 3d reconstruction in function space[END_REF][START_REF] Michalkiewicz | Implicit surface representations as layers in neural networks[END_REF][START_REF] Park | Deepsdf: Learning continuous signed distance functions for shape representa-tion[END_REF][START_REF] Peng | Convolutional occupancy networks[END_REF][START_REF] Remelli | Meshsdf: Differentiable iso-surface extraction[END_REF][START_REF] Xu | DISN: deep implicit surface network for high-quality single-view 3d reconstruction[END_REF] to video encoding [START_REF] Hao Chen | Nerv: Neural representations for videos[END_REF], 3D-aware generative modelling [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF][START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF]22,[START_REF] Gu | Stylenerf: A style-based 3d aware generator for highresolution image synthesis[END_REF][START_REF] Meng | Gnerf: Gan-based neural radiance field without posed camera[END_REF]85,[START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF], inverse graphics [START_REF] Niemeyer | Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision[END_REF][START_REF] Yariv | Universal differentiable renderer for implicit neural representations[END_REF] and novel view synthesis [START_REF] Henzler | Unsupervised learning of 3d object categories from videos in the wild[END_REF][START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF][START_REF] Reizenstein | Common objects in 3d: Large-scale learning and evaluation of real-life 3d category reconstruction[END_REF][START_REF] Wang | Ibrnet: Learning multi-view image-based rendering[END_REF][START_REF] Yu | pixelnerf: Neural radiance fields from one or few images[END_REF]. In contrast to explicit representations i.e. point clouds, meshes and voxels, implicit representations encode the shape's geometry and appearance in the weights of a neural network. Among the most extensively used implicitbased models are NeRFs [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF], which combine an implicit neural network with volumetric rendering [START_REF] Kajiya | Ray tracing volume densities[END_REF] to perform novel view synthesis. Due to their compelling results, numerous works have been introduced to improve the training and rendering time [START_REF] Garbin | Fastnerf: Highfidelity neural rendering at 200fps[END_REF][START_REF] Lindell | Autoint: Automatic integration for fast neural volume rendering[END_REF][START_REF] Liu | Neural sparse voxel fields[END_REF][START_REF] Müller | Instant neural graphics primitives with a multiresolution hash encoding[END_REF][START_REF] Daniel Rebain | Derf: Decomposed radiance fields[END_REF][START_REF] Reiser | Kilonerf: Speeding up neural radiance fields with thousands of tiny mlps[END_REF][START_REF] Tancik | Learned initializations for optimizing coordinate-based neural representations[END_REF][START_REF] Yu | Plenoctrees for real-time rendering of neural radiance fields[END_REF][START_REF] Zhang | Nerf++: Analyzing and improving neural radiance fields[END_REF], the underlying geometry [START_REF] Oechsle | UNISURF: unifying neural implicit surfaces and radiance fields for multi-view reconstruction[END_REF][START_REF] Wang | Neus: Learning neural implicit surfaces by volume rendering for multi-view reconstruction[END_REF], to better handle lighting variations [5,[START_REF] Boss | Nerd: Neural reflectance decomposition from image collections[END_REF][START_REF] Martin-Brualla | Nerf in the wild: Neural radiance fields for unconstrained photo collections[END_REF][START_REF] Pratul | Nerv: Neural reflectance and visibility fields for relighting and view synthesis[END_REF] and to encode shape priors for better generalization [START_REF] Henzler | Unsupervised learning of 3d object categories from videos in the wild[END_REF][START_REF] Trevithick | GRF: learning a general radiance field for 3d representation and rendering[END_REF][START_REF] Yu | pixelnerf: Neural radiance fields from one or few images[END_REF] and generation [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF]. For a thorough overview on NeRF-based approaches we refer readers to [START_REF] Tewari | Advances in neural rendering[END_REF][START_REF] Xie | Neural fields in visual computing and beyond[END_REF]. In our work, we introduce a generative model for editable 3D shapes with texture. Specifically, we parametrize objects as a structured set of local NeRFs that are trained from posed images and object masks.

3D-Aware Image Generation: Incorporating 3D representations in generative settings [22, 25, 35, 38, 40-42, 71, 73, 81, 82, 84, 140] has significantly improved the quality of the generated images and increased control over various aspects of the image formation process. Likewise, radiance fields have been combined with GANs to allow for photorealistic image synthesis of objects [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] and scenes [85]. More Figure 2. Method Overview. Our generative model is implemented as an auto-decoder and it comprises three main components: The Decomposition Network takes two object specific learnable embeddings {zs, zt} that represent its shape and texture and maps them to a set of M latent codes that control the shape and texture of each part. First, we map z s and z t to M per-part embeddings {ẑ s m } M m=1 and {ẑ t m } M m=1 using M linear projections, which are then fed to two transformer encoders: τ s θ and τ t θ , that predict the final per-part shape and texture embeddings, {z s m } M m=1 and {z t m } M m=1 . Next, the Structure Network maps the per-part shape feature representation z s m to a rotation matrix Rm, a translation vector tm and a scale vector sm that define the coordinate system of the m-th part and its spatial extent. The last component of our model is the Neural Rendering module that takes the 3D points along each ray, transformed to the coordinate frame of its associated part, and maps them to an occupancy and a color value. We use plate notation to denote repetition over the M parts.

recently, [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF] introduced a triplane-based architecture that leverages both implicit and explicit representations and can generate high resolution images. Concurrently, [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] combined differentiable surface modelling [26] with a differentiable renderer to generate high-quality textured meshes. Unlike [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF][START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] that are part agnostic, our model generates objects with part-level control, hence unlocking editing operations not previously possible. Our formulation is closely related to the compositional representation of [85] but has two important differences. First, we enforce a hard assignment between rays and parts ensuring that the color of each part is only determined by one NeRF, thus enabling local editing. Moreover, we model the shape and texture of each part separately, hence enabling even more control.

Shape Editing using NeRFs: Our work falls into the category of implicit-based shape editing approaches that directly operate on the radiance field [69,[START_REF] Yang | Neumesh: Learning disentangled neural mesh-based implicit field for geometry and texture editing[END_REF][START_REF] Yuan | Nerf-editing: Geometry editing of neural radiance fields[END_REF]. Recent methods [START_REF] Yang | Neumesh: Learning disentangled neural mesh-based implicit field for geometry and texture editing[END_REF][START_REF] Yuan | Nerf-editing: Geometry editing of neural radiance fields[END_REF] extract meshes from a pre-trained NeRF and rely on deformation techniques [24,[START_REF] Joshi | Harmonic coordinates for character articulation[END_REF][START_REF] Lipman | Green coordinates[END_REF][START_REF] Sorkine | As-rigid-as-possible surface modeling[END_REF] to guide the rendering process. Unlike our approach, these models are scene specific and cannot capture shape and texture variations across an object class. An alternative line of research explored using separate embeddings for capturing the shape and texture variations of 3D shapes [START_REF] Jang | Codenerf: Disentangled neural radiance fields for object categories[END_REF]69]. They demonstrated various editing operations such as color modifications or removal of certain parts of the shape. However, as they do not consider parts, they rely on heuristics for controlling what needs to be changed. Instead, by incorporating parts, our model provides more intuitive control, when editing a 3D shape. Also similar to our work, [START_REF] Noguchi | Watch it move: Unsupervised discovery of 3d joints for re-posing of articulated objects[END_REF] uses multi-view videos and decomposes the object using a set of ellipsoids. However, this model is scene-specific and cannot generate novel shapes. In the context of face editing [START_REF] Kania | Conerf: Controllable neural radiance fields[END_REF][START_REF] Sun | Ide-3d: Interactive disentangled editing for high-resolution 3d-aware portrait synthesis[END_REF][START_REF] Sun | Fenerf: Face editing in neural radiance fields[END_REF], different models require video sequences and partial semantic masks [START_REF] Kania | Conerf: Controllable neural radiance fields[END_REF], or posed images along with full semantic masks [START_REF] Sun | Ide-3d: Interactive disentangled editing for high-resolution 3d-aware portrait synthesis[END_REF][START_REF] Sun | Fenerf: Face editing in neural radiance fields[END_REF]. In contrast, our work only requires posed images and 2D object masks at training.

Primitive-based Representations: Shape abstraction techniques represent 3D shapes using semantically consistent primitive arrangements across different instances in a class. This most often requires 3D supervision [START_REF] Deng | Cvxnets: Learnable convex decomposition[END_REF][START_REF] Deprelle | Learning elementary structures for 3d shape generation and matching[END_REF]28,[START_REF] Genova | Learning shape templates with structured implicit functions[END_REF][START_REF] Kawana | Neural star domain as primitive representation[END_REF][START_REF] Li | GRASS: generative recursive autoencoders for shape structures[END_REF]61,[START_REF] Li | Learning 3d part assembly from a single image[END_REF][START_REF] Mo | Structurenet: Hierarchical graph networks for 3d shape generation[END_REF][START_REF] Niu | Im2struct: Recovering 3d shape structure from a single RGB image[END_REF][START_REF] Paschalidou | Superquadrics revisited: Learning 3d shape parsing beyond cuboids[END_REF][START_REF] Paschalidou | Learning unsupervised hierarchical part decomposition of 3d objects from a single rgb image[END_REF][START_REF] Sharma | Parsenet: A parametric surface fitting network for 3d point clouds[END_REF][START_REF] Tulsiani | Learning shape abstractions by assembling volumetric primitives[END_REF][START_REF] Zou | 3d-prnn: Generating shape primitives with recurrent neural networks[END_REF], although [START_REF] Yao | Discovering 3d parts from image collections[END_REF][START_REF] Yao | LASSIE: learning articulated shapes from sparse image ensemble via 3d part discovery[END_REF] demonstrate that is possible to learn only from images. Unlike our parts, geometric primitives are typically simple shapes such as cuboids [START_REF] Tulsiani | Learning shape abstractions by assembling volumetric primitives[END_REF], spheres [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] or superquadrics [START_REF] Paschalidou | Superquadrics revisited: Learning 3d shape parsing beyond cuboids[END_REF][START_REF] Paschalidou | Learning unsupervised hierarchical part decomposition of 3d objects from a single rgb image[END_REF]. Due to their simple shape parametrization these primitives cannot capture complex geometries. To address this, recent works propose to increase the number of primitives [START_REF] Deng | Cvxnets: Learnable convex decomposition[END_REF][START_REF] Kawana | Neural star domain as primitive representation[END_REF] or represent shapes using a family of homeomorphic mappings [START_REF] Paschalidou | Neural parts: Learning expressive 3d shape abstractions with invertible neural networks[END_REF], or a structured set of implicit functions [START_REF] Genova | Local deep implicit functions for 3d shape[END_REF]. Similar to [START_REF] Paschalidou | Neural parts: Learning expressive 3d shape abstractions with invertible neural networks[END_REF] our parts can capture complex geometries, but as we parametrize them with locally defined NeRFs, we do not require explicit 3D supervision.

Part-based Shape Editing: Part-based generative models [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF][START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF][START_REF] Li | SP-GAN: sphere-guided 3d shape generation and manipulation[END_REF][START_REF] Petrov | ANISE: assembly-based neural implicit surface reconstruction[END_REF][START_REF] Wu | PQ-NET: A generative part seq2seq network for 3d shapes[END_REF] can generate plausible 3D shapes [START_REF] Mo | Structurenet: Hierarchical graph networks for 3d shape generation[END_REF][START_REF] Mo | Structedit: Learning structural shape variations[END_REF][START_REF] Yang | Dsm-net: Disentangled structured mesh net for controllable generation of fine geometry[END_REF] and perform various editing operations such as part mixing [START_REF] Lin | Neuform: Adaptive overfitting for neural shape editing[END_REF][START_REF] Petrov | ANISE: assembly-based neural implicit surface reconstruction[END_REF][START_REF] Yin | Coalesce: Component assembly by learning to synthesize connections[END_REF] and shape manipulation [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF][START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF]. Closely related to our work are [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF][START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] which employ primitives, such as spheres [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] and 3D Gaussians [START_REF] Hertz | Spaghetti: Editing implicit shapes through part aware generation[END_REF], to enable shape editing by explicitly [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] or implicitly [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] transforming them. However, both require 3D supervision and can only alter attributes related to the shape of the object.

Method

Our goal is to design a 3D part-aware generative model that can be trained without explicit 3D supervision. Moreover, we want our generated shapes to be editable, namely to be able to make local changes on the shape and texture of specific parts of the object. To this end, we represent objects using M locally defined parts that are parametrized with a NeRF [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF]. Defining NeRFs locally, i.e. in their own co-ordinate system, enables direct part-level control simply by applying transformations on the per-part coordinate system.

However, to achieve distinct, manipulable parts, it is essential that each object part is represented by a single NeRF. To enforce this, we introduce a hard assignment between rays and parts by associating a ray with the first part it intersects (Fig. 3). Namely, the color of each ray is predicted from a single NeRF, thus preventing combinations of parts reasoning about the color of a ray. Note that our formulation differs from [85], as we explicitly associate rays with parts, instead of simply combining them. This ensures that when editing one part, the shape and appearance of the others does not change (Fig. 1).

Neural Radiance Fields

Given a set of posed images of objects in a semantic class, each accompanied by an object mask, which is simply a binary image indicating whether each pixel is inside the object or not, we define R, the complete set of rays from all views. For each ray r = {x r 0 + td r : t ≥ 0} with origin x r 0 and viewing direction d r , we denote C(r) ∈ R 3 and I(r) ∈ {0, 1} the color value of the RGB image and the binary value of the mask, respectively, at the corresponding pixel. Finally, we sample a set of N points X r = {x r 1 , . . . , x r N } along r, which are ordered by increasing distance from the origin x r 0 , used for estimating the color along this ray using numerical quadrature [118].

Neural Radiance Fields: NeRFs [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF] represent a scene as a continuous function, parametrized with an MLP, that maps a 3D point x ∈ R 3 and a viewing direction d ∈ S 2 into a color c ∈ R 3 and a volume density σ ∈ R + . Before passing the inputs x and d to the MLP, they are projected to a higher dimensional space by applying a fixed positional encoding [START_REF] Vaswani | Attention is all you need[END_REF] to each one of their elements. Given the predicted color and densities {c r i , σ r i } N i=1 for the N sampled points X r along ray r, its rendered color can be derived from

Ĉ(r) = N i=1 exp - j<i σ r j δ r j (1 -exp(-σ r i δ r i ))c r i , (1)
where δ r i is the distance between two adjacent samples along r. At training, the MLP is optimized by minimizing the error between observed and rendered images.

Alternatively, [START_REF] Oechsle | UNISURF: unifying neural implicit surfaces and radiance fields for multi-view reconstruction[END_REF] propose predicting occupancies instead of densities, hence their rendering equation becomes

Ĉ(r) = N i=1 o r i j<i 1 -o r j c r i , (2)
where o r i = 1-exp(-σ r i δ r i ) is the occupancy value at point x r i and c r i its color. Similar to [START_REF] Oechsle | UNISURF: unifying neural implicit surfaces and radiance fields for multi-view reconstruction[END_REF] we also predict occupancy values, as this facilitates associating rays with parts, hence enabling part-level control, as discussed in Sec. 3.2.

Parts as Neural Radiance Fields

We represent a 3D object using M parts, where each part is parametrized as a NeRF. Note that we assume a fixed number of parts across all objects, namely the generated objects cannot have a variable number of parts. To learn the latent space of each NeRF, we follow [69] and condition it on two part-specific learnable latent codes: one for the shape and one for the texture, z s m , z t m . These codes are obtained from a per-object specific learnable embedding (see Sec. 3.3). Disentangling the shape from the texture allows modifying one property without affecting the other.

Moreover, as we are interested in editing specific parts of the object, we want to be able to modify the pose, size, and appearance of each part independently. This can be enforced by making sure that each NeRF receives geometric inputs in its own local coordinate system. To this end, we augment each part with: (i) an affine transformation T m (x) = R m (x + t m ) that maps a 3D point x to the local coordinate system of the m-th part, where t m ∈ R 3 is the translation vector and R m ∈ SO(3) is the rotation matrix and (ii) a scale vector s m ∈ R 3 , representing its spatial extent. All are obtained from the per-part shape code z s m . Part Representation: Each part is represented as a continuous function that maps a 3D point x ∈ R 3 , a viewing direction d ∈ S 2 , a shape code z s ∈ R Ls and a texture code z t ∈ R Lt into a color c ∈ R 3 and an occupancy value o ∈ [0, 1]. Similar to [START_REF] Oechsle | UNISURF: unifying neural implicit surfaces and radiance fields for multi-view reconstruction[END_REF], we employ two separate networks: a color network c θ and an occupancy network o θ to predict the color and the occupancy value. Note that the occupancy value o is constrained to [0, 1] with a sigmoid. More formally, each NeRF maps a 3D point x along a viewing direction d to a color c and an occupancy o as: Figure 3. Ray-Part Association. We illustrate the hard assignment between rays and parts in a 2D example with 3 parts and two rays r and r . Since the association between rays and parts is determined based on the first part that a ray interests, the associations that emerge from ( 9) are R1 = {r}, R2 = {∅} and R3 = {r }.

x to the coordinate frame of the m-th part. This ensures that any transformation of the part, also transforms its ellipsoid.

Part Rendering: The rendering equation of the m-th part, given a set of N sampled points along ray r now becomes

Ĉm (r) = N i=1 h m θ (x r i ) j<i (1 -h m θ (x r i )) c m θ (x r i , d r ). (7)
Object Rendering: To ensure distinct, manipulable parts, we introduce a hard assignment between rays and parts, by associating a ray with the first part it intersects. Given the ordered set of points X r sampled along ray r, we define the index of the first point inside the part that r intersects as

ψ r (m) = min {i ∈ {1, . . . , N } : h m θ (x r i ) ≥ τ } , ( 8
)
where τ is a threshold used to determine whether a point is inside the m-th part or not. This is illustrated in Fig. 3. We can now define the set of rays R m associated with the m-th part, as the set of rays that first intersect with it, namely:

R m = r ∈ R : m = argmin k∈{0...M } ψ r (k) . (9)
Using the assignment of rays to parts and the per-part rendering equation [START_REF] Boss | Nerd: Neural reflectance decomposition from image collections[END_REF], we can formulate the rendering equation for the entire object, using M NeRFs as follows

Ĉ(r) = M m=1 1 r∈Rm Ĉm (r). (10)
Namely, we use the m-th NeRF to render ray r if it is assigned to the m-th part. If a ray is not associated with any part its color is black. The hard ray-part assignment is an essential property that ensures that editing one part does not alter the appearance of other parts (see Fig. 5). The 1st column shows the tractor from a novel view, before editing. In the 2nd, we select the bucket and rotate it downwards, whereas in the 3rd we translate the cockpit to the floor. In the 4th, we perform isotropic scaling of the cockpit and in the last we change the color of the bucket to red.

Network Architecture

We implement PartNeRF using an auto-decoder [6,[START_REF] Park | Deepsdf: Learning continuous signed distance functions for shape representa-tion[END_REF]. The input to our model is two learnable embeddings z s , z t , per training sample, that represent its shape and texture. Our network consists of three components: (i) the decomposition network that maps z s and z t to M latent codes that control the per-part shape and texture, (ii) the structure network that predicts the pose and the scale for each part m and (iii) the neural rendering network that renders a 2D image using the M locally defined NeRFs. The overall architecture is illustrated in Fig. 2.

Decomposition Network: The decomposition network takes the two object specific embeddings z s , z t ∈ R L d and maps them to M per-part embeddings of the same dimensionality, L d , using M linear projections f θ (•). Subsequently, these embeddings are mapped to part-specific latent codes using two multi-head attention transformers, τ s θ and τ t θ without positional encoding [START_REF] Vaswani | Attention is all you need[END_REF] as follows

{z s m } M m=1 = τ s θ (f θ (z s )) (11)
{z t m } M m=1 = τ t θ (f θ (z t )). (12)
{z s m } M m=1 and {z t m } M m=1 are the latent codes that control the shape and texture of each part respectively.

Structure Network: The structure network s θ maps the shape latent code z s m ∈ R L d to a translation vector t m ∈ R 3 , a rotation matrix R m ∈ SO(3) and a scale vector

s m ∈ R 3 , with {t m , R m , s m } = s θ (z s m ) (13)
an MLP shared across parts. Similar to [START_REF] Paschalidou | Superquadrics revisited: Learning 3d shape parsing beyond cuboids[END_REF], we parametrize R m using quaternions [START_REF] Rowan | Xi. on quaternions; or on a new system of imaginaries in algebra[END_REF]. As discussed in Sec. 3.2, we determine the set of rays R m that are assigned to each part m from (9) and transform them to its coordinate system.

Neural Rendering: Given the transformed points to the per-part coordinate system, we predict colors and occupancies with (5)+(3). Next, we perform volumetric rendering using [START_REF] Boss | Nerd: Neural reflectance decomposition from image collections[END_REF] and render the object using M NeRFs with [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF].

No Editing Rotation Translation Scaling

Figure 5. Soft Ray-Part Assignment. We demonstrate that enforcing a soft ray-part assignment results in parts that do not preserve their texture across transformations.

Training

Our optimization objective L is the sum over six terms combined with two regularizers on the shape and texture embeddings z s , z t , namely

L = L rgb (R) + L mask (R) + L occ (R) + L cov (R) + L overlap (R) + L control + z s 2 + z t 2 . ( 14
)
As supervision, we use the observed RGB color C(r) ∈ R 3 and the object mask I(r) ∈ {0, 1} for each ray r ∈ R. We also associate r with a binary label r = I(r). Namely, we label a ray r as inside, if r = 1 and outside if r = 0.

Reconstruction Loss: We measure the error between the observed C(r) and the rendered Ĉ(r) color for the ray r as

L rgb (R) = r∈R Ĉ(r) -C(r) 2 2 . (15)
Mask Loss: Likewise, we measure the squared error between the observed I(r) and the rendered Î(r) pixel value of the object mask for ray r as

L mask (R) = r∈R Î(r) -I(r) 2 2 . ( 16
)
Note that Î(r) can be derived from (10)+ [START_REF] Boss | Nerd: Neural reflectance decomposition from image collections[END_REF] simply by omitting the multiplication with the predicted color, namely

Î(r) = M m=1 1 r∈Rm N i=1 h m θ (x r i ) j<i 1 -h m θ (x r j ) . ( 17
)
Occupancy Loss: This loss makes sure that the generated parts do not occupy empty space. To this end, we employ a binary cross-entropy classification loss L ce (•; •) between the predicted and the target labels for all rays

L occ (R) = 1 |R| r∈R L ce ( ˆ r , r ) + L ce ( ˜ r , r ) , (18)
where ˆ r and ˜ r are the predicted labels along ray r based on the predicted occupancies and ellipsoid occupancies respectively. Intuitively, we consider a ray r to be inside the object if it is inside at least one part. In turn, in order for r Table 1. Comparison with 3D Generative Models. We measure MMD-CD (↓) and COV-CD (↑). Note that none of these baselines considers parts nor allows any part-level shape editing.

to be inside a part it suffices if at least one point along the ray X r is inside this part. This can be expressed as

ˆ r = max m∈{1...M } max x r i ∈Xr h m θ (x r i ) (19)
˜ r = max m∈{1...M } max x r i ∈Xr g m θ (x r i ). (20)
Coverage Loss: This loss ensures that the parts cover the object, thus preventing degenerate arrangements with small parts or parts outside the object. To implement this, we encourage parts to contain at least k inside rays. This can be expressed as a binary cross-entropy loss between the predicted per-part and target labels for all rays in R k m ,

L cov (R) = 1 M M m=1 r∈R k m L ce ( ˆ m r , r ), (21)
where ˆ m r = max

x r i ∈Xr h m θ (x r i ) the predicted label for ray r wrt.

part m and R k m the set of the k inside rays with the greatest predicted occupancy values for this part. Overlapping Loss: To encourage the generated parts to capture different regions of the object, we penalize rays that are inside of more than λ parts as follows

L overlap (R) = 1 |R| r∈R max 0, M m=1 ˆ m r -λ . ( 22
)
Control Loss: To ensure uniform control across the shape, we want parts with comparable volumes. We implement this loss on the volumes V(•) of the ellipsoids, as follows:

L control = 1 M (M -1) M i=1 i j=1 |V(s i ) -V(s j )|. (23)

Experimental Evaluation

We provide an extensive evaluation of PartNeRF comparing it to relevant baselines in terms of the realism and diversity of the generated shapes. We also showcase several editing operations of our model on multiple object categories. Additional results, ablations and implementation details are provided in the supplementary.

Datasets:

We use five ShapeNet [START_REF] Angel | Shapenet: An information-rich 3d model repository[END_REF] categories: Motorbike, Chair, Table , Airplane and Car. To render our training data, we randomly sample camera poses from the upper hemisphere of each shape and render images at 256 2 resolution as in [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF]. For the Car, Table, Airplane and Chair, we use 24 random views, while for Motorbike we use 100.

To ensure fair comparison with our baselines, we use the train-test splits of [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] for the Motorbike, Car, Chair object categories and the train-test splits of [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] for the Airplane, Table category. In all our experiments, we perform category specific training. Finally, we showcase the scene-specific editing capabilities of our model on the Lego tractor [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF]. In all our experiments, we set M = 16.

Baselines: We compare our model with several NeRFbased models: GRAF [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF], Pi-GAN [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF], EG3D [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF] and the concurrent GET3D [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] that relies on differentiable rendering. Unlike our model, none of the above considers parts. We also compare with the part-based DualSDF [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] and SPAGHETTI [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] that require 3D supervision.

Metrics:

We report the Coverage (COV) and the Minimum Matching Distance (MMD) [START_REF] Achlioptas | Learning representations and generative models for 3d point clouds[END_REF] using Chamfer-L 2 distance. MMD measures how likely it is that a generated shape looks like a test shape. COV measures how many shape variations are covered by the generated shapes.

Scene-Specific Shape Editing

We train PartNeRF on the tractor scene [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF], using all 200 training views. The results are shown in Fig. 4. Initially, we select the part that corresponds to the bucket of the tractor and apply a rotation, such that the bucket is facing downwards. Similarly, we select the cockpit and move it to a new location on the floor, by adding a displacement to the part's translation vector. During both transformations the rest of the shape (geometry, parts and textures) does not alter. We then apply a non-rigid transformation on the cockpit, scaling it uniformly across all axes, by multiplying the part's rotation with an isometric scale matrix. Again, while we change the shape of one part its texture as well as the texture and shape of the others does not change. Finally, we alter the color of the bucket by explicitly setting the predicted color of its associated NeRF to red.

Soft Ray-Part Assignment:

To investigate the impact of our hard ray-part assignment, we train a variant of our model without, namely the color of a ray can be determined from multiple NeRFs. We note that when we apply a transformation on a part of the object, also the color of other parts changes, as illustrated in Fig. 5. Moreover, note that For the motorbikes, we select the saddle and for the airplanes the right wing. In the 3rd and 4th columns, we interpolate between the shape codes of the two parts, whereas in the 5th and 6th we interpolate between the texture codes of the two parts.

with this variant of our model it is not possible to change the color of specific parts of the generated object, as in Fig. 4.

Shape Generation

In Tab. 1, we compare the quality of our generations with NeRF-based generative models and observe that it outperforms existing approaches in terms of MMD and COV on Motorbikes and Chairs, while being better than [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] also for Cars. Furthermore, it performs on par with the concurrent work of [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] that relies on a highly optimized differentiable graphics renderer [START_REF] Laine | Modular primitives for high-performance differentiable rendering[END_REF] and requires training for approximately 16 GPU days (8 A100 for 2 days). Instead our model employs a simpler volumetric renderer and training takes approximately 5 GPU days (1 RTX 3090). Compared to [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF], our generations are sharper with more crisp colors (see Fig. 6). However, compared to [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF][START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] that employ tri-plane representations and hence can generate highresolution textures, our textures are less detailed.

We also compare PartNeRF with state-of-the-art partbased approaches that require 3D supervision. While our model is trained from posed images and object masks, it consistently generates plausible 3D geometries (see Fig. 7). This is also valitated quantitatively in Tab. 2, where we observe that our model outperforms both [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF][START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] on Airplanes while being better in terms of MMD for Tables.

Shape Interpolation: In Fig. 8, from left to right, we show interpolations between the shape and texture codes of two cars. We observe that our model smoothly interpolates between two shapes, while preserving the shape structure and the the part-based structure.

Part-level Interpolation: Fig. 9 shows part-level interpolation, where we pick two shapes and select a part from both. For the motorbikes, we choose the saddle part and linearly interpolate its shape and texture codes. We repeat for the airplanes, where we select the right wing. When we inter- polate the shape codes, the geometry changes, while the texture remains the same. In contrast, when we interpolate the texture codes, the geometry remains unchanged and only the part texture changes smoothly. Across all interpolations our model consistently generates realistic shapes.

Shape and Texture Editing

Shape Mixing: Starting from two shapes, the task is to select and combine parts in a meaningful way. As shown in Fig. 10, we consider two types of mixing operations: geometry and texture mixing. In geometry mixing, we combine parts from two objects and generate a new one, whose texture is determined by the texture codes from one of the two, while shape codes are taken from different parts of the two objects (third column). In texture mixing, we mix the shapes only in terms of texture, while the shape is determined by the shape codes of one object (fourth column). We also combine both mixing modes. PartNeRF consistently generates plausible shapes across all editing operations.

Shape Editing: Our method also allows several shape editing operations on the part level, such as applying rigid and non-rigid transformations and inserting or removing parts.

Affine transformations are directly applied on the rotation and translation vector that define the per-part coordinate frame. To remove a part, it suffices to ignore its associated NeRF in the rendering process. Likewise, adding a part amounts to incorporating its NeRF during rendering.

Examples of these operations are summarized in Fig. 1.

Conclusion

In this paper, we introduce PartNeRF, the first part-aware generative model that parametrizes parts as NeRFs. As our work considers the decomposition of objects into parts, it enables intuitive part-level control and several editing operations not previously possible. Furthermore, it is trained without explicit 3D supervision, using only posed images and object masks. Our experiments showcase the ability of our model to generate plausible 3D shapes with texture. Moreover, we demonstrate several editing operations both on the texture and the shape of the generated object. In future work, we plan to investigate incorporating more complex representations such as triplanes [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF], or using differentiable rendering techniques [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] in order to better represent the object's texture. Another exciting direction for future research is extending our model to moving objects. Figure 11. Decomposition Network. The decomposition network consists of two two multi-head attention transformers, τ s θ and τ t θ , without positional encoding, that map the object-specific shape and texture embeddings z s , z t to M learnable codes {z s m } M m=1 and {z t m } M m=1 that control the shape and texture of each part respectively.

Structure Network: The structure network learns a function s θ : R L d → R 4 × R 3 × R 3 that maps the per-part shape code z s m to an affine transformation, defined through a rotation matrix R m ∈ SO(3) and a translation vector t m ∈ R 3 , and a scale vector s m ∈ R 3 . We follow [START_REF] Paschalidou | Neural parts: Learning expressive 3d shape abstractions with invertible neural networks[END_REF] and parametrize the rotation matrices using quaternions [START_REF] Rowan | Xi. on quaternions; or on a new system of imaginaries in algebra[END_REF], whereas the translation and the scale vectors are represented using 3 scalars along the axes. Specifically the per-part R m , t m and s m are predicted from an MLP with shared weights across parts. A pictorial representation for the structure network is provided in Fig. 12. Starting from the shape latent code for part m, we feed it to a linear layer with 128 hidden dimensions that predicts 4 values Figure 12. Structure Network. The structure network s θ maps the shape latent code z s m ∈ R L d to a translation vector tm, a rotation matrix Rm and a scale vector sm, using an MLP with shared weights across parts. that define the rotation matrix R m as a quaternion. Similarly, we feed z s m to another another linear layer with 128 hidden dimensions that predicts the 3 values that define the translation vector t m of the m-th part. Finally, to predict the scale vector s m , we use a linear layer with 128 hidden dimensions, followed by a sigmoid activation function. As discussed in Sec. 3.2 of our main submission, we associate every ray with a specific part and transform it to its coordinate system using the predicted rotation and translation matrices. To transform a 3D point x to the local coordinate system of the m-th part, we simply apply T m (x) = R m (x + t m ), whereas to transform the ray direction d it simply suffices to multiply it with the rotation matrix R m . The scale vector s m represents the spatial extent of each part. To ensure that each part captures continuous regions of the object, we multiply its occupancy function with the occupancy function of an axis-aligned 3D ellipsoid centered at the origin of the coordinate system, with axis lengths given by the scale vector s m . Specifically the parametric function of the m-th ellipsoid is f m θ (x) = f (T m (x), s m ), where

f (x, s) = diag(s) -1 x 2 , (25)
is less than 1 when a 3D point x is inside the ellipsoid, greater than 1 when x is outside and equal to one when x is on the surface. We convert the parametric function of each ellipsoid to an occupancy function g : R 3 → [0, 1] with a sigmoid function σ(•), as follows:

g(x, s) = σ (β (1 -f (x, s))) , (26)
where β = 100 controls the sharpness of the transition of the occupancy function. As already discussed in Sec. 3.2 of our main submission, note that before estimating the occupancy function of the m-the ellipsoid g m θ (x) = g(T m (x), s m ), we first transform x to the coordinate frame of the m-th part. This ensures that any transformation of the part, also transforms its ellipsoid.

Neural Rendering: The last component of our pipeline performs volumetric rendering using M NeRFs using the assignment of rays to parts from Eq. 9 in our main submission and the per-part rendering equation

Ĉm (r) = N i=1 h m θ (x r i ) j<i (1 -h m θ (x r i )) c m θ (x r i , d r ), (27)
as follows:

Ĉ(r) = M m=1 1 r∈Rm Ĉm (r), (28)
where Ĉ(r) is the predicted color value for ray r and h m θ (x) = o m θ (x)g m θ (x) is the joint occupancy function of the m-th part. Namely, we use the m-th NeRF to render ray r if it is assigned to the m-th part. Whereas, if a ray is not associated with any part its color is simply black, namely Ĉ(r) = 0.

We follow [START_REF] Oechsle | UNISURF: unifying neural implicit surfaces and radiance fields for multi-view reconstruction[END_REF] and employ two separate networks: an occupancy network o θ (•) and a color network c θ (•) to predict the color and occupancy values. The occupancy network o θ maps a 3D point x and the shape code z s m to an occupancy value o. For the m-th part, the predicted occupancy value of a 3D point x is defined as:

o θ : R 3 × R 128 → [0, 1] o = σ(τ o m θ (T m (x), z s m )), (29)
where σ(•) is the sigmoid function and τ is a hyperparameter that controls the sharpness of the transition of the occupancy function and is set to 100. Likewise, the color network c θ maps the 3D point x and the viewing direction d after applying positional encoding on its components, as well as the shape code z s m and the texture code z t m into a color value c ∈ R 3 . For the m-th part the predicted color value for a 3D point x along a ray with direction d can be defined as:

c θ : R Lx × R L d × R 128 × R 128 → R + c = c m θ (γ(T m (x)), γ(R m d), z s m , z t m ). (30)
Here, γ(•) is the positional encoding of [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF] that is applied element-wise as follows

γ(p) = [p; sin(2 0 πp), cos(2 0 πp), . . . , sin(2 L-1 πp), cos(2 L-1 πp)], (31)
where p ∈ R can be any dimension of the input point x and the corresponding ray direction d and [•; •] denotes concatenation.

In our experiments, we set L = 10, hence

L x = L d = 3(2L + 1) = 63.
Occupancy Network: The occupancy network is implemented using 2 residual blocks as shown in Fig. 13 and is similar to [START_REF] Mescheder | Occupancy networks: Learning 3d reconstruction in function space[END_REF]. The input to our occupancy network is the per-part shape latent code z s m ∈ R 128 and a batch of 3D points sampled along rays that are transformed to the local coordinate system of the m-th part. Note that we do not apply positional encoding on the input as we empirically observed that projecting the 3D points into a higher dimensional space using [START_REF] Genova | Local deep implicit functions for 3d shape[END_REF] does not improve our model's performance. The input points are passed through a fully-connected layer that produce a 128dimensional feature vector for each point. This feature vector, together with the per-part shape code z s m , is then passed to 2 residual blocks. Each residual block first applies Conditional Scaling and Translation (CST) to the input features followed by a ReLU. The output is then fed into a fully-connected layer, a second CST, a ReLU activation and another fully-connected layer. The output of this operation is then added to the input of the residual block. The Conditional Scaling and Translation layer (CST) is the same as Conditional Batch-Normalization (CBN) [START_REF] Harm De Vries | Modulating early visual processing by language[END_REF], using in [START_REF] Mescheder | Occupancy networks: Learning 3d reconstruction in function space[END_REF], but we replace the normalization layer with the identity function. The output of the two residual blocks is fed to a fully-connected layer that produces a 257-dimensional output. This is then split into a 1-dimensional feature vector that we use to compute the occupancy value, simply by passing it to a sigmoid function, as defined in [START_REF] Garbin | Fastnerf: Highfidelity neural rendering at 200fps[END_REF], and a 256-dimensional feature vector, which we pass to the color network that produces the corresponding color. Color Network: The color network is implemented using 3 residual blocks, as shown in Fig. 14. Each residual block [START_REF] He | Deep residual learning for image recognition[END_REF] is implemented as a 3-layer MLP with ReLU non-linearities. The hidden dimensions of the 3 linear layers of each block are: 510, 256, 256 for the first, 256, 256, 256 for the second and 256, 128, 64 for the third. The inputs to the color network are: the per-part texture code z t m ∈ R 128 , the 3D point γ(T m (x)) ∈ R 63 and the ray direction γ(R m d) ∈ R 63 transformed in the coordinate system of the m-th part and projected in a higher dimensional space using [START_REF] Genova | Local deep implicit functions for 3d shape[END_REF], and the intermediate feature representation q m ∈ R 256 that is predicted from the occupancy network o θ (•). We concatenate all inputs and produce a 510-dimensional feature vector. Each residual block first applies a linear projection to the current feature vector, followed by a ReLU activation. The output is then fed into a fully-connected layer, a ReLU activation and another fully-connected layer followed by a ReLU non linearity. The output of this operation is then added to the input of the residual block after feeding it to a fully connected layer. To predict the color, we use one linear layer with hidden size 64 and output size 3, followed by a sigmoid activation.

A.2. Training Protocol

In all our experiments, we use the Adam optimizer [START_REF] Diederik | Adam: A method for stochastic optimization[END_REF] with batch size of 32 and a learning rate that begins at η = 5×10 -4 and decays to η = 5 × 10 -6 over the course of optimization. We employ a cosine annealing learning rate schedule with warm up that is set to 500 steps. For the other hyperparameters of Adam, we use the PyTorch [START_REF] Paszke | Enet: A deep neural network architecture for real-time semantic segmentation[END_REF] defaults (β 1 = 0.9, β 2 = 0.999 and = 10 7 ) and we have no weight decay. Furthermore, our input images and object masks are rendered at 256 2 resolution and we approximate each image with 512 rays. Specifically, we adopt a similar strategy as [START_REF] Yu | pixelnerf: Neural radiance fields from one or few images[END_REF] and sample an equal number of rays inside and outside the object mask, as shown in Fig. 15, during training. We observe that this sampling strategy results in faster convergence and prevents several local minima. In addition, during training, we sample 64 random points along each ray, whereas during inference, we sample 128 points. Note that unlike [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF], we do not consider a coarse and fine volume of point coordinates along rays. While, we anticipate that this would improve the quality of our renderings, we were not able to adopt this sampling strategy due to our limited computational resources, as it would significantly increase the computational requirements of our model. Finally, we train our model with 16 parts, for each object category, for approximately 125k Figure 15. Inside-Outside Rays. Inside rays correspond to pixels within the object mask (i.e. white pixel), whereas outside rays correspond pixels outside the object mask (i.e. black pixel).

iterations. All our experiments were conducted on a single NVIDIA RTX 3090, with 24GB and training per category takes approximately 1 week. We weigh the loss terms of Eq. 14 in our main submission with 1.0, 1.0, 1.0, 0.01, 0.01, 1.0, 0.0001, 0.0001. Note that we use smaller weights for L overlap (R) and L cov (R), as they act as regularizers on the recovered parts and we want our model to focus primarily on generating part arrangements that can render plausible objects from any novel camera. For L occ (R), we weight the two terms of Eq. 18 in our main submission, by 0.1, 0.01. We empirically observe that having both terms when computing the occupancy loss significantly helps performance. Finally, we weigh the control loss L control with 1 as it takes relatively smaller values and weighting it with a smaller number would make its contribution insignificant. The impact of each term is discussed in detail in Sec. B.1. In addition, the k term of L cov (R) is set to 16, since we have 256 rays and 16 parts. This encourages that each part will "cover" approximately the same number of rays, hence parts would uniformly cover the generated shape. Having uniformly distributed parts across the generated shape is essential for our application, as we want to enable uniform control over the generated shape. Finally, we set parameter λ of L overlap (R) to 3 as we empirically observe that it leads to good performance. Note that setting λ = 1 would enforce that each ray can intersect, i.e. be predicted as internal, only with one part, thus yielding completely disjoint parts. However, this is quite limiting when trying to generate complex geometries. Therefore, we instead set λ = 3 in order to enable more flexibility when capturing complex geometries.

We anticipate that setting λ = 2 would lead to similar performance, however in our experiments we use λ = 3 as it seemed to consistently yield plausible generations.

A.3. Generation Protocol

In this section, we describe the sampling process used for the generation of new shapes. In particular, we follow [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] and draw a set of shape and texture latent codes {z s , z t } from a multivariate normal distribution. Namely,

z s ∼ N (µ s train , Σ s train ) z t ∼ N (µ t train , Σ t train ). (32)
Here, the mean (µ s train , µ t train ) and covariance (Σ s train , Σ t train ) values are calculated from the shape and texture embeddings learnt during training. At inference/generation, we randomly sample z s and z t and for a given camera we cast rays and sample points along these rays. For each point we predict the corresponding color and opacity value. Note that during generation, our model does not need to condition on the object mask to be generated. To generate a novel shape from a novel camera, our model associates the casted rays with the learned parts as described in Eq. 9 of our main submission and performs rendering. Note that while for training we sample 64 points along each ray, for generation we increase this number to 128 in order to improve the generation quality.

A.4. Editing

In this section, we provide additional information regarding the editing capabilities of our model and analyze how the editing operations are performed. As we are interested in editing specific parts of the object, we want to be able to modify the pose, size and appearance of each part independently. This can be enforced by making sure that each NeRF/part receives geometric inputs in its own local coordinate system, which is enforced by augmenting each part with:

1. an affine transformation T m (x) = R m (x + t m ) that maps a 3D point x to the local coordinate system of the part, where t m ∈ R 3 is the translation vector and R m ∈ SO(3) is the rotation matrix;

2. a scale vector s m ∈ R 3 , representing spatial extent;

3. latent codes: shape z s m ∈ R 128 and texture z t m ∈ R 128 .

To select and edit a specific part of a 3D shape, it suffices to select its corresponding latent vectors z s m and z t m and manipulate them based on the type of the editing operation. Below, we provide more details regarding the editing operations presented in the main paper.

Rigid Transformations: To apply a rigid transformation on a specific part of a shape, it suffices to alter the per-part translation vector t m and rotation matrix R m . For example, to translate a part we add an appropriate displacement vector to the t m . Similarly, to rotate a part, we can multiply R m with the desired rotation matrix.

Non-Rigid Transformations: Similarly, a non-rigid transformation that changes the size of a specific part can be implemented by multiplying the part's rotation matrix with an appropriate scale matrix.

Geometry Mixing: To perform geometry mixing, we select part shape latent codes z s m from an arbitrary number of initial shapes, forming a set of part shape latent codes that describe the new mixed shape. To generate a shape with a desired texture, we allow selecting the part texture latent codes either from a single shape or from an arbitrary number of shapes. For example, to generate the results of the shape mixing experiment presented in Section 4.3 of our main submission and Fig. 10, we select texture codes only from Shape 1 for the chair and the airplane in the third column, whereas we select texture codes from both shapes to generate the mixed shapes for the chair and the airplane in the last column. As soon as the selection process is done, we feed the new part latent codes to the Neural Rendering module and render the new mixed shape. Note that the resulting number of parts in the generated shape can be arbitrary, as our model's occupancy and color networks can produce meaningful results for any given number of parts.

Texture Mixing: For texture mixing, we follow the same process as in the geometry mixing procedure, and select part shape and texture latent codes either from a single shape, or from multiple shapes and feed them to the Neural Rendering module to generate the new shape. To generate the results for the experiment presented in Section 4.3 and Fig. 10 of our main submission, we select the shape codes from Shape 1 and for the legs of the chair, we select the texture codes of the legs of Shape 2.

Part Addition: Part addition can be seen as the equivalent operation of our shape mixing strategy, where we select all the part latent codes from an entire shape, and append extra part geometry and texture codes from other shapes. Similarly to the previously discussed editing operations, the per-part shape and texture codes of the new shape after the addition are fed to the Neural Rendering module that renders the new shape.

Part Removal: To remove parts from a shape, it suffices to remove the corresponding part shape and texture embeddings, and feed only the remaining part embeddings to the Neural Rendering module.

Color Change: Our hard ray-part assignment enables changing the colors of selected parts, by directly replacing the predicted colors of the associated part rays with a color of our preference.

Part-Level Interpolation: For the part-level interpolation operation, we select corresponding parts from two different shape instances, and linearly interpolate the part shape and texture embeddings, producing new part shape and texture latent codes. The interpolated vectors are then passed to the Neural Rendering module to generate a new shape.

A.5. Metrics

As mentioned in the main submission, we evaluate our model and our baselines using two metrics that measure the plausibility and the diversity of set of generated shapes G in comparison to a set of reference shapes R. In particular, we report the Coverage score (COV) and the Minimum Matching Distance (MMD) [START_REF] Achlioptas | Learning representations and generative models for 3d point clouds[END_REF] using Chamfer Distance (CD). MMD measures the quality of the generated shapes by computing how likely it is that a generated shape looks like a shape from the reference set of shapes. On the other hand, COV measures how many shape variations are covered by the generated shapes, by computing the percentage of reference shapes that are closest to at least one generated shape.

To ensure fair comparison with our baselines, when we compare with NeRF-based generative models (i.e. Table 1 in our main submission), we follow [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF], using the test set as the set of reference shapes and synthesizing five times as many generated shapes. In contrary, when comparing to part-based generative models (i.e. Table 2 in our main submission), we follow [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] and randomly generate 1000 shapes which are compared to 500 shapes from the training set and 500 shapes from the test set.

To estimate the similarity between two shapes from the two sets, we use the Chamfer Distance (CD), which is simply the distance between a set of points sampled on the surface of the reference and the generated mesh. Namely, given a set of N sampled points on the surface of the reference X = {x i } N i=1 and the generated shape

Y = {y i } N i=1 the Chamfer Distance (CD) becomes CD(X , Y) = 1 N x∈X min y∈Y x -y 2 2 + 1 M y∈Y min x∈X y -x 2 2 . ( 33
)
For both our NeRF-based and part-based baselines, we set N = 2048. The Minimum Matching Distance (MMD) is the average distance between each shape from the generated set G to its closest shape in the reference set R and can be defined as:

MMD(G, R) = 1 |R| X ∈R min Y∈G CD(X , Y). ( 34
)
Intuitively, MMD measures how likely it is that a generated shape is similar to a reference shape in terms of Chamfer Distance and is a metric of the plausibility of the generated shapes. Namely, a high MMD score indicates that the shapes in the generated set G faithfully represent the shapes in the reference set R.

The Coverage score (COV) measures the percentage of shapes in the reference set that are closest to each shape from the generated set. In particular, for each shape in the generated set G, we assign its closest shape from the reference set R. In our measurement, we only consider shapes from R that are closest to at least one shape in G. Formally, COV is defined as

COV(G, R) = |{argmin X ∈R CD(X , Y) | Y ∈ G}| |G| (35)
Intuitively, COV measures the diversity of the generated shapes in comparison to the reference set. In other words, a high Coverage indicates that most of the shapes in the reference set R are roughly represented by the set of generated shapes G.

To ensure a fair comparison, with our baselines, we use the evaluation code of [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF].

Method

Rendering Representation Textures Supervision Parts GET3D [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] Differentiable Mesh 2D

GRAF [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] Volumetric Neural Field 2D Pi-GAN [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF] Volumetric Neural Field 2D EG3D [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF] Volumetric Neural Field 2D

DualSDF [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] -Implicit SDF 3D SPAGHETTI [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] -Implicit Occupancy 3D

Ours Volumetric Neural Field 2D We compare our model with NeRF-based generative models [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF][START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF], part-based generative models [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF][START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] and the concurrent [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] that unlike our model relies on differentiable rendering.

A.6. Baselines

In this section, we provide additional details regarding our baselines. To the best of our knowledge, our work is the first part-aware generative model that does not require explicit 3D supervision, thus there are no other works that are directly comparable to our model. Therefore, in our evaluation, we consider three types of baselines: NeRF-based generative models [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF][START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] that are part agnostic, part-based generative models [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF][START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] that require explicit 3D supervision in the form of watertight meshes and can only generate shapes without textures and finally the concurrent GET3D [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] that relies on differentiable rendering and again does not consider any parts. A concise comparison between our model and these baselines is provided in Tab. 3. Furthermore, we also compare our model with our baselines wrt. the editing capabilities of each model in Tab. 4.

GET3D:

In concurrent work, GET3D [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] 2 , proposed a novel generative model for textured meshes that relies on a highly optimized differentiable graphics renderer [START_REF] Laine | Modular primitives for high-performance differentiable rendering[END_REF]. In particular, their model comprises a geometry generator that employs DMTet [26] to recover surfaces of arbitrary topologies and a texture generator that generates textures as a texture field [START_REF] Oechsle | UNISURF: unifying neural implicit surfaces and radiance fields for multi-view reconstruction[END_REF].

During training, they rely on two discriminator losses on the rendered image and the 2D silhouette. As the underlying representation of GET3D is a textured mesh, their generated textures and geometries are more detailed compared to ours. However, as they do not consider parts, they cannot perform several editing operations that our model is capable of. As already mentioned in our main submission, training GET3D requires approximately 16 GPU days (8 NVIDIA A100 for 2 days), whereas training our model takes approximately one third of the time (5 GPU days). Due to their rigorous evaluation and to ensure a fair comparison, we report their results in Table 1 and Figure 6 in our main submission. GRAF: GRAF [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] 3 was among the first 3D-aware generative models that combined a 2D GAN [START_REF] Goodfellow | Generative adversarial nets[END_REF] with volumetric rendering as in NeRF [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF]. In particular, they introduce a conditional NeRF parametrized as an MLP that maps the positional encoding of a 3D point and a viewing direction to a color and a volume density value, conditioned on a shape and an appearance latent codes. Unlike [START_REF] Mildenhall | NeRF: Representing scenes as neural radiance fields for view synthesis[END_REF], GRAF is trained from a collection of unposed images and employs a PatchGAN [START_REF] Isola | Image-to-image translation with conditional adversarial networks[END_REF] discriminator to improve the quality of the rendered images from a novel view. While GRAF's code is publicly available, to generate the qualitative results for Fig 6 and the quantitative comparison in Table 1 from our main submission, we do not train their model. Instead, we directly report the results from [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF]. Unlike our model, GRAF employs a discriminator to improve the quality of the rendered images from novel view points. Furthermore, as [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] does not consider parts, it only enables few editing operations on the entire image, i.e. changing the color of the depicted object.

Pi-GAN: Similar to GRAF [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF], Pi-GAN [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF] 4 addresses the 3D-aware image synthesis task and leverages a neural representation with periodic activation functions [START_REF] Vincent Sitzmann | Implicit neural representations with periodic activation functions[END_REF]. Unlike [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] that conditions on a shape and appearance latent code, Pi-GAN conditions the MLP on a single input noise vector, as in StyleGAN [START_REF] Karras | Analyzing and improving the image quality of StyleGAN[END_REF]. Also, Pi-GAN uses a discriminator to further improve the quality of the volumetric rendering. As they do not consider parts, [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF] have limited editing capabilities. Again, to ensure a fair comparison, we do not train their model from scratch but instead report the results from [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF].

Method

Image Inversion Shape Inversion Generation Shape Mixing Shape Editing Texture Editing GET3D [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] GRAF [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] Pi-GAN [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF] EG3D [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF] DualSDF [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] SPAGHETTI [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] Ours Table 4. Comparison to Prior Work wrt. Editing Operations. We compare the editing capabilities of our model and our baselines. Note that Shape Editing and Texture Editing refer to local changes on the texture and the shape of the generated object.

EG3D: More recently, EG3D [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF] 5 proposed a StyleGAN-based generator [START_REF] Karras | Analyzing and improving the image quality of StyleGAN[END_REF] that relies on a tri-plane representation instead of positional encoding. Their model is capable of generating images at high resolutions using a CNN-based upsampling module. Despite its impressive results, EG3D does not consider parts, hence it cannot perform local edits on the generated shapes. Similar to [START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF][START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF], for the qualitative and quantitative evaluation in Sec. 4.2 of our main submission, we report the results from [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF]. In addition, note that as EG3D [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF] requires training of approximately 8 days on 8 NVIDIA Tesla V100 GPUs, we are not able to run their code due to our limited GPU resources.

DualSDF: DualSDF [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] 6 was among the first to introduce a model capable of editing neural implicit shapes. In particular, they proposed a representation with two levels of granularity, where a user can manipulate a 3D shape through the coarse primitive-based representation and these edits are reflected to a high-resolution implicit shape, via a shared latent code. Unlike our model, DualSDF assumes explicit 3D supervision in the form of a watertight mesh and cannot generate shapes with texture. To ensure a fair comparison, we report the results from [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] in Table 2 of our main submission. Although our model considers 2D supervision in the form of posed images and object masks, our model outperforms DualSDF in terms of MMD and COV both for airplanes and tables (see Table 2 in our main submission). 7 is the state-of-the-art part-based generative model that similar to [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] permits manipulating neural implicit shapes. Similar to our model, they implement their generative model as an auto-decoder [6, 91] that takes an instant-specific latent code as input and decomposes it to M per-part latent codes, representing different parts of the object. Unlike our model, SPAGHETTI [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF], employs a transformer decoder that merges the parts and produces the final implicit shape as an occupancy field. Unlike our model, [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] assumes explicit 3D supervision in the form of a watertight mesh and cannot generate meshes with texture. As already mentioned previously, to ensure a fair comparison, the numbers in Table 2 of our main submission are from [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF]. For the qualitative comparison in Fig. 7 of our main submission, we use the pre-trained models provided to us by the authors.

SPAGHETTI: SPAGHETTI [44]

A.7. Mesh Extraction

To extract meshes from the predicted occupancy field, we employ the Multiresolution IsoSurface Extraction (MISE) technique introduced in [START_REF] Mescheder | Occupancy networks: Learning 3d reconstruction in function space[END_REF]. In particular, we start from a voxel grid of 32 3 initial resolution for which we predict occupancy values. Next, we follow the process proposed in [START_REF] Mescheder | Occupancy networks: Learning 3d reconstruction in function space[END_REF] and extract the approximate isosurface with Marching Cubes [START_REF] Lorensen | Marching cubes: A high resolution 3d surface construction algorithm[END_REF], which is then refined using 3 optimization steps. For the mesh extraction, we use the code provided by Mescheder et al. [START_REF] Mescheder | Occupancy networks: Learning 3d reconstruction in function space[END_REF]. Note that for the individual parts, we only extract approximate surfaces with Marching Cubes [START_REF] Lorensen | Marching cubes: A high resolution 3d surface construction algorithm[END_REF].

B. Ablation Study

In this section, we ablate various components of our model and demonstrate their impact on its generation capabilities. We conduct all our ablations on a subset of ShapeNet [START_REF] Angel | Shapenet: An information-rich 3d model repository[END_REF] Airplanes, which comprises approximately 10% of the original train set. Namely, we use 178 training samples and 100 views for training all our model variants. In Sec. B.1, we discuss the effect of our loss terms on the overall performance of our model and in Sec. B.2, we demonstrate the impact of the number of parts on the generation capabilities of our model. Finally, we provide additional information regarding the impact of our hard ray-part assignment, presented in our main submission (see Sec. B.3)

B.1. Loss Functions

Our optimization objective L is the sum of six terms combined with two regularizers on the shape and texture embeddings z s , z t , namely

L = L rgb (R) + L mask (R) + L occ (R) + L cov (R) + L overlap (R) + L control + z s 2 + z t 2 . (36)
As supervision, we use the observed RGB color C(r) ∈ R 3 and the object mask I(r) ∈ {0, 1} for each ray r ∈ R. In addition, we associate r with a binary label r = I(r), as shown in Fig. 15. Namely, we label a ray r as inside, if r = 1 and outside if r = 0. In this section, we discuss how the loss terms affect the performance of our model wrt. the plausibility of the generated shapes. In particular, we train 4 variants of our model and for each one we omit one of the loss terms. We provide both quantitative (see Tab. 5) and qualitative comparison (see Fig. 16) for these scenarios. For a fair comparison, all models are trained for the same number of epochs, which is set to 50. Furthermore, in this experiment, we set the number of parts to 10. To compute the metrics in Tab. w/o Mask Loss: The mask loss is the squared error between the observed and the rendered pixel value of the object mask for a set of rays. We observe that removing the mask loss L mask (R) results in more noisy/blurry renderings, in particular around the surface boundaries (see first column in Fig. 16). We experimentally observed that L mask (R) helps the network find the object boundaries faster, which naturally improves the overall rendering quality. On the part-level, we also observe that the generated parts are less smooth (e.g. see the tail parts of the two last airplanes in the first column of Fig. 16).

w/o Occupancy Loss: The occupancy loss makes sure that the generated shape does not occupy empty space. This is enforced by making sure that the generated parts only contain/cover inside rays, namely rays with r = 1. Therefore, removing L occ (R) from our optimization objective results in renderings of worse quality, particularly around the object boundaries (see second column in Fig. 16). Note that in our evaluation, even if we remove this loss, we still use L mask (R), which forces, to some extent, the network to capture the surface boundary.

w/o Coverage Loss: The coverage loss prevents degenerate parts, that are either too thin or too large. Therefore, when we remove L cov (R) from our optimization, we note that the generated parts become either very small (first and second example in third column of Fig. 16) or too large (last example in the same column).

w/o Overlapping Loss: The overlapping loss encourages the generated parts to not capture the same regions of the object. We identify overlapping parts by a ray being internal to more than λ parts and we set λ = 3. Note that this done using the predicted label for ray r wrt. to part m, ˆ m r = max

x r i ∈Xr h m θ (x r i ). Removing L overlap (R) results in generated parts that capture the same regions of the object, as shown in the fourth column of Fig. 16.

B.2. Number of Parts

In this section, we analyze the impact of the number of parts on the quality of the generated shapes. Specifically, we train our model with: 5, 10, 16 and 20 parts. Unlike the results presented in our main submission, for this experiment, we From the quantitative comparison in Tab. 6, we observe that the quality of the generated meshes increases for a larger number of parts, namely using more parts yields higher MMD-CD scores. From the qualitative comparison of Fig. 17, we note that using fewer parts results in parts that capture multiple regions of the object, e.g. the red part represents the left wing and the tail. Since our main goal is to enable editability and part-level control, we want to ensure that there is an adequate number of parts so that the user can choose what they want to edit/change. For the case of 10 parts, we note that now parts are capable of recovering more distinct regions of the object.

B.3. Hard Ray-Part Assignment

In Sec. 4.1 of our main submission, we demonstrate that enabling a soft assignment between parts and rays, namely the color of one ray being determined from multiple parts, prevents several editing operations (see Fig. 5 in our main submission). This is to be expected as for the case of the soft ray-part assignment, the colors and opacities of all rays are determined jointly by all NeRFs. As a result, changing one NeRF naturally affects the others, hence the colors and opacities of parts of the object that we did not intend to change.

C. Additional Experimental Results

In this section, we provide additional information regarding our experiments on ShapeNet [START_REF] Angel | Shapenet: An information-rich 3d model repository[END_REF]. In particular, we consider five categories: Motorbike, Chair, Table, Airplane, Car, which contain 337, 6678, 8509, 4045 and 7497 shapes respectively. For the Car, Table , Airplane and Chair, we use 24 random views, while for Motorbike we use 100, as it contains fewer training samples. To ensure fair comparison with our baselines, we use the train-test splits of [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF] for the Motorbike, Car, Chair object categories and the train-test splits of [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] for the Airplane, Table category. To render our training data, we randomly sample camera poses from the upper hemisphere of each shape and render images at 256 2 resolution as in [START_REF] Gao | GET3D: A generative model of high quality 3d textured shapes learned from images[END_REF]. To render both the RGB images and the corresponding object masks we use simple-3dviz [START_REF] Angelos | simple-3dviz[END_REF] 8 . Examples of the rendered RGB images and object masks per category are provided in Fig. 18.

C.1. Shape Generation

In this section, we provide additional qualitative results for our shape generation experiment on the five ShapeNet [START_REF] Angel | Shapenet: An information-rich 3d model repository[END_REF] categories: Motorbike, Chair, Table, Airplane, Car. In particular, we visualize several random samples per category, rendered from a novel view point, not seen during training. In addition, we also show the corresponding 3D meshes and parts. Specifically, in Fig. 19, we illustrate randomly generated motorbikes. We notice that all motorbikes are consistently plausible and the underlying parts meaningfully capture several motorbike's geometry. Likewise, for the case of generated cars (see Fig. 20) and airplanes (see Fig. 21), we observe that our model is capable of generating diverse geometries and textures that are consistently plausible. For the case of chairs and tables (see Fig. 22), we notice that the geometries are consistently plausible, as also evidenced from Table 1 in our main submission, however the generated textures are less crisp in comparison to the other categories. We hypothesize that this discrepancy stems from the fact that tables and chairs have thinner parts than the other objects. We believe that incorporating a coarse and a fine volume of 3D coordinates would potentially improve this. We compare our model with [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] and show six randomly generated samples per category. The first row per category corresponds to samples from [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF], the second row to our results, and the third row to our part geometry results.

D. Shape Inversion

Our generative model is realized by an auto-decoder architecture. In order to be able to edit a shape that does not belong to the training set, we seek to match the given shape to a shape embedding z s that can closely reconstruct its geometry. Following [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF], we randomly initialize the shape embedding z s , sampling from a multivariate normal distribution using the mean µ s train and covariance Σ s train of shape embeddings seen during training:

z s ∼ N (µ s train , Σ s train ). (37)
Then, we sample points along rays R from N = 5 different views of the object, and freeze our entire network, optimizing the latent code z s using the following loss function:

L inversion = L mask (R) + L occ (R) + z s 2 , (38)
using weights 1.0, 1.0 and 0.0001. We optimize the latent code z s for a fixed number of 700 gradient update steps. Note that this experiment does not require any color information, as we are solely interested in extracting an accurate representation of the geometry of the target shape. We therefore utilize only object masks during optimization. We compare our method with DualSDF [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] and SPAGHETTI [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] on the test set of the ShapeNet Airplanes category. Our results are summarized in Tab. 7. To measure the Chamfer-L 1 distance, we follow [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] and sample 30, 000 points on the surface of the generated and the target mesh.

DualSDF SPAGHETTI Ours

Chamfer-L 1 0.806 0.050 0.4536 Our model yields better reconstructions than DualSDF [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] in terms of Chamfer distance, even though [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] was trained with explicit 3D supervision. Compared to SPAGHETTI [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF], our model yields worse reconstructions. We hypothesize that conditioning our generations to more than 5 views would further improve the performance of our model. In Fig. 27, we show examples of our shape inversion experiment.

E. Image Inversion

The goal of this experiment is to recover both the appearance and geometry of a 3D shape, as opposed to only the shape as for the case of shape inversion (Sec. D). To this end, we need to find an appropriate match for both the shape and texture embeddings {z s , z t }, given a set of posed images and masks as targets. In a similar manner to the sampling process of Sec. A.3, we randomly initialize the shape and texture embeddings, as discussed in Sec. A.3. Then, we freeze the network parameters and optimize the embeddings using the loss function:

L image inversion = L rgb (R) + L mask (R) + L occ (R) + z s 2 + z t 2 , (39)
with weights of 1.0, 1.0, 1.0, 0.0001 and 0.0001. We use N = 5 posed images and masks as targets, and optimize the latent codes for a fixed number of 2000 gradient update steps. We showcase several inverted examples in Fig. 28.

Input Images Ours Ours -Geometry We observe that our model can faithfully recover the object geometry and appearance for various objects. Note that Image Inversion enables users to directly edit shapes, by just providing a few posed images and masks. In Sec. F we showcase several editing functionalities on the inverted shapes.

F. Shape Editing

In this section, we demonstrate the editing capabilities of our model on inverted shapes from ShapeNet Airplane. To perform the image inversion, we follow the process described in Sec. E. In Fig. 29, we show several examples of geometry, texture mixing and shape editing. In particular, we show two shape editing examples, (see last four rows in Fig. 29), where we select several parts from two airplanes and we translate them along the body of the two airplanes. The parts that we select correspond to the tail of the first airplane and the wings of the second, highlighted in green. Across both transformations, only the pose of the selected parts change, while their appearance/texture as well as the shape and appearance of the other parts does not change. For the case of texture mixing (see third and fourth rows in Fig. 29), we start from three airplanes and perform several texture mixing operations. For example, in the last column of the third row of Fig. 29, we show a generated airplane, whose texture and shape for the tail is from the first shape, while the texture and shape for the wings and the body are from the second and third shape respectively. Likewise, for the geometry mixing experiment (see two first rows in Fig. 29), we show examples where we mix the shapes of the three input airplanes, while keeping the texture of the first (fourth column), the second (fifth column) or the third input airplane (sixth column).

G. Discussion and Limitations

In the primitive-based literature, the word part refers to geometric primitives that are typically simple shapes such as cylinders [61], cuboids [START_REF] Tulsiani | Learning shape abstractions by assembling volumetric primitives[END_REF], superquadrics [START_REF] Paschalidou | Superquadrics revisited: Learning 3d shape parsing beyond cuboids[END_REF][START_REF] Paschalidou | Learning unsupervised hierarchical part decomposition of 3d objects from a single rgb image[END_REF], spheres [START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF] or more generally convex shapes [START_REF] Deng | Cvxnets: Learnable convex decomposition[END_REF]. More recently, the term part has also been used to describe parts that can capture complex geometries and are not limited to simple geometric shapes [START_REF] Genova | Local deep implicit functions for 3d shape[END_REF]56,[START_REF] Paschalidou | Neural parts: Learning expressive 3d shape abstractions with invertible neural networks[END_REF]. Regardless of the part's expressivity, primitive-based methods yield semantically consistent reconstructions, where the same part is consistently used for representing the same part of the object. Being semantically consistent does not necessarily mean that parts will also be semantically meaningful, namely refer to humanly identifiable parts.

As we parametrize parts by neural radiance fields, our parts can capture complex topologies that are not limited to simple geometric shapes. Examples of our generated parts can be found in Fig. 19-Fig. 26. We note that our parts can be coherent across some objects, e.g. the same part is used for representing the same region of the object, in particular when the parts have comparable size and shape. However, for two shapes with different sizes e.g a big and small car (see Fig. 20), we note that our parts are not semantically consistent, namely the part that is used to represent the tire and the top part of the car for a smaller car is now representing only the tire of a bigger car. Note that this is not a limitation only of our work but also of existing part-based methods, as they do not explicitly enforce the semantic consistency of parts.

In addition, in Fig. 30, we provide two examples of the renderings produced using our 16 NeRFs/parts, when rendering the tractor scene from a novel view and when rendering a ShapeNet car from a novel camera. Although the per-part renderings are consistently crisp and faithfully capture the appearance details of the object, they do not always correspond to semantically meaningful parts. For example, for the case of the tractor scene, our network has associated one part with the bucket of the tractor, however it uses multiple parts to capture regions of the floor, whereas ideally we would like one part to capture the entire floor. Similarly, for the case of the car, while the per-part renderings have sharp colors, they cover parts of the object that are not humanly interpretable, such as a single NeRF representing part of the tire and part of the car. This is again a common issue observed in all existing part-based methods [START_REF] Deng | Cvxnets: Learnable convex decomposition[END_REF][START_REF] Paschalidou | Neural parts: Learning expressive 3d shape abstractions with invertible neural networks[END_REF][START_REF] Paschalidou | Superquadrics revisited: Learning 3d shape parsing beyond cuboids[END_REF][START_REF] Tulsiani | Learning shape abstractions by assembling volumetric primitives[END_REF]. As these methods do not explicitly enforce the meaningfulness of their parts, oftentimes parts are associated with regions of objects that are not meaningful and do not correspond to humanly interpretable parts. We believe that in future research, it would be valuable to explore ways to enforce that parts are more interpretable, in order to unlock more editing operations, that better keep humans in the loop. Our main goal for this work, was to introduce a generative model that enables local control through parts. While increasing the number of parts enables more control on the generated shape, as we can select multiple small parts that compose a semantic part such as the wings of the airplane, we believe that it is useful to also explore other types of more semantic control, where a user for example could select a part based on its semantic class e.g. wing of an airplane or saddle of a motorbike, without having to manually select multiple parts, as is the case for our model.

In contrast to existing NerF-based generative models [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF][START_REF] Chan | Pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis[END_REF]26,[START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] that rely on adversarial losses to generate high quality renderings, our model does not employ such losses. We believe that incorporating triplane-based representations [START_REF] Chan | Efficient geometryaware 3d generative adversarial networks[END_REF] or adversarial losses could further improve the quality of our generated textures. Moreover, in our current framework, moving one part of an object to a new location outside the object does not necessarily generate a contiguous shape. To address this, [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF], introduced a blending network, implemented as a transformer decoder that merges the subsequent parts and synthesizes a novel object. Incorporating such a technique in our model is not possible, as we do not have access to 3D supervision in the form of a mesh. However, we could utilize [START_REF] Lin | Neuform: Adaptive overfitting for neural shape editing[END_REF][START_REF] Yin | Coalesce: Component assembly by learning to synthesize connections[END_REF] to synthesize connections between parts.

To summarize, while our work makes an important step towards generating editable 3D shapes, it still has several limitations. In particular, during training, our supervision comes from posed images and object masks. Nevertheless, acquiring detailed masks for objects in the wild is not always possible. Therefore, we believe it would be useful to explore ways to alleviate the need for object masks. Likewise, adopting a formulation like [START_REF] Schwarz | Graf: Generative radiance fields for 3d-aware image synthesis[END_REF] that enables training from unposed images could further extend the capabilities of our model. In addition, while our model can perform several editing operations, our current formulation does not support operations where a part is deformed using techniques such as Neural Cages [START_REF] Yifan | Neural cages for detail-preserving 3d deformations[END_REF] or Biharmonic Coordinates [START_REF] Wang | Linear subspace design for real-time shape deformation[END_REF]. Incorporating deformations in our editing operations could unlock several editing applications.

H. Potential Negative Impact on Society

Our proposed model enables generating editable 3D meshes with textures. While, we see this as an important step towards automatic content creation and enabling a multitude of editing functionalities, it can also lead to negative consequences, when applied to sensitive data, such as human bodies or faces. Therefore, we believe it is imperative to always check the license of any 3D publicly available 3D model. In addition, we see the development of techniques for identifying real from synthetic data as an essential research direction that could potential prevent deep fake.

Note that throughout this work, we have only worked with publicly available datasets and did not use any data that involves privacy or copyright concerns. For future users that would like to train our model on new data, we recommend to first remove biases from the training data in order to ensure that our model can fairly capture the diversities in terms of shapes, sizes and textures.

Figure 4 .

 4 Figure 4. Scene-Specific Editing. The top and bottom row show the rendered images and the part-based geometries respectively.The 1st column shows the tractor from a novel view, before editing. In the 2nd, we select the bucket and rotate it downwards, whereas in the 3rd we translate the cockpit to the floor. In the 4th, we perform isotropic scaling of the cockpit and in the last we change the color of the bucket to red.

Figure 7 .

 7 Figure 7. Shape Generation. We compare our model with[START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF] and show three randomly generated samples per category.MethodSupervision MMD-CD (↓) COV-CD (%, ↑)Airplane TableAirplane Table

Figure 8 .

 8 Figure 8. Shape Interpolation. From left to right, we interpolate between the geometry and texture latent codes of the two shapes.

Figure 9 .

 9 Figure 9. Part-Level Interpolation. From left to right, we interpolate between two parts (colored in green) from two shapes.For the motorbikes, we select the saddle and for the airplanes the right wing. In the 3rd and 4th columns, we interpolate between the shape codes of the two parts, whereas in the 5th and 6th we interpolate between the texture codes of the two parts.

Figure 10 .

 10 Figure 10. Shape Mixing. We mix parts from two shapes and show geometry (3rd column), texture (4th column), and combined geometry and texture mixing (5th column). The selected parts for mixing are colored in green.

  z s and z t respectively using M linear projections f θ (•). The output of each transformer is the set of per-part shape {z s m } M i=1 and texture {z t m } M i=1 , where z s m ∈ R 128 and z t m ∈ R 128 . Both transformers consist of 2 layers with 4 attention heads. The queries, keys and values have 128 dimensions and the intermediate representations for the MLPs have 1024 dimensions. To implement the transformer architecture we use the transformer library provided by Wightman [122] 1 . (a) τ s θ (•) predicts the M per-part shape codes {z s m } M i=1 . (b) τ t θ (•) predicts the M per-part shape codes {z t m } M i=1 .

Figure 13 .

 13 Figure 13. Occupancy Network. The occupancy network o θ (•) maps a 3D point x transformed in the local coordinate system of the m-th part and its shape code z s m to an occupancy value o ∈ [0, 1] and an intermediate feature vector qm ∈ R 256 which is passed to the color network c θ (•).

Figure 14 .

 14 Figure 14. Color Network. The color network c θ (•) maps a 3D point x and a viewing direction d after applying element-wise positional encoding on their components, the texture code z t m and the feature vector qm into a color value c ∈ R 3 . Note that qm is predicted from the occupancy network o θ (•) from z s m .

( 1 )

 1 w/o L mask (2) w/o Locc (3) w/o Lcov (4) w/o L overlap (5) Ours (6) w/o L mask (7) w/o Locc (8) w/o Lcov (9) w/o L overlap (10) Ours (11) w/o L mask (12) w/o Locc (13) w/o Lcov (14) w/o L overlap (15) Ours

Figure 16 .

 16 Figure 16. Ablation Study on Loss Terms. Qualitative evaluation of the impact of the 4 loss terms on the performance of our model. We train our model, without each loss term and generate novel shapes.

Figure 17 .

 17 Figure 17. Ablation Study on the Number of Parts. Qualitative evaluation of the impact of the number of parts. The first row shows randomly generated airplanes with 5 parts, the second row with 10, the third with 16, and the last row with 20 parts. Note that we train a different model for the four different numbers of parts.

Figure 18 .

 18 Figure 18. Rendered RGB Images and Object Masks. We provide examples of the rendered RGB images and object masks that we use for training.

Figure 19 . 29 Figure 20 .

 192920 Figure 19. Generated Motorbikes. Generated motorbikes accompanied by their corresponding 3D geometries and part-based geometries.

Figure 21 .

 21 Figure 21. Generated Airplanes. Generated airplanes accompanied by their corresponding 3D geometries and part-based geometries.

Figure 22 .Figure 23 .

 2223 Figure 22. Generated Chairs & Tables. Generated chairs and tables accompanied by their corresponding 3D geometries and part-based geometries.

Figure 24 .

 24 Figure 24. Airplanes Shape Interpolation. From left to right, we interpolate between the geometry and texture latent codes of the two airplanes.

Figure 25 .

 25 Figure 25. Motorbikes Shape Interpolation. From left to right, we interpolate between the geometry and texture latent codes of the two motorbikes.

Figure 26 .

 26 Figure 26. Cars Shape Interpolation. From left to right, we interpolate between the geometry and texture latent codes of the two cars.

Figure 27 .

 27 Figure 27. Shape Inversion. We show examples of our results when performing shape inversion on the ShapeNet airplanes.

Figure 28 .

 28 Figure 28. Image Inversion. We show examples of our results when performing image inversion on the ShapeNet airplanes.

Figure 30 .

 30 Figure 30. Per-Part Renderings. We show the per-part renderings produced by our 16 NeRF/parts for a novel view.

Table DualSDF

 DualSDF

		3D Shapes	4.20	12.30	25.00	36.30
	SPAGHETTI 3D Shapes	2.40	5.90	35.00	47.80
	Ours	Multi-view	1.37	4.48	37.90	40.60

Table 2 .

 2 Comparison

with Part-based Generative Models. We measure MMD-CD (↓) and the COV-CD (↑). Unlike our model, both

[START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF][START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF]

require 3D supervision during training.

Table 3 .

 3 Comparison to Prior Work. We introduce the first part-based generative model that does not require explicit 3D supervision.

Table 5 .

 5 5, we consider a subset of the test set, which amounts to 46 shapes, namely roughly 10% of the original test set. w/o L mask w/o L occ w/o L cov w/o L overlap Ours Ablation Study on Loss Terms. We investigate the impact of each loss term by training our model without each one of them. We report the MMD-CD (↓) for all variants.

	MMD-CD (↓)	1.787	1.823	1.737	1.757	1.732

Table 6 .

 6 Ablation Study on the Number of Parts. This table shows a quantitative comparison of our approach with different numbers of parts wrt. MMD-CD (↓).

Table 7 .

 7 Shape

	Ground Truth	Input Object Masks	Ours

Inversion. Quantitative evaluation of our method against DualSDF

[START_REF] Hao | Dualsdf: Semantic shape manipulation using a two-level representation[END_REF]

and SPAGHETTI

[START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF]

wrt. to Chamfer distance (↓) on the test set of the Airplanes category.

https://github.com/rwightman/pytorch-image-models

https://nv-tlabs.github.io/GET3D/

https://github.com/autonomousvision/graf

https://marcoamonteiro.github.io/pi-GAN-website/

https://nvlabs.github.io/eg3d/

https://www.cs.cornell.edu/ hadarelor/dualsdf/

https://github.com/amirhertz/spaghetti

https://simple-3dviz.com/

Acknowledgments

This research was supported by an ARL grant W911NF-21-2-0104 and an Adobe research gift. Konstantinos Tertikas and Ioannis Emiris have received funding from the European Union's Horizon 2020 research and innovation programme under the Marie Skłodowska-Curie grant agreement No. 860843. Despoina Paschalidou is supported by the Swiss National Science Foundation under grant number P500PT 206946. Leonidas Guibas is supported by a Vannevar Bush Faculty Fellowship.

Abstract

In this supplementary document, we first present a detailed overview of our network architecture, the training and generation procedure, in Sec. A. We then provide ablations on how different components of our pipeline impact the performance of our model, in Sec. B. Subsequently, in Sec. C we provide additional results both on the shape generation task as well as on the shape editing task. Next, we demonstrate various applications of our model such as shape and image inversion, in Sec. D and Sec. E, respectively. Finally, in Sec. G, we analyse the limitations, future research directions and in Sec. H we discuss potential negative impact of our method on society.

A. Implementation Details

In this section, we provide a detailed description of the several components of our network architecture (Sec. A.1). Next, we describe our training procedure (Sec. A.2) and the generation protocol (Sec. A.3). Then, we provide details regarding the various editing operations demonstrated in the main submission (Sec. A.4). Finally, we detail our metrics computation (Sec. A.5) and discuss our baselines (Sec. A.6).

A.1. Network Architecture

Here, we describe the architecture of each individual component of our model, as illustrated in Fig. 2 in the main submission. As already discussed in Sec 3.3 of our main submission, we implement our generative model using an autodecoder [6,[START_REF] Park | Deepsdf: Learning continuous signed distance functions for shape representa-tion[END_REF]. In particular, the input to our model is a set of embedding vectors Z = {z i } n i=1 , uniquely identifying each one from the n training samples. Each z i = {z s , z t }, comprises two learnable embeddings that capture the shape and appearance properties of each sample. Note that both the shape z s and texture z t codes are initialized by sampling from the normal distribution z s , z t ∼ N (0, I). To avoid notation clutter, we omit the object index i in the rest of this section.

Our network consists of three main components: (i) the decomposition network that maps the instance-specific latent codes {z s , z t } to M per-part shape {z s m } M i=1 and texture {z t m } M i=1 embeddings, (ii) the structure network that takes the per-part shape code z s m and predicts an affine transformation {R m , t m } and scale s m that controls the pose and the area of influence of this part, and (iii) the neural rendering module that renders a 2D image using M NeRFs. As supervision, we use the observed RGB color C(r) ∈ R 3 and the object mask I(r) ∈ {0, 1} for each ray r ∈ R. We also associate r with a binary label r = I(r), as shown in Fig. 15. Namely, we label a ray r as inside, if r = 1 and outside if r = 0.

Decomposition Network: The decomposition network maps the instance-specific shape and texture {z s , z t } latent codes into a set of M latent codes that control the shape and appearance of each part. We implement the decomposition network using two multi-head attention transformers without positional encoding [START_REF] Vaswani | Attention is all you need[END_REF], τ s θ and τ t θ , that predict M shape {z s m } M m=1 and texture {z t m } M m=1 codes, as follows:

where L d is the dimensionality of the instance-specific embeddings and is set to 128. The input to transformer τ s θ is the set of M per-part shape codes {ẑ s } M m=1 , where ẑs m ∈ R 128 . Likewise, the input to transformer τ t θ is the set of M per-part texture codes {ẑ t } M m=1 , where ẑt m ∈ R 128 . Note that the M shape {ẑ s } M m=1 and texture {ẑ t } M m=1 codes are produced from

C.1.1 Comparison with Part-Based Generative Models

In this section, we provide more qualitative comparisons of our generated shapes with existing part-based generative methods [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF], that require explicit 3D supervision in the form of occupancy labels. In particular, we visualize random samples for three ShapeNet [START_REF] Angel | Shapenet: An information-rich 3d model repository[END_REF] categories: Table, Airplane, Chair. Results are summarized in Fig. 23. Our method can generate geometries of similar quality to [START_REF] Hertz | SPAGHETTI: editing implicit shapes through part aware generation[END_REF], without the need of explicit 3D supervision.

C.2. Shape Interpolation

In this section, we show interpolations between the shape and texture codes of two various objects for all object categories. In particular, we interpolate between the latent codes of two shapes and demonstrate that our model is able to smoothly interpolate between two shapes, while preserving the shape structure and the part-based structure for all object categories. Fig. 24 shows three interpolations from left to right between two airplanes. For the case of cars and motorbikes, interpolation results are summarized in Fig. 26 and Fig. 25. Note that for all interpolations the transitions from one shape to the other are consistently meaningful.