High-Resolution Neural Rendering

Abstract

A method and system are provided for training a machine learning model to generate density values ​​and radiance components based on position data with a weighting scheme associated with a particular line of sight based on orientation data to calculate a final RGB value for each point along a plurality of camera rays. The position data and orientation data are extracted from a set of training images of a particular static scene. The radiance components, density values, and weighting scheme are cached for efficient image data processing to perform volume rendering for each sampled point. A novel viewpoint of the static scene is generated based on the volume rendering for each sampled point.

Description

[Technical Field]

[0001]

[0001] Background [Background technology]

[0002] Many methods have been investigated for rendering continuous three-dimensional (3D) viewpoints of 3D scenes containing various materials and objects with complex geometries. The goal of such research is to be able to render novel viewpoints of a scene from a limited number of 2D training images. Such static scenes can be represented by a continuous 5D or 6D function that takes a position and a direction as input and outputs the directional radiance at that position. Alternatively, the codomain of such a function is the radiance at each direction and point in space. Some research has focused on encoding objects and scenes into neural networks such as multi-layer perceptrons (MLPs).

[0003] Neural Radiance Field (NeRF) is a recently discovered method for training a neural network to capture a 3D scene based on multiple images of that scene. Once the network is trained, it can then be used to generate images of the scene from any viewpoint, with any camera parameters. However, while the NeRF method accurately renders the subtle details of a scene, the process of rendering new viewpoints is very slow and computationally expensive. The primary source of inefficiency in NeRF is that the neural network must be called as many as 200 times for each pixel rendered. For a 1 MPix image, this results in 200 million calls to the neural network to render a single image. Therefore, to render a single image, the computing system processes data for a long period of time to achieve these detailed results.

[0004]

[0003] In view of the above, there remains a need for improved systems and methods for generating training data and training models, including the development of such models, for improved image rendering.

[0005]

[0004] The subject matter claimed herein is not limited to embodiments that solve any drawbacks or that operate only in environments such as those described above. Rather, this Background section is provided merely to illustrate one example technology area in which any embodiments described herein may be practiced. Summary of the Invention

[0006] Disclosed embodiments are directed to training a machine learning model to generate color output for a static scene. A three-dimensional (3D) static scene is identified. After acquiring a set of training images including multiple viewpoints of the 3D static scene, multiple camera rays corresponding to the set of training images are identified. A set of points is sampled along the multiple camera rays to obtain position and orientation data for each point in the point cloud. A first neural network is then trained on the position data, and the position data is processed with the first neural network to generate a density value and multiple radiance components. The multiple radiance components and the density values ​​are cached.

[0007]

[0006] A second neural network is also trained on the directional data. The directional data is processed by the second neural network to generate a weighting scheme for the plurality of gaze directions. The weighting scheme includes a plurality of weight values ​​to be applied to the plurality of radiance components. A weighting scheme is cached for each gaze direction included in the plurality of gaze directions, and a final color value is generated by combining the cached plurality of radiance components according to the cached weighting scheme associated with the particular gaze direction.

[0008] Some embodiments are also directed to systems and methods for generating new viewpoints of a static scene based on cached orientation and position data obtained for the static scene. In such embodiments, a computing system identifies a three-dimensional static scene and a new viewpoint from which to render a two-dimensional image of the three-dimensional static scene. A cached database of radiance components for a plurality of points in a volumetric representation of the three-dimensional static scene is accessed along with a cached database of weighting schemes for a plurality of viewing directions. For each point in the plurality of points, a final color value is generated by combining the set of radiance components for each point according to a weighting scheme contained in the cached database of weighting schemes corresponding to one or more new viewing directions in the plurality of viewing directions.

[0009] This Summary section is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary section is not intended to identify key features or essential features of the claimed subject matter, nor is it intended for use as an aid in determining the scope of the claimed subject matter.

[0010]

[0009] Additional features and advantages will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the teachings herein. The features and advantages of the invention may be realized and obtained by means of the implementations and combinations particularly pointed out in the appended claims. Features of the invention will become more fully apparent from the following description and the appended claims, or may be learned by the practice of the invention as set forth hereinafter. [Brief explanation of the drawings]

[0011]

[0010] To explain how the above-mentioned and other advantages and features can be obtained, a more particular description of the subject matter briefly described above will be rendered by reference to specific embodiments that are illustrated in the accompanying drawings. The embodiments will be described and explained with additional specificity and detail by use of the accompanying drawings, with the understanding that the drawings depict only exemplary embodiments and therefore should not be construed as limiting the scope. [Figure 1] FIG. 1 illustrates a computing environment in which a computing system may be incorporated and / or used to implement disclosed aspects of the disclosed embodiments. [Figure 2A]

[0012] FIG. 2A illustrates an exemplary embodiment for generating novel viewpoints of a static scene based on training images. [Figure 2B] FIG. 2B illustrates an exemplary embodiment for generating novel viewpoints of a static scene based on training images. [Figure 3]

[0013] Figure 3 shows a conventional embodiment of a process flow diagram for training a machine learning model to generate color values ​​for points contained in a volumetric representation of a static scene. [Figure 4]

[0014] FIG. 4 illustrates a novel embodiment of a process flow diagram for training a machine learning model to generate color values ​​for points in a volumetric representation of a static scene based on disentangled positional and directional data. [Figure 5]

[0015] Figure 5 shows one embodiment of a process flow diagram for generating novel viewpoints of a static scene by accessing cached radiance components and cached weighting schemes. [Figure 6]

