Patent Application
20220122308
This disclosure generally relates to image editing techniques. More specifically, but not by way of limitation, this disclosure relates to editing images with reduced artifacts using smooth region merging techniques, e.g., for use with a generative adversarial network for image editing.
Many image editing tools provide features that enable a user to edit or modify an image. Some of these tools even use machine learning-based techniques for editing images. However, the image editing capabilities of such existing tools are quite limited—the recreation of images is not accurate, the editing is limited to low-resolution images (i.e., large high resolution images cannot be processed at all or cannot be processed in a reasonable time frame for the desired end result), unwanted effects are introduced into the recreated images, and other deficiencies.
Some image editing tools use machine learning models such as Generative Adversarial Networks (GANs) to generate edited images. While GANs have been successful in generating high quality edited images, existing techniques using GANs still have several shortcomings. Resolution is generally limited (e.g., GAN generators can typically output 1024×1024 pixels at best). Given that photos to be edited are increasingly of very high resolution (e.g., 8K resolution), the output image can have a significantly reduced resolution. Current hardware constraints limit the feasible output of generators well beyond an average photograph resolution. Another issue is loss of content. When generating an image using a GAN, detail is not fully preserved, and the output image is often missing details from the input image. Other issues arise due to the fact that GANs typically can only process images at a particular angle that is tightly cropped around a target region (e.g., for faces, the face should be facing directly forward and cropped to omit the body and background). When reintroducing a cropped GAN output region back into the background, issues such as misalignment, different color tones, textural differences, and structural differences are common.
The present disclosure describes techniques for editing images to efficiently generate realistic and accurate edited images. More particularly, new and improved techniques are described for applying and training an encoder with specialized architecture for improved speed and quality image projection, e.g., for use with a generative adversarial network for image editing.
In some embodiments, a computer-implemented method includes cropping, by a computing system, an input image around a region to be edited to produce a cropped input image; applying, by the computing system, an affine transformation to the cropped input image to produce a rotated cropped input image; providing, by the computing system, the rotated cropped input image as input to a machine learning model to generate a latent space representation of the rotated cropped input image; editing, by the computing system, the latent space representation to generate an edited latent space representation; providing, by the computing system, the edited latent space representation as input to a trained generator neural network implemented by the computing system; generating, by the generator neural network, a generated edited image; applying, by the computing system, an inverse affine transformation to the generated edited image to generate a rotated generated edited image; aligning, by the computing system, an identified segment of the rotated generated edited image with an identified corresponding segment of the input image to produce an aligned rotated generated edited image; and blending, by the computing system, the aligned rotated generated edited image with the input image to generate an edited output image.
In some aspects, the method further includes identifying, by the computing system, the segment of the rotated generated edited image; and identifying, by the computing system, the corresponding segment of the input image. In some aspects, identifying the corresponding segment of the input image includes providing, by the computing system, the input image to a segmentation neural network implemented by the computing system, wherein the segmentation neural network identifies a plurality of segments including the segment of the input image.
In some aspects, the method further includes, based on the identified corresponding segment of the input image and the identified segment of the rotated generated edited image, modifying, by the computing system, a color and a contrast in the rotated generated edited image to match a color and a contrast in the input image. In some aspects, blending the aligned rotated generated edited image with the input image comprises applying, by the computing system, healing to the aligned rotated generated edited image and the input image.
In some aspects, the method further includes identifying, by the computing system, pixels corresponding to artifacts in the aligned rotated generated edited image; and applying a content-aware fill to the identified pixels of the aligned rotated generated edited image. In some aspects, the method further includes outputting, by the computing system, the edited output image to a display device for display. In some aspects, the method further includes, before cropping the input image, detecting, by the computing system, a target region of the input image for configuring the cropping.
In some embodiments, a computing system includes a processor and a non-transitory computer-readable medium comprising instructions which, when executed by the processor, perform processing comprising: applying an affine transformation to an input image to produce a rotated input image; providing the rotated input image as input to a machine learning model to generate a latent space representation of the rotated input image; editing the latent space representation to generate an edited latent space representation; providing the edited latent space representation as input to a trained generator neural network implemented by the computing system; generating, by the generator neural network, an edited generated image; applying an inverse affine transformation to the generated edited image to generate a rotated generated edited image; aligning an identified segment of the rotated generated edited image with an identified corresponding segment of the input image to produce an aligned rotated generated edited image; and blending the aligned rotated generated edited image with the input image to generate an edited output image.
In some embodiments, a non-transitory computer-readable medium has instructions stored thereon, the instructions executable by a processing device to perform operations comprising: cropping an input image around a region to be edited to produce a cropped input image; applying an affine transformation to the cropped input image to produce a rotated cropped input image; providing the rotated cropped input image as input to a machine learning model to generate a latent space representation of the rotated cropped input image; editing the latent space representation to generate an edited latent space representation; providing the edited latent space representation as input to a trained generator neural network; generating, by the generator neural network, a generated edited image; and a step for blending the generated edited image with the input image such that an identified segment of the generated edited image aligns with an identified corresponding segment of the input image.
Various embodiments are described herein, including methods, systems, non-transitory computer-readable storage media storing programs, code, or instructions executable by one or more processors, and the like.
These illustrative embodiments are mentioned not to limit or define the disclosure, but to provide examples to aid understanding thereof. Additional embodiments are discussed in the Detailed Description, and further description is provided there.
The patent or application file contains at least one drawing executed in color. Copies of this patent or patent application publication with color drawing(s) will be provided by the Office upon request and payment of the necessary fee.
Features, embodiments, and advantages of the present disclosure are better understood when the following Detailed Description is read with reference to the accompanying drawings.
In the following description, for the purposes of explanation, specific details are set forth in order to provide a thorough understanding of certain embodiments. However, it will be apparent that various embodiments may be practiced without these specific details. The figures and description are not intended to be restrictive. The word “exemplary” is used herein to mean “serving as an example, instance, or illustration.” Any embodiment or design described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other embodiments or designs.
The present disclosure describes improved image representation and editing techniques. More specifically, improved techniques are described for processing an edited image for improved detail, feature preservation, and avoidance of undesirable artifacts. When editing an image using a Generative Adversarial Network (GAN), an input image is provided as input to a machine learning model that generates a latent space representation, an N-dimensional vector representing a point in a latent space of a GAN. The latent space representation is edited (e.g., by vector addition or nonlinear modifications to the latent space representation). The edited latent space representation is then provided as input to the GAN, which generates an edited image reflecting the edits applied to the latent space representation. This process can provide high-quality results and allow fine-level control over the edits applied (e.g., for an image of a face, this process can be used to increase age by 3 years or decrease smile by 50%). However, there are inherent shortcomings to GAN-based image editing, including loss of resolution and content as well as disjointed merging between an edited region of an input image and an unedited region of the input image.
There are limitations as to the resolution of images that can be generated by the GAN (e.g., 1024×1024 pixel resolution at best). Often an input image to be edited may have a higher resolution than the GAN can replicate. To increase the active resolution of a GAN, massive amounts of computing power would be required to train higher compacity neural networks with higher resolution images, which is not possible given current hardware constraints. Even if a higher-resolution GAN were available, most consumer-level hardware such as laptop computers or smartphones cannot support the inferencing process that would be required to generate images with higher resolution (e.g., 8K resolution). Thus, GAN-based image processing commonly results in a loss of resolution, which is not acceptable for many users. The process of generating the latent space representation also tends to result in a loss of content. And, if the GAN was trained on images that do not include enough examples of a certain feature, then the GAN cannot generate such features during synthesis. For example, for images of faces, features that are uncommon in the training data may include face painting, face marks, and earrings. A generated image will then be missing such features (e.g., a facial tattoo or earrings have been removed).
Another challenge in GAN-based image editing relates to the nature of GAN input and output. The GAN is typically trained to accept as input, as well as output, an image that has been tightly cropped around a specific type of image the GAN has been trained to generate. For example, the GAN may have been trained to generate images of cats, human faces, or flowers. Any background will generally be cropped out before inputting the image to the GAN. The GAN will also generally expect the input to be at a certain angle. If the image is not at the right angle, the output may not accurately reflect the features of the input image. To address this, rotations may be applied to the input image. When the GAN generates an image, the generated image will reflect such crops and rotations, along with other alterations such as resolution loss and color changes. When introducing the cropped GAN input back into the original background, these changes will make it difficult to seamlessly blend the GAN output with the original background.
In certain embodiments, the disclosed techniques include new and improved techniques for processing images to address the noted issues. For example, techniques are described for combining an input image with an edited image generated using a GAN in order to preserve detail from the original image and/or seamlessly blend edited and unedited regions of the input image.
The following non-limiting examples are provided to introduce certain embodiments. In these examples, an image editing system processes an input image to generate a latent space representation of the image. Edits to be made to the input image may be made by editing this latent space representation of the input image (e.g., using vector arithmetic or another neural network). The edited latent space representation is provided as input to a GAN, which processes the edited latent space representation and generates an output edited image, where the edited image reflects the input image with the desired edits made to the input image. For example, an image of a human face can be edited so that the face appears to smile, look older or younger, turn the head to a different angle, and so forth.
In one example, the image editing system integrates features from an input image into an edited image to preserve detail. The image editing system provides an input image as input to a machine learning model to generate a latent space representation of an input image. The image editing system can generate the latent space representation using one or more machine learning models trained to generate a latent space representation of an input image. In one example, the machine learning model is an encoder neural network. The encoder neural network may, for example, be a feedforward encoder network trained to compress an image into a vector representation. Alternatively, or additionally, generating the latent space representation may include applying an optimizer model to minimize a loss between an image generated using an initial latent space representation and the original output image. Once the latent space representation is generated, edits may be applied to the latent space representation based on user-configured parameters (e.g., make a dog depicted in an image a different breed, change the gender of a person depicted in an image, etc.).
The image editing system provides the latent space representation of the input image as input to a trained generator neural network implemented by the computing system. As noted above, a GAN is a neural network for generating images based on latent space representations. GANs include a generator neural network that generates the images as well as a discriminator neural network used in generator training. The generator neural network generates a generated image based upon the latent space representation. The generated image looks similar to the input image, with any edits applied. The generated image may suffer from some resolution loss or detail loss. For example, a generated image of a face with a bindi and fine wrinkles may be missing the bindi and fine wrinkles due to limitations of the machine learning models and processing devices involved. Accordingly, the image editing system performs processing to integrate different levels of features from the original image back into the generated image.
The image editing system generates a first scale representation of the input image and a second scale representation of the input image. The image editing system can generate two or more representations of the input image at different scales, which can be used to incorporate different levels of features (e.g., low-level features such as lighting conditions, high-level features such as fine facial texture, and/or mid-level features such as the appearance of teeth). The image editing system can generate the different scale representations by computing pyramid representations of the input image, such as a multi-level Laplacian pyramid. Similarly, the image editing system generates a first scale representation of the generated image and a second scale representation of the generated image (e.g., by calculating a multi-level Laplacian pyramid of the generated image).
The image editing system generates combined images corresponding to the first scale representations and the second scale representations. For each scale (e.g., the first scale and the second scale), the image editing system uses a different value to control how much of the original image is blended in at that scale. For example, the image editing system generates a first combined image at a first scale. This first combined image is a function of on the first scale representation of the input image, the first scale representation of the generated image, and a first value. As a specific example, for low-level features, the first combined image is computed based on a first value, αlow, where αlow controls opacity. The first combined image is given by α1ow times the first scale representation of the input image plus (1−αlow) times the first scale representation of the generated image. The αlow value can be tuned to preserve a relatively high ratio of features from the generated image (e.g., to reflect applied global lighting edits). The image editing system generates a second combined image based on the second scale representation of the input image, the second scale representation of the generated image, and a second value different from the first value. The image editing system may implement a different value for high-level features to ensure preservation of fine textural detail such as skin pores and hair textures from the input image. For example, the second value is configured such that the second combined image is substantially equal to the second scale representation of the input image.
The image editing system then blends the first combined image with the second combined image to generate an output image. For example, the image editing system applies Laplacian blending to blend the first combined image with low-level features from the edited image with the second combined image with high-level features from the original input image. The resulting output image will retain fine details such as skin texture, while still reflecting edits applied.
In a second example, the image editing system smoothly merges a cropped image generated by a GAN with a surrounding region of an input image. The image editing system crops an input image around a region to be edited to produce a cropped input image. For example, the image editing system receives an input image to be edited, which includes a face, neck, and shoulders, along with some scenery in the background. The image editing system may apply image recognition techniques to identify the face and crop around the face to produce a square image for providing to the GAN. The image editing system further rotates the cropped input image so that the face is facing directly forward as expected by the GAN. The image editing system rotates the input image by applying an affine transformation to the cropped input image to produce a rotated cropped input image.
The image editing system provides the rotated cropped input image as input to a machine learning model to generate a latent space representation of the rotated cropped input image. As described above with respect to the first example, an encoder and/or optimizer can be implemented to generate the latent space representation. The image editing system edits the latent space representation to generate an edited latent space representation. The image editing system may apply user-configured edits (e.g., increase age, change gender, etc.) by applying linear or nonlinear modifications to the latent space representation. The image editing system provides the edited latent space representation as input to a trained generator neural network implemented by the computing system (e.g., the generator of the GAN, as described above) to generate a generated edited image.
The image editing system then applies an inverse affine transformation to the generated edited image to generate a rotated generated edited image. The parameters of the affine transformation used to rotate the input image may be inverted to rotate the generated edited image back to the original position. The image editing system aligns an identified segment of the rotated generated edited image with an identified corresponding segment of the input image to produce an aligned rotated generated image. The image editing system may identify a region for merging in each of the images, such as a neck, by applying neural network such as a segmentation neural network to each image. This establishes a region for aligning the images. The image editing system may apply additional transformations to ensure that the input image and the aligned rotated generated image align cleanly.
The image editing system blends the aligned rotated generated edited image with the input image to generate an edited output image. The image editing system may calculate a blending region between the original input image and the generated edited image (e.g., by segmenting the images to identify the neck or other areas of interest). Based on the segmented regions, the images are seamlessly blended, so that the edited region smoothly fits back into the unedited background region.
Accordingly, as described herein, certain embodiments provide improvements to computing environments by solving problems that are specific to computer-implemented image editing environments. These improvements include the use of multi-resolution representations of an input image and a generated edited image to improve the detail and resolution of an output edited image. These improvements further include using image transformation and blending techniques to achieve smooth region merging in the ultimate output image. Together or separately, these techniques significantly improve the results of image projection and editing.
Example of an Operating Environment for Image Projection and Editing
There are various ways in which the input image 106 and the edits to be made are input to the image editing system 102. In the example depicted in
In some embodiments, the editor interface 104 may include one or Graphical User interfaces (GUIs) that enable a user to provide inputs identifying the input images, identifying the edits to be made to be made, setting configuration parameters for the image editing system 102, and the like. For example, a GUI may include one or more user-selectable elements that enable a user to input images 106 to be edited. One or more GUIs provided by the editor interface 104 may include one or more upload elements for uploading content (e.g., an upload field to upload an image to be edited). In some implementations, the editor interface 104 responds to user selection of an upload element by transitioning to a view showing available files to upload, prompt a user to take a photo, or the like.
One or more GUIs provided by the editor interface 104 may also include user-selectable elements that enable a user to specify the edits or modifications to be performed. For example, a GUI may display one or more sliders that can be manipulated by the user, each slider corresponding to an attribute of the image to be edited. Other elements provided by the GUIs may include text entry fields, buttons, pull-down menus, and other user-selectable options. In certain implementations, the editor interface 104 may be part of a content editing software such as Adobe Photoshop®, which is capable of receiving and editing digital content (e.g., digital photographs or other images).
In some embodiments, the image editing system 102 and the editor interface 104 execute on a computing device, which may be used by a user. Examples of a computing device include, but are not limited to, a personal computer, a tablet computer, a desktop computer, a processing unit, any combination of these devices, or any other suitable device having one or more processors. In some other embodiments, the image editing system 102 and the editor interface 104 may operate on different computing systems, which may be communicatively coupled to each other. Examples of computer platforms and implementations that may be used to implement the image editing system 102 are depicted in
The image editing system 102 may comprise multiple subsystems, which work in cooperation to generate edited output images 150. In the embodiment depicted in
The various subsystems of the image editing system 102 can be implemented in the same computing system or different, independently operated computing systems. For example, the edit management subsystem 120 could be a separate entity from the projection subsystem 110, the image generation subsystem 130, and the training subsystem 140, or the same entity. The image editing system 102 may execute on a server separately from the editor interface 104, or other embodiments can involve the image editing system 102 being built into a software application executing the editor interface 104 on a user device.
One or more of the subsystems of the image editing system 102 include trained machine learning models or include components that use machine learning models that have been trained. For example, in the embodiment depicted in
An edit management subsystem 120 configures edits to the input image 106 using an edit configurer 122 and a feedback generator 124. A preprocessor 160 preprocesses an image so that the image has the appropriate size and content for providing to the other components of the image editing system 102. A projection subsystem 110 generates a latent space representation 113 representing the input image 106. A latent code transformer 114 generates a modified latent space representation 117 by applying one or more transformations, including the edits configured by the edit management subsystem 120, to the latent space representation 113 of the input image. An image generation subsystem 130 includes a generator 132 that generates an image according to the transformed latent space representation 117. The image generation subsystem 130 further includes a postprocessor 134 that performs postprocessing of the generated image 139 to produce the output image 150, which may be returned to the editor interface 104. In some embodiments, the training subsystem 140 trains one or more components of the latent code transformer 114 using the training data 142. In some implementations, the training subsystem 140 trains the generator 132 using a discriminator 146. In some implementations, the training subsystem 140 trains the encoder 112 and/or components of the latent code transformer 114 using one or more loss functions 144.
The edit management subsystem 120 includes hardware and/or software configured to control image edits. The edit management subsystem 120 includes an edit configurer 122 and a feedback generator 124. The edit configurer 122 receives edit parameters 108, e.g., editor-configured modification instructions, from the editor interface 104. For example, edit parameters 108 may specify that an image of a person should be modified to include red hair and glasses. The edit configurer 122 transmits an indication of the edit parameters 108 to the latent code transformer 114 of the projection subsystem 110 for further processing.
The feedback generator 124 prepares and transmits edit feedback 128 to the editor interface 104. Examples of such edit feedback 128 includes metrics showing how much an attribute is being modified (e.g., numerical values showing the selected edit parameters 108). Alternatively, or additionally, the edit feedback 128 includes preview images showing how the output image will appear given the current edit parameters.
The preprocessor 160 includes hardware and/or software configured to preprocess an input image 106. The preprocessor 160 may prepare the input image 106 for processing by the projection subsystem 110 and/or generator 132. The preprocessor may crop and/or resize the input image 106. The preprocessor may further rotate the input image 106.
The projection subsystem 110 includes hardware and/or software configured to identify and transform latent space representations of images. The projection subsystem 110 receives as input the input image 106 and generates as output a modified latent space representation of the input image 117, which is a vector string of numbers reflecting edits to be applied to the input image 106.
In some implementations, the projection subsystem 110 includes an encoder 112 configured to receive an input image 106, project the input image 106 into a latent space representation 113, and output the latent space representation 113. The projection subsystem 110 further includes and a latent code transformer 114 for performing modifications to the latent space representation 113 to generate a modified latent space representation 117.
In some implementations, the encoder 112 is a machine learning model that has been trained to discover a latent space representation of the input image 106. The latent space representation (also referred to as semantic latent code or latent code) is a string of numbers (e.g., a n-dimensional vector, containing a value for each of the n-dimensions) that, when provided as input to the generator, creates a particular image (e.g., to replicate the input image 106). The encoder 112 is a machine learning model trained to generate such a latent space representation. The encoder 112 may, for example, be a neural network trained to encode the input image 106. Given an input image 106 and a generator 132, the encoder discovers a latent space representation of the input image w, such that when the latent space representation of the input image w is input to the generator 132, the resulting generated image 139 perceptually resembles the target input image 106. In some implementations, the encoder 112 is a feed forward neural network.
The latent code transformer 114 includes functionality to optimize and/or edit the latent space representation 113 to generate the modified latent space representation 117. In some aspects, the latent code transformer 114 includes an optimizer 114A, a mapper 114B, an augmenter 114C, and a latent code editor 114D.
The optimizer 114A includes functionality to optimize the latent space representation of an input image. In some aspects, the optimizer 114A takes an initial latent space representation and optimizes the latent space representation according to one or more loss functions. The loss is minimized to modify the latent space representation 113 to increase the similarity between the ultimate output image 150 and the original input image 106.
The mapper 114B includes functionality to map the latent space representation 113 from one latent space to another. For example, the encoder 112 and/or optimizer 114A generates a latent code in a first space, Z space, and the mapper 114B applies a mapping to transform the latent code from the Z space to a second space, W space. This mapping is executed in some implementations to facilitate image editing by transforming the latent space such that movement in the latent space smoothly correlates with changes to one or more target attributes. As an example, in the W space, incrementing the latent variable in a particular direction continuously makes hair color lighter in an image while maintaining the overall look of the image. In the Z space, such smooth changes with direction in the latent space are not always possible, as the Z space is more “entangled.” W space transformation techniques and advantages are described in Karras et al., “A Style-Based Generator Architecture for Generative Adversarial Networks”, https://arxiv.org/pdf/1812.04948.pdf (2019) (“StyleGAN”) and Shen et al., InterFaceGAN: Interpreting the Disentangled Face Representation Learned by GANs, arXiv:2005.09635 (2020).
The augmenter 114C includes functionality to augment the latent space representation 113 from one dimensionality to another (e.g., to an extended latent space, also referred to as “W-plus” or “Wp” space). For example, the augmenter 114C transforms W space latent code, which is 512 dimensions, to Wp space latent code, which is 512×18 dimensions. This facilitates image editing based on continuous properties of the latent space. Wp space transformation techniques and advantages are described in Abdal et. al., “Image2StyleGAN: How to Embed Images Into the StyleGAN Latent Space?,” arXiv:1904.03189 (2019).
The latent code editor 114D applies changes to the latent space representation 113 (e.g., after optimization performed by the optimizer 114A), based upon edit parameters received from the edit configurer 122. For example, the latent code editor 114D applies linear and/or nonlinear modifications to the latent space representation based on training indicating that these modifications will cause a desired change in the ultimate output image (e.g., to make a person depicted in an image appear to smile, be older, etc.).
Thus, the latent space representation 113 generated by the encoder 112 is processed by one or more components of the latent code transformer 114 to generate the modified latent space representation 117, which is passed to the image generation subsystem 130 for further processing.
In some embodiments, the image generation subsystem 130 includes hardware and/or software configured to generate an output image 150 based on input code (e.g., the modified latent space representation 117). The image generation subsystem includes a generator 132 and a postprocessor 134.
The generator 132 includes a machine learning model which has been trained to generate a generated image 139 based on input latent code. In some implementations, the generator 132 is a neural network. The generator 132 is pre-trained to generate data that is similar to a training set. Depending on the type of image to be edited by the image editing system 102, the generator may be trained to generate an image of a human face, a landscape, a dog, a cat, a shoe, and so forth. In some aspects, the generator 132 is trained to generate a specific type of image, as such targeted training can produce very realistic results. The generator 132 can produce a random new image (e.g., of a person that does not exist) based on random input (e.g., from a normal or Gaussian distribution). The generator can produce a new image that looks like an input image 106 using the techniques described herein and an input latent code that is generated based on the input image 106. In some implementations, the generator 132 is part of a Generative Adversarial Network (GAN) 138, and is trained in a zero-sum game with the discriminator 146.
In some embodiments, the postprocessor 134 ingests the generated image 139 and performs processing to prepare the output image 150. In some aspects, the projection subsystem 110 projects a portion of the input image 106 (e.g. a cropped region such as a face or a flower from within a larger image). In such cases, the generated image 139 is a subset of the input image 106, and the postprocessor 134 integrates the generated image 139 into the remaining portion of the input image 106 to generate the output image 150. Other postprocessing performed by postprocessor 134 may include smoothing portions of the generated image 139, increasing or decreasing the pixel size of the generated image 139, and/or combining multiple generated images 139.
The landmark detector 202 receives an input image 106 and a generated image 139 (e.g., an edited generated image with edits applied). For each of the input image 106 and the generated image 139, the landmark detector 202 identifies landmarks within the image. For example, in the case of images of human faces, the landmark detector 202 identifier identifies 66 key points on the face. The landmarks may, for example, be identified using a trained neural network.
The warper 204 receives an input image 106 with detected landmarks and a generated image 139 with detected landmarks from the landmark detector 202. The warper 204 warps one of the images to align the landmarks in the input image 106 with the landmarks in the generated image 139. For example, the warper 204 warps the input image 106 to align the landmarks detected therein with the landmarks detected in the generated image 139.
The scaler 206 generates multiscale representations of the input image 106 and the generated image 139. In some implementations, the scaler 206 takes as input the warped input image 106 and the generated image 139 for generating the multiscale representations. Alternatively, or additionally, the scaler 206 takes as input the input image 106 (without landmark detection or warping) and the generated image 139 for generating the multiscale representations. In some implementations, the scaler 206 generates the multiscale representations by generating a Laplacian pyramid of the input image and generating a Laplacian pyramid of the generated image. Alternatively, or additionally, the scaler 206 may generate the multiscale representations using other suitable techniques such as Gaussian pyramids or Multiscale Approximation (MSA). The multiscale representations may include a first scale representation of the input image, a first scale representation of the edited generated image, a second scale representation of the input image, and a second scale representation of the edited generated image. In some implementations, the multiscale representations further include a third scale representation of the input image, a third scale representation of the generated image, and/or additional scale representations of the edited generated image and input image. Each scale corresponds to a different level of features such as low-level details, mid-level details, and high-level details.
The combiner 208 combines the multiscale representations generated by the scaler 206. The combiner 208 generates combined images for each level of scaled images. For example, the combiner 208 generates a first combined image based on the first scale representation of the input image 106 and the first scale representation of the generated image 139. The combiner 208 also generates a second combined image based on the second scale representation of the input image 106 and the second scale representation of the generated image 139. The combiner 208 may generate additional generated images for additional scales, including a third combined image based on the third scale representation of the input image 106 and the third scale representation of the generated image 139. The combiner may apply different values and functions for controlling the strength of the generated image 139 and the input image 106 at each level, as described herein.
The blender 210 blends multiscale representations and/or regions of an image to create a smooth transition. In some embodiments, the blender 210 receives as input the combined multiscale images from the combiner and blends the combined multiscale images together. The blender 210 may apply Laplacian blending techniques to blend together a first combined image corresponding to a first scale, a second combined image corresponding to a second scale, and so forth.
The masker 211 applies a mask to a region of an image. For example, regions of the input image that are not edited are identified and masked to avoid unwanted changes. The masker 211 may further coordinate with the segmenter 214 to identify regions for masking. The masker 211 may then apply a mask to the identified region(s) to produce a masked image. The masker 211 transmits the masked image to the blender 210 for additional blending.
The transformer 212 applies transformations to rotate or otherwise transform part of an image. In some embodiments, the transformer 212 applies an affine transformation to rotate a portion of an input image to an orientation expected by the generator 132. The transformer 212 further applies an inverse affine transformation to rotate a corresponding portion of the image generated by the generator to rotate the portion of the generated image back to the original position. For example, a head is turned as shown in
The segmenter 214 identifies one or more segments of the edited generated image and the input image. In some embodiments, the segmenter 214 inputs the images to a segmentation neural network to identify segments such as eyes, nose, mouth, hair, neck, etc. The segmenter identifies a region for merging the edited generated image with the input image based on an identified segment of the edited generated image and a corresponding segment of the input image. For example, to merge an edited face back with the rest of the body that is unedited, the segmenter identifies the neck segment in each of the edited generated image and the original input image.
The aligner 216 aligns the edited generated image with the input image at the regions identified by the segmenter 214. The aligner may calculate a center of mass of each of an identified region of the edited generated image and a corresponding region of the input image. The aligner 216 may then coordinate with the transformer 212 to apply transformations to align the edited generated image and the input image at the center of mass.
In some embodiments, the blender 210 receives as input the aligned rotated generated edited image and the input image and blends these images together. The blending process can include adjusting colors and contrasts to smoothly merge the aligned rotated generated edited image with the input image, applying content-aware fill to portions of the aligned rotated generated image affected by the rotation, and/or applying healing.
Returning to
The data storage unit 141 can be implemented as one or more databases or one or more data servers. The data storage unit 141 includes training data 142 that is used by the training subsystem 140 to train the engines of the image editing system 102. The training data 142 may include real images, synthetic images (e.g., as generated by the GAN), and/or latent space representations of the real and synthetic images.
Example Techniques for Image Editing with Improved Resolution and Detail
In some embodiments, before the processing of the process 300, the image editing system obtains an input image. For example, the image editing system receives an input image that is uploaded via the editor interface 104. The input image may be an image file that is to be edited (e.g., to change facial expression or age, to change lighting, and so forth). Alternatively, or additionally, the projection subsystem may obtain the input image by retrieving the image from a local or remote database.
At 302, the projection subsystem provides the input image as input to a machine learning model to generate a latent space representation of the input image. The projection subsystem may provide the input image as input to one or more machine learning models trained to generate latent space representations of images.
In some implementations, the machine learning model is an encoder. The encoder receives the input image as input, and is trained to output a latent space representation of the input image. For example, the encoder is a neural network that generates a latent space representation z of the input image in Z space, as described above with respect to
Alternatively, or additionally, the machine learning model is an optimizer (e.g., the Limited-memory Broyden-Fletcher-Goldfarb-Shanno algorithm (L-BFGS) or another suitable optimizer). The projection subsystem provides the input image and an initial latent code to the optimizer as input. This input latent code may either be a random latent code sampled from the latent space (e.g., according to a Gaussian distribution) or an initial latent space representation of the input image generated by the encoder. A loss function is selected. The loss function may include one or more components. For example, the loss function may include a pixel loss component that compares an image generated from the latent code to the input image on a pixel-by pixel basis. The loss function may include additional components, such as a semantic loss component. The selected loss function, the input image, and an initial latent code are input to an optimizer, the loss is minimized, and the output is the latent space representation of the input image obtained at 202.
In some embodiments, at 304, the projection subsystem (e.g., the latent code editor of the projection subsystem) modifies the latent space representation based upon edit parameters. Edit parameters may, for example, be received via user input. As a specific example, a user may interact with sliders in a user interface to increase the age, amount of smile, tilt of the head, etc. in an image of a face. The projection subsystem can modify the latent space representation by applying linear or nonlinear modifications to the latent space representation of the input image. As an example, based on the topology of the Wp space, a vector is discovered which, when added to the latent space representation, modifies the latent space representation such that the ultimate output image has a targeted modification (e.g., the edit parameters are reflected in the output image). For example, an image of a face is edited so that the face is smiling in the output image, or the person appears older, etc. The modifications apply edits to the latent space representation of the input image, and the edits are reflected in the ultimate output image generated at 322.
At 306, the image editing system (e.g., the image generation subsystem) provides the latent space representation as input to a generator neural network. For example, the projection subsystem transmits the edited latent space representation of the input image generated at 304 to the image generation subsystem. The image generation subsystem provides the edited latent space representation as input to a generator neural network (e.g., the generator 132 shown in
At 308, the generator neural network generates a generated image based upon the latent space representation. The generator neural network generates an image, which is similar to the original input image, (with the applied edits, if applicable) as output. Techniques for image generation with a generative model are described in detail in, e.g., Goodfellow et al., Generative Adversarial Nets, NIPS 2014, arXiv:1406.2661v1 (2014) and Karras et al. (2019) (StyleGAN, supra).
At 310, the image editing system (e.g., the landmark detector 202 of the postprocessor 134 shown in
At 312, the image editing system (e.g., the warper 204 of the postprocessor 134 shown in
The image editing system warps the input image to move the points detected in the input image to corresponding points in the generated image. Given the model output generated image as a template, a structural deformation of the input image is applied so that the landmarks align. For example, as illustrated in
At 314, the image editing system (e.g., the scaler 206 of the postprocessor 134 shown in
To generate the first scale representation of the input image and the second scale representation of the input image, the image editing system generates a multiscale representation of the input image, which includes two or more representations at different scales. In some aspects, more than two scale representations of the input image are generated. For example, the image editing system generates a third scale representation of the input image. In some implementations, to generate the multiscale representations of the input image, the image editing system generates a pyramid representation of the input image by subsampling the image at different rates. Generating a pyramid representation results in a set of images at different scales (e.g., different sizes and/or resolutions).
In some implementations, generating the first scale representation of the input image and the second scale representation of the input image includes calculating a Laplacian pyramid of the input image. To generate a Laplacian pyramid, the image editing system applies one or more low-pass filters to an image, then subtracts the resulting low-pass filtered copy of the image from the input image, resulting in a compressed version of the input image. This can be used to separate out different levels of features in the input image. This process can be iterated to generate successively lower scale images. (See, e.g., Burt and Adleson, “The Laplacian Pyramid as a Compact Image Code,” IEE Transactions on Communications 31:4, pp. 532-540 (1983)). For example, the image editing system splits the input image into a low-level or coarse pyramid, a medium-level pyramid, and/or a high-level fine pyramid. This separates coarser parts of the image content from medium and/or fine level details of the image content. Coarse content (e.g., low-level features) corresponds to elements like the general lighting effect of the image. Medium content (e.g., mid-level features) corresponds to mid-level image details like teeth or wrinkles on skin. Fine detail (e.g., high-level features) includes skin textures and hair textures. Using a pyramid technique such as a Laplacian pyramid, these levels of details are separated out into the first scale and second scale (and potentially third scale or additional scales) representations of the input image.
Alternatively, or additionally, other multi-scale imaging techniques can be implemented, such as Gaussian pyramids (see Bert And Adelson, supra), steerable pyramids (see Karasaridis and Simoncelli, “A Filter Design Technique for Steerable Pyramid Image Transforms,” Proc. Int'l Conf Acoustics Speech Signal Processing (ICASSP IV, pp. 2387-2390 (1996)), and Multiscale Approximation (MSA) (see Dahlke et al., “Multiscale Approximation,” Understanding Complex Systems (2007)), or the like.
At 316, the image editing system generates a first scale representation of the generated image and a second scale representation of the generated image. The image editing system can generate the first and second scale representations of the generated image by computing a Laplacian pyramid of the generated image or using other multiscale representation techniques, as described above with respect to block 314. In this case, the generated image generated at 308 is used as the input to the multiscale representation process, and the output is a first scale representation of the generated image and a second scale representation of the generated image. Additional scale representations of the generated image may be computed in some embodiments (e.g., a third scale representation of the generated image, a fourth scale representation of the generated image, etc.).
In some embodiments, the image editing system (e.g., the masker 211 of the postprocessor 134) masks a region of the generated image. The postprocessor may mask one or more regions of the generated image before 316. Alternatively, or additionally, the postprocessor masks one or more of the multiscale representations of the generated image (e.g., the first scale representation of the generated image, the second scale representation of the generated image, etc.). In some implementations, the postprocessor performs image segmentation to identify one or more regions for masking, as further described below with respect to 802 of
At 318, the image editing system (e.g., the combiner 208 of the postprocessor 134 shown in
As an example, the first combined image is for low-level features. The image editing system computes the combined image as:
C
low=αlow×ilow+(1−αlow)×glow [1]
where Clow is the combined image at the first scale corresponding to low-level features, αlow is the first value, ilow is the first scale representation of the input image corresponding to low-level features, and glow is the first scale representation of the generated image corresponding to low-level features. For this level, αlow is close to 1 to maintain the lighting conditions of the original image. If the edit parameters specify that the lighting should change in the edited image (e.g., in the case of slider-based editing, if the slider is changed for lighting), then the αlow value can be tuned down to a value less than one (e.g., between 0 and 0.5) in order to transfer the lighting condition of output which exists in lower levels.
At 320, the image editing system (e.g., the combiner 208 of the postprocessor 134 shown in
C
mid=(1−αmid)×mid+αmid×gmid [2]
where Cmid is the combined image at the second scale corresponding to mid-level features and imid is the second scale representation of the input image corresponding to mid-level features (e.g., the second scale representation of the warped input image). gmid is the second scale representation of the generated image corresponding to mid-level features. For mid-level features, the second value is:
αmid=α×|i −g| [3]
where i is the input image and g is the generated image. α may be set to αlow or another suitable value. This αmid value helps to avoid ghosting effects. Original details from the input image are preserved when the content of the input image is sufficiently close to the generated image. However, there are cases where the generator neural network produces a generated image with new textures, such as when smile is increased and teeth are added, or when the pose is changed and hair and an ear are added. In these cases, more mid-level features can be incorporated from the generated image (e.g., by modifying the alpha value to adjust opacity of each of the input image and the generated image).
Alternatively, or additionally, the image processing system generates a combined image for high-level features. The image editing system computes the combined image as:
Chigh=ihigh [4]
where Chigh is the combined image at the scale corresponding to high-level features and ihigh is the scale representation of the input image corresponding to high-level features. In this case the value is equal to 1 and the generated image scale representation may not be included. This is so that fine details like pores and hair texture are included in the output image. In some implementations, the high level features of equation [4] can be used in lieu of the mid-level features of equation [2]. Alternatively, the image editing system may generate three or more combined images. For example, the image editing system generates a first combined image for low-level features, a second combined image for mid-level features, and a third combined image for high-level features. The third combined image is generated based on the third scale representation of the input image, the third scale representation of the generated image, and a third value different from the first and second values (e.g., per equation [4]).
At 322, the image editing system (e.g., the blender 210 of the postprocessor 134) blends the first combined image and the second combined image to generate an output image. If there are additional combined images, these are also blended (e.g., the image editing system blends the first combined image and the second combined image with the third combined image). In some implementations, the images are blended using Laplacian blending. The image editing system performs a Laplacian blending of the first combined image and the second combined image (and any additional combined images such as the third combined image). Laplacian blending techniques are described in detail in Biwas et al., “Spatially Variant Laplacian Pyramids for Multi-Frame Exposure Fusion,” arXiv:2002.01425v1 (Feb. 2020).
One or more operations in blocks 314-322 implement a step for producing an output image based on a first combined image of a first scale representation of the input image and a first scale representation of the generated image, and a second combined image of a second scale representation of the input image and a second scale representation of the generated image. For example, at 314, the image editing system generates a first scale representation of the input image and a second scale representation of the input image. At 316, the image editing system generates a first scale representation of the generated image and a second scale representation of the generated image. At 318, the image editing system generates a first combined image based on the first scale representation of the input image, the first scale representation of the generated image, and a first value. At 320, the image editing system generates a second combined image based on the second scale representation of the input image, the second scale representation of the generated image, and a second value. At 322, the image editing system blends the first combined image and the second combined image to generate an output image.
In some embodiments, the image editing system outputs the output image for display (e.g., to the editor interface 104 shown in
Example Images for High Resolution Image Editing Process
The input image 402 is an image received by the image editing system to be edited. Landmarks have been detected in the input image 402, as indicated by the mesh overlay. The landmarks include characteristic points on the face detected in the input image 402 (e.g., as described above with respect to block 310 of
The generated image 404 is an edited image generated by the image editing system based upon the input image 402 (e.g., as described above with respect to blocks 302-308 of
The warped version of the input image 406 is the input image after it has been warped to align detected landmarks in the input image 402 with detected landmarks in the edited generated image 404, as described above with respect to block 312 of
Example Image Editing Results
The edited generated image 502 has been edited to smile. Due to the rarity of training data including features such as bindi and nose rings in the data set used to train the generator neural network, the edited generated image 502 generated using a generator neural network (e.g., as described above with respect to blocks 302-308 of
Using the techniques of
The edited generated image 602 has been edited to adjust the lighting. Due to the rarity of training data in the data set used to train the generator neural network including features such as facial markings and cornrows, the edited generated image 602 generated using a generator neural network (e.g., as described above with respect to blocks 302-308 of
Using the techniques of
Thus, the example images 500-606 illustrate how the techniques of
Smooth Region Merging Techniques
In some embodiments, before the processing of the process 700, the image editing system obtains an input image. For example, the image editing subsystem receives an input image that is uploaded via the editor interface 104. The input image may be an image file that is to be edited (e.g., to change facial expression or age, to change lighting, and so forth). Alternatively, or additionally, the image editing system may obtain the input image by retrieving the image from a local or remote database.
At 702, the image editing system (e.g., the preprocessor 160 depicted in
In some embodiments, the preprocessor identifies a target region to crop. For example, for an image containing a face, the preprocessor executes a face detection algorithm to identify a face in the image. The preprocessor may provide the input image to a neural network trained to identify a target object in an image, such as a face, an airplane, a bird, etc. Object detection techniques are described in, e.g., Zou et al., “Object Detection in 20 Years: A Survey,” arXiv:1905.05055 (2019).
At 704, the image editing system (e.g., the preprocessor 160 depicted in
In some implementations, the preprocessor rotates the cropped input image by applying an affine transform. To apply an affine transform, the preprocessor maps pixel intensity values at a given position (x1, y1) in an input image into new variables in a rotated image (x2, y2). The preprocessor computes a rotation matrix to apply the desired rotation to the cropped input image, and multiplies the cropped input image by the rotation matrix. (See, e.g., “Basics of Affine Transformation,” Neutrium, https://neutrium.net/mathematics/basics-of-affine-transformation/ (2012)).
At 706, the image editing system (e.g., the projection subsystem 110 shown in
At 708, the projection subsystem (e.g., the latent code editor of the projection subsystem) edits the latent space representation to generate an edited latent space representation. The projection system may apply linear or nonlinear modifications to the latent space representation of the rotated cropped input image based upon edit parameters, as described above with respect to block 304 of
At 710, the image editing system (e.g., the image generation subsystem) provides the latent space representation as input to a trained generator neural network to generate a generated image. The image generation is performed as described above with respect to blocks 306-308 of
In some embodiments, after 710, the image editing system performs the processing of
At 712, the image editing system (e.g., the aligner 216 of the postprocessor 134 shown in
At 714, the image editing system (e.g., the aligner 216 of the postprocessor 134 shown in
At 716, the image editing system blends the aligned rotated generated edited image with the input image to generate an edited output image. The blending process can include adjusting colors and contrasts to smoothly merge the aligned rotated generated edited image with the input image, as further described below with respect to block 808 of
One or more operations in blocks 712-716 implement a step for blending the generated edited image with the input image such that an identified segment of the generated edited image aligns with an identified corresponding segment of the input image. For example, at 712, the postprocessor applies an inverse affine transformation to the generated edited image to generate a rotated generated edited image, at 714, the postprocessor aligns an identified segment of the rotated generated edited image with an identified corresponding segment of the input image to produce an aligned rotated generated image, and at 716, the postprocessor blends the aligned rotated generated edited image with the input image to generated an edited output image.
In some embodiments, the image editing system outputs the output image for display (e.g., to the editor interface 104 shown in
At 802, the image editing system (e.g., the segmenter 214 of the postprocessor 134 of
At 804, the image editing system (e.g., the segmenter of the postprocessor 134 of
At 806, the image editing system (e.g., the transformer of the postprocessor 134 of
The transformer calculates a transformation to align the two centers of mass. The transformation may, for example, be an affine transformation, which can include rotation, translation, scale, and/or shear. (See “Basics Of Affine Transformation,” supra). The transformation is applied to the transformed generated edited image to establish a transition in the region corresponding to the segments identified at 802 and 804. For example, the centers of masses of a neck in the input image and a neck in the transformed generated edited image are aligned by applying one or more computed transformations.
In some embodiments, based on the identified segments, the image editing system computes a blending region between the segments identified at 802 and 804. For example, the blending region is computed as:
B=S
i1
+S
g1
+S
i2
+S
g2
where B is the blending region, Si1 is a first segment of the input image (e.g., corresponding to the face in an image of a face), Sg1 is a first segment of the rotated generated edited image (e.g., corresponding to the face), Si2 is a second segment of the input image (e.g., the neck), and Sg2 is a second segment of the generated image (e.g., the neck).
At 808, the image editing system (e.g., the blender of the postprocessor 134 of
At 810, the image editing system (e.g., the blender of the postprocessor 134 of
At 812, the image editing system (e.g., the blender of the postprocessor 134 of
In some implementations, the image editing system further performs global color matching between the input image and the rotated generated edited image. Due to biases in the training data, skin color may inadvertently be modified in a generated edited image (e.g., skin color becomes lighter as age increases). The image editing system performs a global color match between the input image and the rotated generated edited image to adjust the skin tone and correct such inadvertent changes to skin color.
The operations of
Example Images Illustrating Smooth Region Merging
Example of a Computing System for GAN Based Image Processing
Any suitable computing system or group of computing systems can be used for performing the operations described herein. For example,
The depicted examples of a computing system 1200 includes a processor 1202 communicatively coupled to one or more memory devices 1204. The processor 1202 executes computer-executable program code stored in a memory device 1204, accesses information stored in the memory device 1204, or both. Examples of the processor 1202 include a microprocessor, an application-specific integrated circuit (“ASIC”), a field-programmable gate array (“FPGA”), or any other suitable processing device. The processor 1202 can include any number of processing devices, including a single processing device.
The memory device 1204 includes any suitable non-transitory computer-readable medium for storing data, program code, or both. A computer-readable medium can include any electronic, optical, magnetic, or other storage device capable of providing a processor with computer-readable instructions or other program code. Non-limiting examples of a computer-readable medium include a magnetic disk, a memory chip, a ROM, a RAM, an ASIC, optical storage, magnetic tape or other magnetic storage, or any other medium from which a processing device can read instructions. The instructions may include processor-specific instructions generated by a compiler or an interpreter from code written in any suitable computer-programming language, including, for example, C, C++, C#, Visual Basic, Java, Python, Perl, JavaScript, and ActionScript.
The computing system 1200 may also include a number of external or internal devices, such as input or output devices. For example, the computing system 1200 is shown with one or more input/output (“I/O”) interfaces 1208. An I/O interface 1208 can receive input from input devices or provide output to output devices. One or more buses 1206 are also included in the computing system 1200. The bus 1206 communicatively couples one or more components of a respective one of the computing system 1200.
The computing system 1200 executes program code that configures the processor 1202 to perform one or more of the operations described herein. The program code includes, for example, the projection subsystem 110, the edit management subsystem 120, the image generation subsystem 130, the training subsystem 140, the editor interface 104, or other suitable applications that perform one or more operations described herein. The program code may be resident in the memory device 1204 or any suitable computer-readable medium and may be executed by the processor 1202 or any other suitable processor. In some embodiments, the projection subsystem 110, the edit management subsystem 120, the image generation subsystem 130, the training subsystem 140, and the editor interface 104 are stored in the memory device 1204, as depicted in
The computing system 1200 can access data in any suitable manner. In some embodiments, some or all of one or more of these data sets, models, and functions are stored in the memory device 1204, as in the example depicted in
In additional or alternative embodiments, one or more of these data sets, models, and functions are stored in the same memory device (e.g., one of the memory devices 1204). For example, a common computing system can host the edit management subsystem 120 and the training subsystem 140 as well as the training data. In additional or alternative embodiments, one or more of the programs, data sets, models, and functions described herein are stored in one or more other memory devices accessible via a data network.
The computing system 1200 also includes a network interface device 1210. The network interface device 1210 includes any device or group of devices suitable for establishing a wired or wireless data connection to one or more data networks. Non-limiting examples of the network interface device 1210 include an Ethernet network adapter, a modem, and the like. The computing system 1200 is able to communicate with one or more other computing devices (e.g., a computing device executing the editor interface 104 as depicted in
In some embodiments, the functionality provided by the computing system 1200 may be offered via a cloud-based service provided by a cloud infrastructure 1300 provided by a cloud service provider. For example,
In the embodiment depicted in
The code, program, or instructions may be stored on any suitable non-transitory computer-readable medium such as any electronic, optical, magnetic, or other storage device capable of providing a processor with computer-readable instructions or other program code. Non-limiting examples of a computer-readable medium include a magnetic disk, a memory chip, a ROM, a RAM, an ASIC, optical storage, magnetic tape or other magnetic storage, or any other medium from which a processing device can read instructions. The instructions may include processor-specific instructions generated by a compiler or an interpreter from code written in any suitable computer-programming language, including, for example, C, C++, C#, Visual Basic, Java, Python, Perl, JavaScript, and ActionScript. In various examples, the server computer(s) 1302 can include volatile memory, non-volatile memory, or a combination thereof.
In the embodiment depicted in
An editor interface (e.g., editor interface 104A, editor interface 104B, and editor interface 104C) may be displayed on each of the user devices user device A 1310A, user device B 1310B, and user device C 1310C. A user of user device 1310A may interact with the displayed editor interface, for example, to enter an input image and/or image edit parameters. In response, processing for image processing may be performed by the server computer(s) 1302.
General Considerations
Numerous specific details are set forth herein to provide a thorough understanding of the claimed subject matter. However, those skilled in the art will understand that the claimed subject matter may be practiced without these specific details. In other instances, methods, apparatuses, or systems that would be known by one of ordinary skill have not been described in detail so as not to obscure claimed subject matter.
Unless specifically stated otherwise, it is appreciated that throughout this specification discussions utilizing terms such as “processing,” “computing,” “calculating,” “determining,” and “identifying” or the like refer to actions or processes of a computing device, such as one or more computers or a similar electronic computing device or devices, that manipulate or transform data represented as physical electronic or magnetic quantities within memories, registers, or other information storage devices, transmission devices, or display devices of the computing platform.
The system or systems discussed herein are not limited to any particular hardware architecture or configuration. A computing device can include any suitable arrangement of components that provide a result conditioned on one or more inputs. Suitable computing devices include multi-purpose microprocessor-based computer systems accessing stored software that programs or configures the computing system from a general purpose computing apparatus to a specialized computing apparatus implementing one or more embodiments of the present subject matter. Any suitable programming, scripting, or other type of language or combinations of languages may be used to implement the teachings contained herein in software to be used in programming or configuring a computing device.
Embodiments of the methods disclosed herein may be performed in the operation of such computing devices. The order of the blocks presented in the examples above can be varied—for example, blocks can be re-ordered, combined, and/or broken into sub-blocks. Certain blocks or processes can be performed in parallel.
The use of “adapted to” or “configured to” herein is meant as open and inclusive language that does not foreclose devices adapted to or configured to perform additional tasks or steps. Additionally, the use of “based on” is meant to be open and inclusive, in that a process, step, calculation, or other action “based on” one or more recited conditions or values may, in practice, be based on additional conditions or values beyond those recited. Headings, lists, and numbering included herein are for ease of explanation only and are not meant to be limiting.
While the present subject matter has been described in detail with respect to specific embodiments thereof, it will be appreciated that those skilled in the art, upon attaining an understanding of the foregoing, may readily produce alterations to, variations of, and equivalents to such embodiments. Accordingly, it should be understood that the present disclosure has been presented for purposes of example rather than limitation, and does not preclude the inclusion of such modifications, variations, and/or additions to the present subject matter as would be readily apparent to one of ordinary skill in the art.
This application is a non-provisional application of and claims the benefit of the filing date of U.S. Provisional Application 63/092,980, filed on Oct. 16, 2020, which is herein incorporated by reference in its entirety for all purposes. This application is related to the concurrently filed application titled “Detail-Preserving Image Editing Techniques,” which is herein incorporated by reference in its entirety for all purposes. This application is also related to the U.S. patent applications Ser. Nos. 17/384,273, 17/384,283, 17/384,357, 17/384,371, and 17/384,378, filed on Jul. 23, 2021, which are herein incorporated by reference in their entirety for all purposes. This application is also related to the concurrently filed patent applications titled “Attribute Decorrelation Techniques for Image Editing,” “Attribute Control Techniques for Image Editing,” and “Non-Linear Latent Filter Techniques for Image Editing,” which are herein incorporated by reference in their entirety for all purposes.
| Number | Date | Country | |
|---|---|---|---|
| 63092980 | Oct 2020 | US |