[0016] FIG. 6 illustrates one embodiment of a flow chart including operations for training a machine learning model to generate color values ​​for points in a volumetric representation of a static scene. [Figure 7]

[0017] FIG. 7 illustrates one embodiment of a flow chart including operations for generating color values ​​for points included in a volumetric representation of a static scene to generate a novel viewpoint image of the static scene. DETAILED DESCRIPTION OF THE INVENTION

[0012]

[0018] Disclosed embodiments are directed to generating novel viewpoints of a three-dimensional scene, and to training and caching neural networks configured to generate novel viewpoints of a three-dimensional scene.

[0013]

[0019] 1, there is shown components of a computing system 110 that may include and / or be used to implement aspects of the disclosed invention. As shown, the computing system includes multiple machine learning (ML) engines, models, neural networks, and data types associated with the inputs and outputs of the ML engines and models.

[0014]

[0020] 1 , computing system 110 is shown as part of computing environment 100 that also includes remote / third-party system 120 in communication with computing system 110 (via network 130). Computing system 110 is configured to train multiple machine learning models for volume rendering, image rendering, and image data processing, and more specifically, to train machine learning models for generating point-wise light values ​​in volumetric representations of static three-dimensional scenes based on cached position-based and orientation-based neural networks. Computing system 110 is also configured to generate training data configured to train the machine learning models.

[0015]

[0021] Computing system 110 includes, for example, one or more processors 112 (e.g., one or more hardware processors) and storage (i.e., hardware storage devices 140) that store computer-executable instructions 118, where the one or more hardware storage devices 140 can accommodate any number of data types and any number of computer-executable instructions 118, such that computing system 110 is configured to implement one or more aspects of the disclosed embodiments when the computer-executable instructions 118 are executed by the one or more processors 112. Computing system 110 is also shown to include a user interface 114 and input / output (I / O) devices 116.

[0016]

[0022] As shown in FIG. 1 , hardware storage device 140 is depicted as a single storage unit. However, it will be understood that hardware storage device 140 can be configured as a distributed storage system that is distributed across several separate, sometimes remote and / or third-party systems 120. Computing system 110 can also comprise a distributed system with one or more components of computing system 110 maintained / executed by different individual systems that are remote from one another, each performing a different task. In some examples, multiple distributed systems perform similar and / or shared tasks to implement the disclosed functionality, such as in a distributed cloud environment.

[0017]

[0023] The hardware storage device 140 is configured to store various data types, including image data 141, camera data 142, position data 143, orientation data 144, radiance component data 145, final RGB data 146, weighting scheme data 147, computer-executable instructions 118, volumetric density data 148, and cached MLP models described herein.

[0018]

[0024] Storage (e.g., hardware storage device 140) includes computer-executable instructions 118 for instantiating or executing one or more models and / or engines shown within computing system 110. The models are configured as machine-learned or pre-machined models, such as deep learning models and / or algorithms and / or neural networks. In some examples, one or more models are configured as engines or processing systems (e.g., computing systems integrated within computing system 110), and each engine (i.e., model) includes one or more processors (e.g., hardware processor 112) and computer-executable instructions 118 corresponding to computing system 110.

[0019]

[0025] The image data 141 includes multiple images captured at various viewing angles or view directions. Additionally or alternatively, the image data 141 includes metadata (i.e., attributes, information, object or scene identifiers, etc.) corresponding to the particular source from which the data was collected. The metadata may include attributes associated with a static scene or object type, characteristics of the image data 141, and / or information about where, when, and / or how the image data 141 was acquired. The multiple images corresponding to a particular scene or object are used as training images to train a neural network to render novel perspectives of the particular static scene or object contained in the multiple images.

[0020]

[0026] Camera data 142 includes data about the type of camera used, whether it is a simulated (or virtual) camera or a real camera, the direction of the camera ray relative to the volumetric representation of the static scene, camera ray lens information, a camera model identifier, the height of the camera capture angle, the distance from one or more objects in the static scene, and other attributes associated with the camera and the captured image.

[0021]

[0027] The position data 143 is organized as a data set, where each data point includes a position identifier of a sampled point along a camera ray (simulated by a real or virtual camera). The position identifier is set as a three-dimensional coordinate (e.g., Cartesian coordinate) that specifies a particular point within a bounded volumetric representation of a static scene. Thus, the position data 143 also includes boundary data for the volumetric representation and the positions of one or more objects within the volumetric representation.

[0022]

[0028] Position data 143 is stored for all points sampled along each camera ray simulated in the volumetric representation. To improve storage efficiency, when caching the trained neural network, a sparse volume is generated to hold the radiance components and weights. The weights are held in a sparse volume because the input is known to be on the surface of a sphere (hence, empty space anywhere outside the surface). The radiance components are also held in a sparse volume because the empty parts of the scene are known through knowledge of the density values ​​output by the network. To further improve storage efficiency, position data 143 is stored only for occupied space (e.g., the volumetric space occupied by objects or materials in a static scene); empty space is not included in the volumetric data set (referred to as a sparse volume).

[0023]

[0029] The direction data 144 is defined as a data set, where each data point includes a viewing direction identifier for a point sampled along a camera ray (simulated by a real or virtual camera). The viewing direction is the direction of the ray along which the point is sampled. The direction data is the ray direction, which is the same for all points along a single ray. The direction identifier is defined as a three-dimensional vector specifying the specific viewing angle of the point. The direction data 144 is stored for all points sampled along each simulated camera ray in the volumetric representation. In some examples, the direction data 144 is also derived from camera data 142, which includes the camera's image capture angle, which corresponds to the viewing direction of the particular point. The position data 143 and the direction data 144 include data for corresponding points sampled in the volumetric representation of a static scene. In other words, each sampled point has position data 143 and direction data 144.

[0024]

[0030] The radiance component data 145 includes a color map, a deep radiance map, RGB components, and / or a set of radiance components for each point in the volumetric representation of the static scene. In other words, radiance components or RGB values ​​are generated for a set of points sampled on a 3D grid in the static scene. These grids have various sizes, such as 256^3 and / or 512^3 points. The sets of radiance components are configured to be combined according to a weighting scheme (e.g., weighting scheme data 147). Each weighting scheme included in the weighting scheme data 147 corresponds to a particular viewing direction of the static scene. Each weighting scheme includes multiple weight values ​​that determine the proportion of each radiance component in the set of radiance components that will be combined to form the final RGB value (e.g., final RGB data 146). The weight values ​​are stored as percentages. Alternatively, the weight values ​​are not constrained to sum to one.

[0025]

[0031] The hardware storage device 140 also stores volumetric density data 148, which includes a plurality of density values ​​set to represent the opacity of points in the volumetric representation of the static scene. The density values ​​correspond to the opacity of materials or objects in the static scene and are equal to or greater than zero. A zero value for density represents low opacity or a transparent point. Higher density values ​​represent more opacity or a more dense point. The density values, along with RGB values, can represent the radiance, transparency, reflectance, or other attributes of various points of materials and objects in the volumetric representation of the static scene.

[0026]

[0032] The hardware storage device 140 is also configured to store a cached network (e.g., a cached MLP model 149) corresponding to a machine learning model configured to generate novel viewpoints of static scenes based on a set of training images of the static scenes. The cached MLP model 149 includes a first multilayer perceptron (MLP) network parameterized by position data 143 to generate volumetric density data 148 and radiance component data 145. The radiance component data 145 and the volumetric density data 148 are cached, and a computing system (e.g., computing system 110) can access the cached data to perform efficient volume rendering of the static scenes. The cached MLP model 149 also includes a second MLP network parameterized by direction data 144 to generate weighting scheme data 147. The weighting schemes generated by the second MLP network are cached according to various viewing directions, and a computing system can access the weighting schemes when performing volume rendering and other image processing tasks.

[0027]

[0033] An additional storage unit for storing machine learning (ML) engine 150 is shown herein in Figure 1 as storing multiple machine learning models and / or engines. For example, computing system 110 may include one or more of data search engine 151, sampling engine 152, feature extraction engine 153, training engine 154, combination engine 155, implementation engine 156, and rendering engine 157, each individually and / or collectively configured to perform various functions described herein.

[0028]

[0034] For example, data search engine 151 is configured to identify and access data sources, databases, and / or storage devices containing one or more data types from which data search engine 151 can extract a set or subset of data to be used as training data. Data search engine 151 receives data from databases and / or hardware storage devices, and data search engine 151 is configured to reformat or otherwise augment the received data to be used as training data. Additionally or alternatively, data search engine 151 communicates with one or more remote / third-party systems (e.g., remote / third-party system 120) that contain remote / third-party data sets and / or data sources. In some examples, these data sources include visual services that record text, images, and / or video.

[0029]

[0035] Data search engine 151 accesses electronic content including image data 141, camera data 142, position data 143, orientation data 144, radiance component data 145, final RGB data 146, weighting scheme data 147, volumetric density data 148, and / or other types of audiovisual data, including video data, image data, holographic data, 3-D image data, etc. Data search engine 151 is a smart engine capable of learning optimal dataset extraction processes to provide sufficient data in a timely manner and to search for the most applicable data for the desired application for which the machine learning model / engine is trained. For example, data search engine 151 can learn which databases and / or datasets generate training data for training a model (e.g., for a particular query or task) to improve the model's accuracy, efficiency, and effectiveness in a desired image processing technique.

[0030]

[0036] The data search engine 151 identifies, selects, and / or stores raw, recorded source data (e.g., image data 141), and the data search engine 151 communicates with one or more other ML engines and / or models included in the computing system 110. In such cases, the other engines in communication with the data search engine 151 can receive data retrieved (i.e., extracted, pulled, etc.) from one or more data sources so that the received data can be further enhanced and / or applied to downstream processes. For example, the data search engine 151 communicates with the training engine 154 and / or the implementation engine 156.

[0031]

[0037] The sampling engine 152 is configured to identify simulated camera rays within a volumetric representation of a static scene. The sampling engine 152 then identifies a set of points along the particular camera rays (i.e., samples the point cloud). Based on the sampled points, the feature extraction engine 153 accesses the position data 143 and orientation data 144 for each point. The feature extraction engine 153 is configured to extract the position data 143 and / or orientation data 144 information from the electronic content, image data 141, and camera data 142.

[0032]

[0038] The training engine 154 is in communication with one or more of the data search engine 151, the sampling engine 152, the feature extraction engine 153, or the implementation engine 156. In such an embodiment, the training engine 154 is configured to receive one or more sets of training data from the data search engine 151. After receiving the training data related to a particular application or task, the training engine 154 trains one or more models based on the training data. The training engine 154 is configured to train the models through unsupervised training or supervised training.

[0033]

[0039] The training engine 154 is configured to train one or more machine learning models (e.g., MLP neural networks) on a set of training images including static scenes to generate novel perspectives of the static scenes. More specifically, the training engine 154 is configured to train a first MLP network based on position data to generate volumetric density data 148 and radiance component data 145. The training engine 154 is configured to train a second MLP network on orientation data 144 to generate weighting scheme data 147. The training engine 154 is configured to train the machine learning models to minimize the error between the rendered image of the static scene and the corresponding training image of the static scene. The training of the two neural networks (e.g., the orientation neural network and the position neural network) is performed sequentially as two separate steps. Alternatively, the training of the first MLP network parameterized by position data and the training of the second MLP network parameterized by orientation data are performed in parallel or simultaneously. In such an embodiment, the training loss (a function optimized by the training process) compares the rendered pixel to the ground truth pixel, renders a single pixel, and then requires that the output from both networks minimize the loss between the rendered pixel and the ground truth pixel.

[0034]

[0040] The computing system 110 includes a combination engine 155 configured to combine sets of radiance component data corresponding to a particular point based on a weighting scheme associated with a particular viewing direction to generate a final RGB value for the particular point.

[0035]

[0041] The computing system 110 also includes an implementation engine 156 that communicates with any one of the models and / or ML engines 150 (or all of the models / engines) included in the computing system 110, such that the implementation engine 156 is configured to implement, initiate, or execute one or more functions of the multiple ML engines 150. In one example, the implementation engine 156 is configured to operate a data search engine 151, such that the data search engine 151 searches for data in a timely manner so that it can generate training data for the training engine 154.

[0036]

[0042] The implementation engine 156 facilitates process and timing communications between one or more ML engines 150 and is configured to implement and operate a machine learning model (or one or more of the ML engines 150) configured to access cached MLP models to generate point-wise light values ​​(e.g., radiance values), color values, perform volume rendering, and generate novel images based on viewpoints not previously captured by images included in the set of training images.

[0037]

[0043] The rendering engine 157 is configured to perform volume rendering for each point sampled along a particular camera ray based on the final RGB and density values, perform volume rendering for each point included in the volumetric representation of the static scene, and render a new 2D image including a new viewpoint of the static scene. The rendering engine 157 is also configured to generate successive 3D viewpoints of the static scene based on multiple new viewpoints and / or a set of captured images of the static scene. More specifically, the image is rendered by combining sets of radiance component data to generate a final color value and then performing volume rendering using the density values ​​for the particular points and the final color value.

[0038]

[0044] The rendering engine 157 supports multiple rendering modes, such as volume lookup and ray-trace volume lookup. In volume lookup, calls to neural networks are replaced with cache lookups. In ray-trace volume lookup, hardware-accelerated ray tracing is performed to skip empty space in volumetric representations of 3D static scenes. Collision meshes are calculated from sign-distance functions derived from density volumes. In some instances, for volumes larger than 512^3 points, the volumes are scaled down by a factor of two to reduce mesh complexity. The rendering engine 157 integrates points along a ray only after the first hit is identified by the collision mesh. Mesh generation parameters are held constant across all data sets, and the storage complexity of the collision mesh is negligible compared to the grid cache. By leveraging collision meshes, the calculation system uses ray-traced volume lookups, which significantly reduces calls to the cache and provides improved calculation speed over using volume lookup mode.

[0039]

[0045] The computing system communicates with a remote / third party system 120 that includes one or more processors 122 and one or more computer-executable instructions 124. In some examples, the remote / third party system 120 is expected to further include a database containing data that can be used as training data, for example, static scene data not included in local storage. Additionally or alternatively, the remote / third party system 120 includes a machine learning system external to the computing system 110. The remote / third party system 120 is a software program or application.

[0040]

[0046] Neural Radiance Fields (NeRF) is a method for training a neural network to render a 3D scene based on a fixed number of images of that scene. Once the network is trained, it can be configured to generate images of the scene from any viewpoint, with any camera parameters. However, traditional NeRF networks are very slow. The main source of inefficiency in traditional NeRF networks is that the neural network must be called 200 times for each pixel that is rendered. For a 1MPix image, this means training the neural network 200x10 times to render a single image. 6 Call times.

[0041]

[0047] To address this inefficiency, the present invention is directed to a system and method for separating a NeRF neural network into two separate networks that can be cached for efficient inference. By caching neural network outputs for a wide selection of inputs and then replacing neural network processing with cache lookups, processing time, storage, and computations are significantly reduced. It will be appreciated that the disclosed embodiments for separating and caching the position and orientation components of a neural network are applicable to any neural network configured to receive orientation and position data as input parameters and output point-wise light values ​​(e.g., radiance).

[0042]

[0048] A static scene is represented as a continuous 6D function that outputs (1) the radiance emitted in each direction at each point in space and (2) the density at each point. The density is set as a variable opacity value that determines the amount of radiance present in a ray passing through each point. A separately cached multilayer perceptron (MLP) (e.g., a deep fully connected neural network without convolutional layers) is used to convert the 6D coordinates (direction vector and position) of a particular point into a single volumetric density and viewpoint-dependent RGB color. To render a novel viewpoint of a static scene (e.g., a viewpoint not previously included in the set of previously captured images), a volumetric density and viewpoint-dependent RGB color are generated for each point in the volumetric representation of the static scene. Based on the desired novel viewpoint, the system samples the volumetric density and viewpoint-dependent RGB color for all points corresponding to the rendering of the novel viewpoint.

[0043]

[0049] 2A and 2B, multiple images of a particular static scene are captured by multiple cameras (e.g., camera 210) or by a single camera at various positions. The camera parameters, including the camera's image capture direction and position, are known and accessible by the system. A volumetric representation 230 of the static scene 240 is generated, and camera rays (e.g., simulated camera rays 220) based on the image capture direction of each image included in the multiple images are simulated throughout the volumetric representation.

[0044]

[0050] The system samples multiple coordinates along each camera ray. Each of the multiple coordinates, or points (e.g., points 222, 224, 226, and 228), has a 2D viewing direction based on the image capture direction. The location of each point along simulated camera ray 220 and its associated direction are applied as input to a neural network, which generates an output set of colors and densities. Classical volume rendering techniques are then used to aggregate these colors and densities into a 2D image (e.g., image 260), where the multiple coordinates (e.g., points 222, 224, 226, and 228) associated with a particular simulated camera ray, now defined by its respective set of colors and densities, are sampled and collapsed into a pixel (e.g., pixel 270) that will be included in the newly rendered novel perspective of static scene 240.

[0045]

[0051] The multiple novel viewpoints are then rendered from different angles corresponding to the static scene. The novel viewpoints can be rendered from any angle based on the set of captured images (e.g., training images). The multiple novel viewpoints are then processed (e.g., by gradient-based optimization) along with the set of originally captured images to generate a continuous 3D viewpoint of the static scene.

[0046]

[0052] The disclosed embodiments advantageously derive from the attributes of volumetric representations that capture the ability to represent complex real-world geometries and appearances. Other advantages include reducing storage and computational costs by representing continuous scenes with complex geometry and materials (or generating novel viewpoints) as neural radiance fields using machine learning models parameterized as partially cached multi-layer perceptron (MLP) networks. The cached portion corresponds to position and orientation encodings disentangled from 6D functional data corresponding to static volumetric scene representations.

[0047]

[0053] Additionally, volume rendering techniques are used to optimize the representation using standard RGB images. An optimized sampling strategy is used to identify points in the volumetric representation that correspond to visible scene content (e.g., points in empty space are omitted during the rendering process to focus computational effort on visible scene content).

[0048]

[0054] Continuous viewpoints of a static scene are represented by a 6D vector-valued function. Inputs to this function include position (e.g., represented by 3D Cartesian coordinates) and viewing direction (e.g., represented by a 3D unit vector). Outputs include emitted color (e.g., RGB data or radiance data) and volumetric density. Continuous viewpoints are rendered by a dual MLP network, including cached ones for direction-based and position-based parameters, and the position-encoding and direction-encoding inputs are disentangled from the 6D vector-valued function.

[0049]

[0055] The disclosed embodiments advantageously generate a set of density and radiance components based on positional encoding data. The radiance components are depth radiance maps and / or RGB-based color data. A computing system generates a predetermined number of radiance maps. A set of weighting values, or weighting schemes, is generated based on the directional encoding data and configured to be applied to the set of radiance components. The weighting schemes determine the values ​​of each radiance component to be included in the final color rendering for a particular point sampled along the ray. Multiple points are then sampled along the particular ray, and classical volume rendering techniques are used to generate a color and density rendering of the pixel. The volume density corresponds to the differential probability of a ray (e.g., a simulated camera ray) terminating at the location of the particular point.

[0050]

[0056] Generating a position encoding involves mapping the position input to a higher-dimensional space using high-frequency functions before applying the position input to a neural network configured to generate radiance components and density data. This encoding process allows for more accurate data fitting, including high-frequency variations. Additional functions are applied to each of the position coordinate values ​​(e.g., "x," "y," "z"), which are then normalized. These functions are used to map continuous input coordinates to a higher-dimensional space, allowing the MLP network to better approximate higher-frequency functions, which allows for higher-quality rendering of detailed, static scenes. Viewpoint sampling allows for the rendering of photorealistic novel viewpoints (or novel viewpoints based on a set of training images). Errors in rendering novel viewpoints based on a set of captured images are minimized.

[0051]

[0057] As shown in FIG. 3 , a conventional system for a NeRF neural network includes a large MLP 314 configured to receive position data 310 (e.g., the position coordinates of each point along a camera ray), which is processed for higher frequency applications through a position encoding operation 312. The large MLP 314 then generates a density value 316 for each point based on the position data 310 corresponding to the density value 316. The large MLP 314 also outputs a feature vector 318 that is combined with direction data 320 (and subsequent direction encoding data 322), which is received by a second small MLP 324. This small MLP 324 is then configured to generate a final RGB value 326 for each point. Therefore, due to these constraints, in which the position data 310 and direction data 320 are entangled between the two neural networks, caching of separate neural networks, such as that according to the disclosed embodiments, is not feasible. Traditional neural networks take in 6-dimensional inputs (3 for position and 3 for orientation), which takes a very large amount of memory to cache. For example, if a system samples 512 values ​​for each input parameter and stores the outputs (e.g., in half-precision floating point (float16)), the cache would occupy 144 petabytes.

[0052]

[0058] Therefore, as shown in FIG. 4, a novel neural network is shown that increases efficiency and reduces the memory required to cache the neural network. The neural network 300 is shown to include a position MLP 414 and a direction MLP 424. The position MLP 414 takes as input position data 410 (e.g., 3D coordinates for the locations of sampled points along a camera ray). The position data is processed to generate position encodings 412, which are then received by the position MLP 414. The position MLP 414 processes the position encodings 412 for each sampled point and outputs (1) a density value 416 and (2) a number of radiance components 418 (e.g., a vector 0, 1, 2, 3, 4, 5, 6, 7), also referred to as a color component map. While FIG. 3 shows at least eight radiance components (e.g., RGB vectors or color maps), it will be understood that any number of radiance components 418 may be generated by the location MLP 414.

[0053]

[0059] A second neural network (e.g., direction MLP 424) is shown configured to receive as input parameters direction data 420, which is processed by direction encoding 422. Direction encoding 422 is processed from direction data 420 (e.g., 3D vector data corresponding to sampled points along a camera ray). Direction MLP 424 is configured to generate a weighting scheme (e.g., weights 426) or weight values ​​for each direction associated with the sampled point. The weighting scheme determines the value or amount of each radiance component to be included in the final RGB rendering. The weights are multiplied with the components by dot products. The radiance components 418 (i.e., color component map) are combined in a number of ways based on the weighting scheme (e.g., weights 426) to generate final color data (e.g., final RGB data 430). The density values ​​416 and final RGB data 430 are then used to render each pixel at the new viewpoint.

[0054]

[0060] As shown in Figure 5, because positions and viewpoints are disentangled, the model can be efficiently cached. For example, if the system samples 512 values ​​for each input parameter and stores the outputs (e.g., in half-precision floating point (float16)), the cache would occupy 8.86 gigabytes. This is over 16,000,000 times smaller than the corresponding cache for a standard NeRF model. Furthermore, this kind of dense cache can be converted into a sparse representation, which significantly reduces the amount of memory required to store the network. Thus, once the cache is computed, the volume rendering process relies on an efficient lookup rather than making a computationally expensive call to the neural network for each new viewpoint.

[0055]

[0061] Specifically, the weighting scheme for each direction corresponding to a sampled point is stored as a weight index 510, so that when a new viewpoint is selected for rendering, the system looks up the applicable weighting scheme in the weight index. The radiance components 518 (e.g., vector 0-vector 7) are also cached, so that the radiance components 518 are combined to form a final RGB value 530 based on the particular combination of radiance components per point. The final RGB value 530 and density data 516 (previously output by the position MLP) are used in volume rendering 540 for the particular point. The system is invoked for each point sampled along one or more camera rays.

[0056]

[0062] Generating the cached data can take anywhere from a few seconds to a few minutes, depending on the size of the volumetric representation. Once the cache is calculated, which only needs to be calculated once after the neural network is trained, the values ​​and data are configured to be accessed directly in the cache without any additional network computations.

[0057]

[0063] Attention now turns to FIG. 6 , which illustrates a flow chart 600 including various operations (operation 605, operation 610, operation 615, operation 620, operation 625, operation 630, operation 635, operation 640, operation 645, operation 650, operation 655, and operation 660) associated with an exemplary method that may be performed by computing system 110 that obtains training data and trains a machine learning model to generate pointwise light and color values ​​for a static scene.

[0058]

[0064] A first illustrated operation includes identifying a three-dimensional (3D) static scene (operation 605). The computing system then obtains a set of training images including multiple viewpoints of the 3D static scene (operation 610) and identifies multiple camera rays corresponding to the set of training images (operation 615). The point cloud is sampled along the multiple camera rays to obtain position and orientation data for each point included in the point cloud (operation 620).

[0059]

[0065] The computing system trains a first neural network based on the position data (operation 625) and processes the position data using the first neural network to generate density values ​​and a plurality of radiance components (operation 630). After generating the output, the computing system caches the plurality of radiance components (operation 635). In some embodiments, the plurality of radiance components described herein differ from the plurality of radiance components obtained by processing all of the points in the data set. The cache is calculated over 3D points sampled on a grid or volumetric representation of a static scene. These sampled points, in some cases, match points in the training set. In some cases, the two point clouds do not match.

[0060]

[0066] The computing system also trains a second neural network based on the direction data (operation 640), and processes the direction data with the second neural network to generate a weighting scheme for the plurality of gaze directions, the weighting scheme including a plurality of weights to be applied to the plurality of radiance components (operation 645). The first neural network and the second neural network are configured as multilayer perceptrons.

[0061]

[0067] After generating the output, the weighting scheme for each gaze direction in the plurality of gaze directions is cached (operation 650). When storing the gaze directions, the gaze directions are sampled on a sphere with some density that depends on the desired cache size. Some gaze directions may match directions in the training data.

[0062]

[0068] Finally, a final color value is generated by combining the cached radiance components according to a cached weighting scheme associated with the particular viewing direction (operation 655).

[0063]

[0069] The computing system also performs volume rendering for each point in the portion of the point cloud along the camera ray included in the multiple camera rays based on the density values ​​and the final color values ​​(operation 660). The portion of the point cloud along the camera ray can be collapsed into rendered pixels that will be included in a two-dimensional (2D) image of the static scene. The computing system can then apply the 2D image of the static scene in an augmented virtual reality application.

[0064]

[0070] Alternatively, to perform volume rendering as described above, the computing system also derives a collision mesh from the volumetric representation by calculating a sign-distance function based on the volume density for a plurality of points sampled along the camera ray. A first point in the plurality of points is identified, which corresponds to the first hit calculated by the collision mesh. Volume rendering is then performed by integrating a portion of the plurality of points, which corresponds to non-empty space identified by the collision mesh after the first hit.

[0065]

[0071] Before deriving a collision mesh from the volumetric representation of the 3D static scene by computing a sign-distance function based on the volume density of points sampled along the camera ray, the computational system downsizes the volumetric representation of the 3D static scene by a predetermined factor based on the original volume of the volumetric representation.

[0066]

[0072] To minimize the error between the rendered pixels and the corresponding pixels in the training images, the rendered pixels are compared with the corresponding pixels in the training images included in the set of training images.

[0067]

[0073] The method is also directed to generating a position encoding for the position data and generating a direction encoding for the direction data.

[0068]

[0074] The training image set is a 2D, RGB image of a static scene, and further includes metadata including camera parameters and a static scene boundary, where the radiance component and final color values ​​are constructed as the radiance component. The static scene boundary defines a bounding box, from which the input to the neural network will be sampled. If an approximate mesh or point cloud is available for the scene, its extreme points define the bounding box. Alternatively, near and far ray boundaries specified for each camera in the training set can be used to define the bounding box, or the bounding box can be manually defined by the user.

[0069]

[0075] In addition to the set of training images, the computing system also obtains a set of camera parameters corresponding to the plurality of camera rays, determines a minimum boundary and a maximum boundary of each camera ray included in the plurality of camera rays based on the set of camera parameters, and samples a set of points along the plurality of camera rays from the minimum boundary to the maximum boundary.

[0070]

[0076] Attention now turns to FIG. 7, which shows a flow chart including various operations (operation 705, operation 710, operation 715, operation 720, operation 725, operation 730, and operation 735) associated with an exemplary method that may be performed by computing system 110 to generate novel perspectives of a static scene.

[0071]

[0077] A first illustrated operation includes identifying a 3D static scene (operation 705), and a second illustrated operation includes identifying a novel viewpoint from which to render a 2D image of the 3D static scene (operation 710). The computing system then accesses a cached database of radiance components for a plurality of points included in a volumetric representation of the 3D static scene (operation 715) and a cached database of weighting schemes for a plurality of viewing directions (operation 720). The volumetric representation can be constructed as a neural radiance field. The plurality of points are points along rays passing through the image to be rendered from one or more novel viewpoints. For each point in the plurality of points, a final color value is generated by combining the set of radiance components for each point according to a weighting scheme corresponding to one or more novel viewing directions included in the plurality of viewing directions (operation 725).

[0072]

[0078] The computing system generates multiple rays, multiple points are generated along the rays and then sampled, the colors of the points are calculated per operation 725, and the color of the pixel to which the rays correspond is calculated in operation 730.

[0073]

[0079] The computing system performs volume rendering for each point based on the final color value and the corresponding density value (operation 730). The computing system also generates a new viewpoint of the static scene based on the volume rendering for each point, where the points are collapsed into pixels that will be included in the new viewpoint of the static scene (operation 735).

[0074]

[0080] In view of the above, it will be appreciated that the disclosed embodiments provide many technical advantages over conventional systems and methods for generating machine learning training data configured to train a machine learning model that generates RGB color values ​​for points belonging to a static scene based on untangled position and orientation data. The disclosed embodiments beneficially improve upon conventional techniques for generating novel and / or sequential viewpoints of a static scene.

[0081] In particular, the disclosed embodiments facilitate improvements in multi-view consistency and reduce artifacts when compared to conventional techniques. Furthermore, the present invention integrates well into ray tracing and path tracing paradigms through the use of implicit functions that can be queried at any point, freeing the system and method from the need to specify precise bounding volumes or geometries at training time.

[0075]

[0082] Embodiments of the present invention may comprise or utilize a special-purpose or general-purpose computer (e.g., computing system 110), including computer hardware, as described in more detail herein. Embodiments within the scope of the present invention also include physical and other computer-readable media for carrying or storing computer-executable instructions and / or data structures. Such computer-readable media may be any available media that can be accessed by a general-purpose or special-purpose computer system. Computer-readable media (e.g., hardware storage device 140 in FIG. 1) that store computer-executable instructions (e.g., computer-executable instructions 118 in FIG. 1) are physical hardware storage media / devices, excluding transmission media. Computer-readable media that carry computer-executable or computer-readable instructions (e.g., computer-executable instructions 118) on one or more carrier waves or signals are transmission media. Thus, by way of example, and not limitation, embodiments of the present invention may include at least two distinctly different types of computer-readable media: physical computer-readable storage media / devices and computer-readable transmission media.

[0076]

[0083] A physical computer-readable storage medium / device is hardware, including RAM, ROM, EEPROM, CD-ROM or other optical disk storage (CD, DVD, etc.), magnetic disk storage or other magnetic storage devices, or any other hardware that can be used to store desired program code means in the form of computer-executable instructions or data structures and that can be accessed by a general-purpose or special-purpose computer.

[0077]

[0084] A "network" (e.g., network 130 in FIG. 1) is defined as one or more data links that enable the transfer of electronic data between computer systems and / or modules and / or other electronic devices. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a transmission medium. Transmission media can include networks and / or data links that can be used to transport desired program code means in the form of computer-executable instructions or data structures that can be accessed by a general-purpose or special-purpose computer. Combinations of the above are also included within the scope of computer-readable media.

[0078]

[0085] Furthermore, upon reaching various computer system components, program code means in the form of computer-executable instructions or data structures can be automatically transferred from computer-readable transmission media to physical computer-readable storage media (or vice versa). For example, computer-executable instructions or data structures received over a network or data link can be buffered in RAM within a network interface module (e.g., a "NIC") and then eventually transferred to computer system RAM and / or to less volatile computer-readable physical storage media within the computer system. Thus, computer-readable physical storage media can be included in computer system components that also (or even primarily) utilize transmission media.

[0079]

[0086] Computer-executable instructions include, for example, instructions and data that cause a general-purpose computer, a special-purpose computer, or a special-purpose processing device to perform a certain function or group of functions. The computer-executable instructions may be, for example, binary, intermediate format instructions (e.g., assembly language), or even source code. Although the subject matter has been described in language specific to structural features and / or methodological acts, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the described features or acts described above. Rather, the described features and acts are disclosed as exemplary forms of implementing the claims.

[0080]

[0087] Those skilled in the art will appreciate that the present invention may be practiced in networked computing environments using many types of computer system configurations, including personal computers, desktop computers, laptop computers, message processors, handheld devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, cellular phones, PDAs, pagers, routers, switches, etc. The present invention may also be practiced in distributed system environments where tasks are performed by both local and remote computer systems that are linked through a network (by wired data links, wireless data links, or a combination of wired and wireless data links). In a distributed system environment, program modules may be located in both local and remote storage devices.

[0081]

[0088] Alternatively or additionally, the functions described herein may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include field programmable gate arrays (FPGAs), programmable specific integrated circuits (ASICs), programmable specific standard products (ASSPs), systems on a chip (SoCs), complex programmable logic devices (CPLDs), etc.

[0082]

[0089] The present invention may be embodied in other specific forms without departing from its essential characteristics. The described embodiments are in all respects only illustrative and should not be construed as limiting. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes that come within the meaning and range of equivalency of the claims are to be embraced within their scope.

Claims

1. 1. A method performed by a computing system for training a machine learning model to generate color output for static scenes, comprising: Identifying a three-dimensional static scene; obtaining a set of training images including multiple views of the three-dimensional static scene; identifying a plurality of camera rays corresponding to the set of training images; sampling the point cloud along the plurality of camera rays to obtain position and orientation data for each point in the point cloud; training a first neural network on the position data obtained for each point; processing the position data with the first neural network to generate a density value and a plurality of radiance components; storing the plurality of radiance components as cached radiance components for a plurality of points; training a second neural network on the orientation data; processing the direction data with the second neural network to generate a weighting scheme for a plurality of gaze directions, the weighting scheme including a plurality of weights applied to the plurality of radiance components; storing a weighting scheme for each of the plurality of gaze directions as cached weighting scheme data; and generating a final color value by combining the cached radiance components according to the cached weighting scheme data associated with a particular viewing direction; A method comprising:

2. 10. The method of claim 1, further comprising: performing volume rendering for each point in the portion of the point cloud along a camera ray in the plurality of camera rays based on the density values ​​and final color values ​​contained in a cache database; and dropping a portion of the point cloud along the camera ray into a rendered pixel contained in a two-dimensional image of the static scene; A method comprising:

3. 3. The method of claim 2, further comprising: comparing the rendered pixels to corresponding pixels in training images included in the set of training images; and minimizing the error between the rendered pixels and corresponding pixels in the training images; A method comprising:

4. 10. The method of claim 1, further comprising: deriving a collision mesh from the volumetric representation of the 3D static scene by computing a sign-distance function based on volume densities for a plurality of points sampled along a camera ray; identifying a first point in the plurality of points that corresponds to a first hit calculated by the collision mesh; and performing volume rendering by integrating a portion of a point cloud included in the plurality of points, the portion of the point cloud corresponding to a non-empty volume identified by the collision mesh after the first hit; A method comprising:

5. 10. The method of claim 1, further comprising: prior to deriving a collision mesh from the volumetric representation of the three-dimensional static scene by calculating a sign-distance function based on volume densities for a plurality of points sampled along a camera ray; downsizing the volumetric representation of the three-dimensional static scene by a predetermined factor based on the original volume of the volumetric representation; A method comprising:

6. 10. The method of claim 1, further comprising: performing location encoding on the location data; and performing directional encoding on the directional data; A method comprising:

7. The method of claim 1 , wherein the set of training images are 2D RGB images of the static scene.

8. 10. The method of claim 1, wherein the set of training images further includes metadata including camera parameters and static scene boundaries.

9. The method of claim 1 , wherein the plurality of radiance components and the final color value are set as RGB components.

10. 10. The method of claim 1, wherein the first neural network and the second neural network are trained in parallel.

11. The method of claim 1 , wherein the density value is greater than or equal to zero and represents the opacity of a particular point in the static scene.

12. A method executed by a computing system for generating color values ​​to be used for rendering a static scene to a new viewpoint based on cached orientation and position data obtained for the static scene, the method comprising: Identifying a three-dimensional static scene; identifying a novel viewpoint from which to render a two-dimensional image of the three-dimensional static scene; accessing a cached database of radiance components for a plurality of points included in the volumetric representation of the three-dimensional static scene, the radiance components for the plurality of points having been generated based on the position data; accessing a cached database of weighting schemes for a plurality of gaze directions, the weighting schemes for the plurality of gaze directions being generated based on the direction data; and generating a final color value for each point in the plurality of points originating from the new viewpoint by combining the set of radiance components for each point according to a weighting scheme contained in the cached database of weighting schemes corresponding to one or more new viewing directions in the plurality of viewing directions; A method comprising:

13. 13. The method of claim 12, further comprising: generating a plurality of rays and a plurality of points along the rays corresponding to the new viewpoint; A method comprising:

14. 13. The method of claim 12, further comprising: performing volume rendering for each point based on the final color value and the corresponding density value; A method comprising:

15. 15. The method of claim 14, further comprising: generating a new image of the three-dimensional static scene based on a volume rendering for each point, wherein a plurality of points are dropped onto a plurality of pixels included in the new image of the three-dimensional static scene.

Images