Patent Description:
With the increased use of digital images, affordability of portable computing devices, availability of increased capacity of digital storage media, and increased bandwidth and accessibility of network connections, digital images and video have become a part of daily life for an increasing number of people. Additionally, the expectation of device users is also that the experience of using apps on portable computing devices will continue to become more sophisticated and media-rich.

<CIT> discloses a method for producing edited images using embedded plug-in, involves modifying low resolution version of image by executing instruction associated with selected image editing tools, and displaying low resolution version of modified image.

Embodiments are illustrated by way of example, and not limitation, in the figures of the accompanying drawings in which:.

Users with a range of interests and from various locations can capture digital images of various subjects and make captured images available to others via networks, such as the Internet. To enable computing devices to perform image processing or image enhancing operations on various objects and/or features captured in a wide range of changing conditions (e.g., changes in image scales, noises, lighting, movement, or geometric distortion) can be challenging and computationally intensive.

Additionally, third-party developers of apps for use on personal devices may want to provide enhanced visual effects but may not have the know-how or the budget to provide such effects in their apps. The original developers of systems and technology to support enhanced visual effects (SDK providers) can enable the use of such effects in apps released by third-party app developers, by providing a modular software development kit (SDK) as described in more detail below. As used herein, the term "third party developer," "app developer" and "developer" are not limited to actual developers as such, but include persons and entities that are hosting, providing or own the relevant software, app, SDK or service that may originally have been developed by others.

In some cases, the provider of the SDK also provides a messaging application including image modification capabilities as described herein. The SDK provides a third party access to such image modification capabilities to allow the third party to offer image modification features in their app independently of launching the SDK-provider's messaging application.

As discussed herein, the subject infrastructure supports the creation, viewing and/or sharing of interactive or enhanced two or three dimensional media in apps released by app developers. The subject system also supports the creation, storage and loading of external effects and asset data by a third party developer, for use by an app running on a client device.

As described herein, images, video or other media for enhancement can be captured from a live camera or can be retrieved from local or remote data storage. In one example, an image is rendered using the subject system to visualize the spatial detail / geometry of what the camera sees, in addition to a traditional image texture. When a viewer interacts with this image by moving the client device, the movement triggers corresponding changes in the perspective in which the image and geometry are rendered to the viewer.

As referred to herein, the phrase "augmented reality experience," includes or refers to various image processing operations corresponding to an image modification, filter, media overlay, transformation, and the like, as described further herein. In some examples, these image processing operations provide an interactive experience of a real-world environment, where objects, surfaces, backgrounds, lighting etc. in the real world are enhanced by computer-generated perceptual information. In this context an "augmented reality content generator" comprises the collection of data, parameters, and other assets needed to apply a selected augmented reality experience to an image or a video feed. In some examples, augmented reality content generators are provided by Snap, Inc. under the registered trademark LENSES.

In some examples, an augmented reality content generator includes augmented reality (or "AR") content configured to modify or transform image data presented within a GUI of a client device in some way. For example, complex additions or transformations to the content images may be performed using AR content generator data, such as adding rabbit ears to the head of a person in a video clip, adding floating hearts with background coloring to a video clip, altering the proportions of a person's features within a video clip, adding enhancements to landmarks in a scene being viewed on a client device or many numerous other such transformations. This includes both real-time modifications that modify an image as it is captured using a camera associated with the client device, which is then displayed on a screen of the client device with the AR content generator modifications, as well as modifications to stored content, such as video clips in a gallery that may be modified using AR content generators. For example, in a creator profile with multiple AR content generators, an authorized third party developer may use a single video clip with multiple AR content generators to see how the different AR content generators will modify the stored clip. Similarly, real-time video capture may be used with an AR content generator to show to a user of a client device on its display how video images currently being captured by sensors of a device would modify the captured data. Such data may simply be displayed on the screen and not stored in memory, the content captured by the device sensors may be recorded and stored in memory with or without the AR content generator modifications (or both), or the content captured by the device sensors may be transmitted, with the AR content generator modification, over the network <NUM> to a server or another client device.

AR content generators and associated systems and modules for modifying content using AR content generators may thus involve detection of objects (e.g. faces, hands, bodies, cats, dogs, surfaces, objects, etc.), tracking of such objects as they leave, enter, and move around the field of view in video frames, and the modification or transformation of such objects as they are tracked. In various examples, different methods for achieving such transformations may be used. For example, some examples may involve generating a 3D mesh model of the object or objects, and using transformations and animated textures of the model within the video to achieve the transformation. In other examples, tracking of points on an object may be used to place an image or texture, which may be two dimensional or three dimensional, at the tracked position. In still further examples, neural network analysis of video frames may be used to place images, models, or textures in content (e.g. images or frames of video). AR content generator data thus may include both the images, models, and textures used to create transformations in content, as well as additional modeling and analysis information needed to achieve such transformations with object detection, tracking, and placement.

In one aspect, a method of providing a user interface by a messaging application software development kit (SDK) included with a third party resource running on a portable device including a camera and a display, includes receiving, by the SDK, an API call to display an image processing user interface, displaying on the display of the portable device, a first user interface includes a list of selectable graphical items corresponding to a group of available image modification features, receiving user selection of a desired graphical item from the list of selectable graphical items, applying image modification features corresponding to the desired graphical item to an image received from the camera to generate a modified image, and displaying, on the display of the portable device, a second user interface including the modified image.

The first or the second user interface include a logo related to a provider of the SDK. The second user interface may further include a text overlay including a name of a creator of the image modification features corresponding to the desired graphical item. The second user interface may further include a user interface element that is customizable by a developer of the third party resource and which, when selected, results in an action related to the third party resource or related to the developer of the third party resource.

A final item in the list of selectable graphical items is a logo related to a provider of the SDK. The method may also include receiving user selection of the logo, and opening a messaging application provided by the provider of the SDK. The messaging application may either be opened to a user interface in which the image modification features corresponding to the desired graphical item are active or to a profile specified by the third party resource.

The method also includes further includes receiving user selection of the logo, and opening a messaging application that is provided by a provider of the SDK to a user interface with additional image modification features that are available for selection by a user.

In one aspect, a system includes one or more processors of a machine, a camera and a display. The system also includes a memory storing instructions, including an SDK included with a third party software application, that when executed by at least one processor among the one or more processors, causes the machine to perform operations includes receiving an API call by the SDK to display an image processing user interface, displaying on the display, a first user interface includes a list of selectable graphical items corresponding to a group of available image modification features, receiving user selection of a desired graphical item from the list of selectable graphical items, applying image modification features, by the SDK, corresponding to the desired graphical item to an image received from the camera to generate a modified image, and displaying, on the display, a second user interface including the modified image.

A final item in the list of selectable graphical items is a logo related to a provider of the SDK. The method also includes receiving user selection of the logo, and opening a messaging application provided by the provider of the SDK. The messaging application may either be opened to a user interface in which the image modification features corresponding to the desired graphical item are active or to a profile specified by the third party resource.

The operations further comprise receiving user selection of the logo, and opening a messaging application that is provided by a provider of the SDK. The messaging application may either be opened to a user interface in which the image modification features corresponding to the desired graphical item are active or to a profile specified by the third party software application. The operations further comprise receiving user selection of the logo, and opening a messaging application that is provided by the provider of the SDK to a user interface with additional image modification features that are available for selection by a user.

In one aspect, a non-transitory machine-readable storage medium embodies instructions including an SDK included with a third party resource that, when executed by a portable device including a camera and a display, cause the portable device to perform operations including receiving an API call by the SDK to display an image processing user interface, displaying on the display of the portable device, a first user interface includes a list of selectable graphical items corresponding to a group of available image modification features, receiving user selection of a desired graphical item from the list of selectable graphical items, applying image modification features, by the SDK, corresponding to the desired graphical item to an image received from the camera to generate a modified image, and displaying, on the display of the portable device, a second user interface including the modified image.

The first or the second user interface may include a logo related to a provider of the SDK. The second user interface may further include a text overlay including a name of a creator of the image modification features corresponding to the desired graphical item. The second user interface may further include a user interface element that is customizable by a developer of the third party resource and which, when selected, results in an action related to the third party resource or related to the developer of the third party resource.

The operations further comprise receiving user selection of the logo, and opening a messaging application that is provided by a provider of the SDK. The messaging application may either beopened to a user interface in which the image modification features corresponding to the desired graphical item are active or to a profile specified by the third party software application. The operations further comprise receiving user selection of the logo, and opening a messaging application that is provided by the provider of the SDK to a user interface with additional image modification features that are available for selection by a user.

<FIG> is a block diagram showing an example system <NUM> for exchanging data (e.g., messages, AR content generators, media and associated content) over a network. The system <NUM> includes multiple instances of a client device <NUM>, each of which hosts a number of applications, including an app <NUM>. Each client device <NUM> may be communicatively coupled to other client devices <NUM> also running instances of the app <NUM>, an SDK server system <NUM> and a developer database <NUM>, via a network <NUM> (e.g., the Internet). The client device may also be coupled via the network to an app store from which the app <NUM> can be downloaded and installed on the client device <NUM>. The app <NUM> may be any kind of app that might be running on the client device <NUM>. It may, but need not be, the type of app that is not traditionally associated with augmented reality (AR) interactivity or effects (such as messaging or social networking apps).

The app <NUM> is able to communicate and exchange data with another app <NUM> and with the SDK server system <NUM> via the network <NUM>. The data exchanged between apps <NUM> depends on the particular app and is defined by the developer of the app, and may include text, audio, video or other multimedia data that may or may not have been modified using the systems and methods described herein. Information exchanged between an app <NUM> and the SDK server system <NUM> may include functions or commands to invoke functions, payload data (e.g., text, audio, video or other multimedia data as well as augmented reality content generator data) and performance or usage metrics. The data exchanged between the app <NUM> and the developer database <NUM> includes any data that is specific to or required by the particular app <NUM>, or is data that is specific to the user of the app and that is hosted by or for the app developer.

The system also may include a developer device <NUM> that hosts effects software <NUM> that can be used by a developer to create custom AR content generators for use with the app <NUM>. The effects software <NUM> may be provided by the SDK provider as downloadable software or a cloud service via the SDK server system <NUM>. The developer device <NUM> may also include app development software <NUM> or be used to access an app development platform for use by the developer in developing app <NUM>.

The SDK server system <NUM> includes application programming interfaces (APIs) with functions that can be called or invoked by the app <NUM> or the effects software <NUM>. In certain examples, the SDK server system <NUM> includes a JavaScript library that provides a third party developer access to certain features and assets of the SDK server system <NUM>, but applications and resources based on other technologies can be used.

In order to integrate the functions of the SDK (see further <FIG> and associated description of SDK <NUM>) into an app <NUM>, the SDK is downloaded by developer device <NUM> from the SDK server system <NUM> or is otherwise received by the developer device <NUM>. Once downloaded or received, the SDK is included as part of the application code of the app <NUM>. The code of the app <NUM> that is created by the developer can then call or invoke certain functions of the SDK to integrate image processing technology and features traditionally provided in apps released by the SDK provider.

The SDK server system <NUM> also provides server-side functionality via the network <NUM> to a particular app <NUM> and to the effects software <NUM> hosted on the developer device <NUM>. While certain functions of the system <NUM> are described herein as being performed by either an app <NUM>, the SDK server system <NUM> or the effects software <NUM>, the location of certain functionality either within the app <NUM>, the SDK server system <NUM> or the effects software <NUM> may be a design choice. For example, it may be technically preferable to initially deploy certain technology and functionality within the SDK server system <NUM> but to later migrate this technology and functionality to the app <NUM> when a client device <NUM> has sufficient processing capacity. Similarly, functionality provided by effects software <NUM> may be hosted as a web or cloud service by the SDK server system <NUM>.

The SDK server system <NUM> supports various services and operations that are provided to the app <NUM>, the effects software <NUM> and the app development software <NUM> as will be described in more detail below. Such operations include transmitting data to, receiving data from, and processing data generated by the effects software <NUM>, hosting of the modular SDK for use by the developer in conjunction with the app development software <NUM>, and the provision of AR content generators for use by the app <NUM>. The SDK, when integrated with an app developed by a third party developer, provides all the core functions needed to download, cache, and execute AR content generators built with the effects software <NUM>. Data exchanges within the system <NUM> are invoked and controlled through functions available via user interfaces (UIs) of the app <NUM> and the effects software <NUM>.

Turning now specifically to the SDK server system <NUM>, an Application Program Interface (API) server <NUM> is coupled to, and provides a programmatic interface to, application servers <NUM>. The application servers <NUM> are communicatively coupled to a database server <NUM>, which facilitates access to a database <NUM> that stores data associated with functions by the application servers <NUM>. Similarly, a web server <NUM> is coupled to the application servers <NUM>, and provides web-based interfaces to the application servers <NUM>. To this end, the web server <NUM> processes incoming network requests over the Hypertext Transfer Protocol (HTTP) and several other related protocols.

The Application Program Interface (API) server <NUM> receives and transmits data (e.g., commands and other payloads, e.g. AR content generators and associated metadata) between the client device <NUM> and the application servers <NUM> and between the developer device <NUM> and the application servers <NUM>. Specifically, the Application Program Interface (API) server <NUM> provides a set of interfaces (e.g., routines and protocols) that can be called or queried in order to invoke functionality of the application servers <NUM>. The Application Program Interface (API) server <NUM> exposes various functions supported by the application servers <NUM> as described in more detail below.

The application servers <NUM> host a number of server applications and subsystems, including for example an effects submission service <NUM>, an effects scheduler <NUM>, an SDK hosting service <NUM> and a web UI module <NUM>. The effects submission service <NUM> implements a number of technologies and functions, particularly related to the aggregation, storage of and access to AR content generators for visual effects that have been generated by a developer on the developer device <NUM> using the effects software <NUM>. As will be described in further detail, the AR content generators generated by developers may be uploaded from the developer device <NUM> to the SDK server system <NUM> where they are aggregated by the effects submission service <NUM> into collections of AR content generators, associated with individual developers and stored in database <NUM>. These collections are then made available to the app <NUM> as specified by the effects scheduler <NUM>.

The application servers <NUM> also include an effects scheduler <NUM>, which is an administrative tool that can be used by developers to manage their AR content generators. The effects scheduler <NUM> is accessed via a web-based interface, provided by web UI module <NUM>, for managing AR content generators and associated metadata. The metadata associated with each AR content generator may include an AR content generator ID (a unique identifier used for all transactions involving the AR content generator), a public AR content generator name, an AR content generator icon image, any preview media, visibility settings, preferred activation camera (e.g. front or rear-facing camera) and the date the AR content generator was last submitted through the effects software <NUM>. The associated metadata may also for example specify visibility (i.e. is the AR content generator public or private, or on or off), a "Start date" and "End date" to limit any AR content generator availability within a group, as well as advanced scheduling options, e.g. recurring times (daily, weekly, monthly, yearly). The associated metadata may also for example specify geofencing limitations, so that an AR content generator is only available in certain locations.

The web interface for accessing the effects scheduler <NUM> provides various views to a developer, including a view that has master list of all of the AR content generators associated with the developer, as well as group views, in which AR content generators in developer-defined groups will be listed. Only AR content generators created or owned by a particular developer will appear in the list of AR content generators shown when that developer accesses the effects scheduler <NUM>. Each developer and their apps <NUM> are registered under an organization name in an SDK portal (not shown) by which the developer registers with the SDK server system <NUM>.

To provide additional flexibility for development of use cases by the developer, the effects scheduler <NUM> also provides the ability to add developer data to each AR content generator or group of AR content generators, which can augment use of the AR content generator by the app <NUM>. All developer data included in the AR content generator metadata are provided to the client device <NUM> for use by the app <NUM>. This developer data could for example include search keywords, premium entitlements, additional UI guidance, or other visibility tags (e.g. "it's the birthday LENS"). This developer data is primarily intended for use in interactions between the user of the client device <NUM> and the apps <NUM>. Although not out of the question, in one example neither the effects scheduler <NUM> nor the SDK <NUM> operates on this data.

AR content generator groups provide a way for AR content generators to be collected into ordered lists for delivery to an app <NUM>, which will normally be presented visually by the app <NUM> to a user as will be described in more detail below. Since AR content generators are delivered to the app <NUM> in groups, for an AR content generator to appear in the app it needs to be associated with a group. Groups may be created and defined by the developer based on use cases, for example named "Los Angeles" and "Tokyo" for setting up different content at different locations. Each group has a specific group ID that can be used for group management.

The effects scheduler <NUM> provides an interface for creating and deleting groups, adding or removing AR content generators from individual groups and for applying additional developer data to all the AR content generators associated with a developer (global metadata), to groups of AR content generators (group metadata) and to an individual AR content generator, either directly to an AR content generator or when adding an AR content generator to a group. The global, group and individual AR content generator metadata are nested within separate keys in the metadata so the app <NUM> can choose to override metadata in one level with metadata in another level. The app <NUM> can either use or present a group of AR content generators as-is or filter the group of AR content generators based on any of the metadata associated with the AR content generators.

The effects scheduler <NUM> also receives performance and usage data from the app <NUM>. This can relate both to performance of the SDK (e.g. statistics on tracking, rendering, AR content generator initialization and teardown times, etc.) and to usage metrics for the AR content generators themselves (e.g. which AR content generators were used, when and for how long, events in the app triggered during AR content generator usage. ) This performance and usage data, as well as analytics derived, therefrom can be provided to a developer in a performance and metrics dashboard generated by the effects scheduler <NUM>.

The web UI module <NUM> supports various functions and services and makes these functions and services available to the third party developer directly and/or to the effects software <NUM>.

The SDK hosting service <NUM> provides developer access to the SDK (described in more detail below with reference to <FIG>), including any updates or patches, and any associated SDK documentation.

In use of the system <NUM>, a developer, after registering with the SDK portal, downloads the SDK from the SDK hosting service <NUM> for use in developing the app <NUM>. The SDK provides all the core functions needed to download, cache, and execute AR content generators built with the effects software <NUM>. The developer integrates the SDK into their app <NUM> using the app development software <NUM>. The app <NUM> is then made available for download by users via known means, for example via an app store.

The developer also generates AR content generators using the effects software <NUM>, which are then uploaded to the SDK server system <NUM> via the effects submission service <NUM>, where they are aggregated by the effects submission service <NUM> into a collections of AR content generators associated with the developer and stored in database <NUM>. The developer can then manage the collection of AR content generators using the effects scheduler <NUM> as discussed above, to group AR content generators and to manage AR content generator metadata. A group of AR content generators can then be downloaded to the client device <NUM> for use by the app <NUM>, either in response to a user prompt provided in the app <NUM>, by inclusion in an update of the app <NUM> or pushed from the SDK server system <NUM> in response to an instruction from the developer. Additionally, the app <NUM> may include an AR content generator or one or more groups of AR content generators when originally downloaded, e.g. from an app store.

<FIG> shows the architecture of app <NUM> of <FIG>. and its relationship to the developer database <NUM> and the SDK server system <NUM> of <FIG>. As can be seen from the figure, the app <NUM> includes app logic <NUM> and SDK <NUM> comprising an API <NUM>, SDK kit logic <NUM>, annotation system <NUM>, SDK UI <NUM> and local data storage <NUM>.

The app logic <NUM> is developer-specific and provides the functionality and user interface expected by a user of the app <NUM>. The app logic <NUM> defines and presents all visible interactive UI elements to the user of the client device <NUM> when the app <NUM> is running but the SDK <NUM> has not been called. The app logic <NUM> receives input from user input components <NUM> including for example a touch screen, camera <NUM> and microphone <NUM>. The app logic <NUM> communicates with developer database <NUM> and/or any other required information resource required for regular operation of the app <NUM>, over network <NUM>. The app logic <NUM> also provides the SDK <NUM> with access to the camera <NUM> and the microphone <NUM>.

The app logic <NUM> interacts with the SDK <NUM> via calls provided to the API <NUM>. Examples of such calls may be to get an AR content generator group, get AR content generator metadata for an AR content generator in the group, and prefetch AR content generators for caching. As far as obtaining an AR content generator group, an AR content generator or any additional AR content generator assets are concerned, "downloading" generally refers to download on demand. If something is needed but it is not available in local data storage <NUM>, it will be downloaded. "Prefetching" is predictively downloading an asset that is not available in local data storage <NUM> before it is needed, based on expected or likely interactions of the user with the app <NUM> or client device. "Caching" refers to the storage in local data storage <NUM> of all assets being downloaded or prefetched, which means that they are immediately available and also that the corresponding AR content generator can be used offline.

The SDK <NUM> receives calls and parameters from the app logic <NUM> and based thereon receives and augments the feed from the camera <NUM> in one example. The camera feed is processed by the SDK <NUM> as described in more detail below, and the rendered experience is composited into the return video feed for output and display on the client device <NUM>. In another example, based on calls and parameters received from the app logic <NUM>, the SDK <NUM> augments one or more image or video files stored on or received by client device <NUM>.

The API <NUM> is the integrating link between the app logic <NUM> and the SDK <NUM>, to permit the app logic <NUM> to access the features and services provided by the SDK <NUM>. The API <NUM> receives commands and parameters (for example, get an AR content generator group, get AR content generator metadata for an AR content generator in the group, prefetch AR content generators for caching, apply an AR content generator with a certain AR content generator ID, user inputs, AR content generator parameters etc.) from the app logic <NUM> and translates them appropriately for provision to the SDK kit logic <NUM>.

The SDK kit logic <NUM> can communicate with the SDK server system <NUM> over the network <NUM> to receive or request appropriate AR content generator assets (one or more groups of AR content generators and associate metadata) from the SDK server system <NUM> for storage in the local data storage <NUM>. SDK kit logic <NUM> also provides performance and usage data from the client device <NUM> to SDK server system <NUM> as described above. The SDK kit logic <NUM> also handles authentication between the client device <NUM> and SDK server system <NUM> for such purposes, and calls the correct endpoints to fetch AR content generator groups and associated metadata.

SDK kit logic <NUM> is also responsible for coordinating the interaction between the API <NUM>, the annotation system <NUM> and the local data storage <NUM>. In one example, the SDK kit logic <NUM> receives translated commands and parameters from the API <NUM> and provides appropriate AR content generator assets (a specified AR content generator and associate metadata), device configuration and tracking models (e.g. algorithms and parameters for performing image homography on an image sequence to detect and track objects in the feed from the camera <NUM>) from the local data storage <NUM> to the annotation system <NUM>. The SDK kit logic <NUM> also provides translated or otherwise appropriate instructions to the annotation system <NUM> based on commands or gesture inputs from the user (e.g. touches, swipes, double taps etc.) received from the API <NUM>.

The annotation system <NUM> is responsible for processing the camera feed based on a selected AR content generator and its metadata, the configuration of the device, specified tracking models, user input and sensor (e.g. positional sensor data) or other data received from or via the app logic <NUM> or directly from components making up the client device <NUM> such as the camera <NUM> or microphone <NUM>. For example, in some cases the annotation system <NUM> tracks objects based on the components or parameters within the AR content generator. Examples include face tracking (including monitoring facial action triggers like open mouth, raise eyebrows etc.), surface tracking, pet tracking, etc. The annotation system <NUM> also renders assets in the AR content generator and processes any JavaScript within the AR content generator package to execute any logic contained within the AR content generator (e.g. moving of objects, modifying colors, etc.) The annotation system <NUM> is described in more detail below with reference to <FIG>.

The SDK UI <NUM> is responsible for, in cooperation with the SDK kit logic <NUM>, presenting the user interface elements that are displayed when the SDK <NUM> has been called. The SDK UI <NUM> receives relevant data, such as user interactions, from SDK kit logic <NUM> and passes appropriate responses back to SDK kit logic <NUM>.

The SDK UI <NUM> causes display of selectable graphical items that, in an example, are presented in a carousel arrangement, as described and illustrated below with reference to <FIG>. By way of example, the user can utilize various inputs to rotate the selectable graphical items onto and off of the display screen in manner corresponding to a carousel, thereby providing a cyclic view of the graphical items. The carousel arrangement allows multiple graphical items to occupy a particular graphical area on the display screen. In an example, AR content generators can be organized into groups for including on the carousel arrangement, thereby enabling rotation through AR content generators by group.

The local data storage <NUM> is a repository for device configuration information, tracking models and AR content generator assets. If the device configuration information and tracking models are not included in the SDK <NUM> as part of the app <NUM> originally, these can be downloaded from the SDK server system <NUM> by the SDK kit logic <NUM>. Device configuration information specifies how the application of an AR content generator by the SDK <NUM> may vary based on the actual configuration of the client device <NUM>.

<FIG> is a block diagram illustrating various modules of an annotation system <NUM>, according to certain example examples. The annotation system <NUM> is shown as including an image and depth data receiving module <NUM>, a sensor data receiving module <NUM>, an image and depth data processing module <NUM>, an AR effects module <NUM>, and a rendering module <NUM>. The various modules of the annotation system <NUM> are configured to communicate with each other (e.g., via a bus, shared memory, or a switch). Any one or more of these modules may be implemented using one or more computer processors <NUM> (e.g., a set of processors provided by the client device <NUM>).

Any one or more of the modules described may be implemented using hardware alone (e.g., one or more of the computer processors <NUM> of a machine (e.g., machine <NUM>) or a combination of hardware and software. For example, any described module of the annotation system <NUM> may physically include an arrangement of one or more of the computer processors <NUM> (e.g., a subset of or among the one or more computer processors of the machine (e.g., machine <NUM>) configured to perform the operations described herein for that module. As another example, any module of the annotation system <NUM> may include software, hardware, or both, that configure an arrangement of one or more computer processors <NUM> (e.g., among the one or more computer processors of the machine (e.g., machine <NUM>) to perform the operations described herein for that module. Accordingly, different modules of the annotation system <NUM> may include and configure different arrangements of such computer processors <NUM> or a single arrangement of such computer processors <NUM> at different points in time. Moreover, any two or more modules of the annotation system <NUM> may be combined into a single module, and the functions described herein for a single module may be subdivided among multiple modules. Furthermore, according to various examples, modules described herein as being implemented within a single machine, database, or device may be distributed across multiple machines, databases, or devices.

The image and depth data receiving module <NUM> in one example receives images and depth data captured by a client device <NUM>. For example, an image may be a frame captured by an optical sensor (e.g., camera) of the client device <NUM>. An image may include one or more real-world features, such as a user's face or real-world object(s) detected in the image. In some examples, an image includes metadata describing the image. For example, the depth data may include data corresponding to a depth map including depth information based on light rays emitted from a light emitting module directed to an object (e.g., a user's face) having features with different depths (e.g., eyes, ears, nose, lips, etc.). By way of example, a depth map is similar to an image but instead of each pixel providing a color, the depth map indicates distance from a camera to that part of the image (e.g., in absolute terms, or relative to other pixels in the depth map).

The sensor data receiving module <NUM> receives sensor data from a client device <NUM>. Sensor data is any type of data captured by a sensor of the client device <NUM>. In an example, sensor data can include motion of the client device <NUM> gathered by a gyroscope, touch inputs or gesture inputs from a touch sensor (e.g., touchscreen), GPS, or another sensor of the client device <NUM> that describes a current geographic location and/or movement of the client device <NUM>. As another example, sensor data may include temperature data indicating a current temperature as detected by a sensor of the client device <NUM>. As another example, the sensor data may include light sensor data indicating whether the client device <NUM> is in a dark or bright environment.

The image and depth data processing module <NUM> performs operations on the received image and/or depth data. Various image processing and/or depth processing operations may be performed by the image and depth data processing module <NUM>. For example, the image and depth data processing module <NUM> provides the ability to track the different objects supported by the effects software <NUM>, including faces, pets, hands, bodies, skeletal joints, landmarkers (i.e. physical landmarks that can be recognized by the annotation system <NUM> and to which AR content generators can be applied for landmark-specific effects) and image markers (i.e. specific images that can be recognized by the annotation system <NUM>. ) Some of these features may require additional device data, which will be requested from the app logic <NUM> by the API <NUM> with appropriate user permission requests for protected device data like gyro, compass, and location information.

To optimize tracking, each client device <NUM> device has its own configuration profile and associated tracking models, optimized per device, for tracking different objects. The SDK kit logic <NUM> will request these if and as needed from the SDK server system <NUM>.

The AR effects module <NUM> performs various operations based on algorithms or techniques that correspond to animations and/or providing visual and/or auditory effects to the received image and/or depth data. In an example, a given image can be processed be processed by the AR effects module <NUM> to perform operations to render AR effects (e.g., including 2D effects or 3D effects using depth data) and the like, as specified by a selected AR content generator.

The rendering module <NUM> performs rendering of the image for display by the client device <NUM> based on data provided by at least one of the aforementioned modules. In an example, the rendering module <NUM> utilizes a graphical processing pipeline to perform graphical operations to render the image for display. The rendering module <NUM> implements, in an example, an extensible rendering engine that supports multiple image processing operations corresponding to respective AR content generators.

In some implementations, the rendering module <NUM> provide a graphics system that renders two-dimensional (2D) objects or objects from a three-dimensional (3D) world (real or imaginary) onto a 2D display screen. Such a graphics system (e.g., one included on the client device <NUM>) includes a graphics processing unit (GPU) in some implementations for performing image processing operations and rendering graphical elements for display.

In an implementation, the GPU includes a logical graphical processing pipeline, which can receive a representation of a 2D or 3D scene and provide an output of a bitmap that represents a 2D image for display. Existing application programming interfaces (APIs) have implemented graphical pipeline models. Examples of such APIs include the Open Graphics Library (OPENGL) API and the METAL API. The graphical processing pipeline includes a number of stages to convert a group of vertices, textures, buffers, and state information into an image frame on the screen. In an implementation, one of the stages of the graphical processing pipeline is a shader, which may be utilized as part of a particular AR content generator that is applied to an input frame (e.g., a still image or video frame). A shader can be implemented as code running on a specialized processing unit, also referred to as a shader unit or shader processor, usually executing several computing threads, programmed to generate appropriate levels of color and/or special effects to fragments being rendered. For example, a vertex shader processes attributes (position, texture coordinates, color, etc.) of a vertex, and a pixel shader processes attributes (texture values, color, z-depth and alpha value) of a pixel. In some instances, a pixel shader is referred to as a fragment shader.

It is to be appreciated that other types of shader processes may be provided. In an example, a particular sampling rate is utilized, within the graphical processing pipeline, for rendering an entire frame, and/or pixel shading is performed at a particular per-pixel rate. In this manner, a given electronic device (e.g., the client device <NUM>) operates the graphical processing pipeline to convert information corresponding to objects into a bitmap that can be displayed by the electronic device.

A 3D model of the subject or scene may also be obtained or generated for use by the examples described herein, for example by the image and depth data processing module <NUM> performing homography on the image stream received from the camera <NUM>. In some examples, an existing 3D model of a location may be downloaded from a server based on the location of the client device as reported by position components <NUM>. Such a 3D model can be combined with an AR content generator(s) within the subject system, offering additional elements of interactivity for the user of the app <NUM>.

In some examples, by using depth and image data, 3D face and scene reconstruction can be performed that adds a Z-axis dimension (e.g., depth dimension) to a traditional 2D photos (e.g., X-axis and Y-axis dimensions). This format enables the viewer to interact with the image, changing the angle/perspective in which the image is rendered by the subject system, and affecting particles and shaders that are utilized in rendering the image.

In one example, viewer interaction input comes from movement (e.g., from a movement sensor of the device displaying the image to the viewer) whilst viewing the image which in turn is translated to changes in perspective for how content, particles and shaders are rendered. Interaction can also come from onscreen touch gestures and other device motion.

<FIG> illustrates example user interfaces depicting a carousel for selecting and applying selected AR content generator data to media content (e.g., an image or video generated by the camera <NUM>), and presenting the results of the applied AR content generator in the app <NUM>, according to some examples.

In examples of such user interfaces, selectable graphical items, such as AR content generator icon <NUM>, AR content generator icon <NUM> etc. may be presented in a carousel arrangement in which a portion or subset of the selectable graphical items are visible on a display screen of a given computing device (e.g., the client device <NUM>). By way of example, the user can utilize various inputs to rotate the selectable graphical items in the carousel arrangement onto and off of the display screen, providing a cyclic view of the graphical items. The carousel arrangement as provided in the user interfaces therefore allow multiple graphical items to occupy a particular graphical area on the display screen.

In an example, respective AR or image modification experiences corresponding to different AR content generators can be organized into respective groups for including on the carousel arrangement thereby enabling the user to scroll or "rotate" through available AR content generators. Although a carousel interface is provided as an example, it is appreciated that other graphical interfaces may be utilized. For example, the AR content generator icons may be shown in a graphical list, scroll list, scroll graphic, or another graphical interface that enables navigation and/or selection. As used herein, a carousel interface refers to display of graphical items in an arrangement similar to a circular list, thereby enabling navigation, based on user inputs (e.g., touch or gestures), through the circular list to select or scroll through the graphical items. In an example, a set of graphical items may be presented on a horizontal (or vertical) line or axis where each graphical item is represented as a particular thumbnail image (or icon, avatar, and the like).

At any one time, some of the graphical items in the carousel interface may be hidden. If the user wants to view the hidden graphical items, in an example, the user may provide a user input (e.g., swipe or other touch gesture, and the like) to scroll through the graphical items in a particular direction (e.g., left, right, up, or down, and the like). In response to the user input, an updated view of the carousel interface is displayed via an animation that presents one or more additional graphical items for inclusion on the interface, and in which some of the previously presented graphical items may be hidden. In one example, in this manner the user can navigate through the set of graphical items back and forth in a circular fashion. Thus, it is appreciated that the carousel interface can optimize screen space by displaying only a subset of graphical items from a set of graphical items, in a scrollable view. In some cases the carousel is continuous (graphical items leaving one side are able to re-enter the other side) or has defined beginning and end points (there are first and last graphical elements beyond which the carousel will not scroll.

As described herein, AR content generator icons are included on the carousel arrangement (or another interface as discussed above) thereby enabling rotation through and selection of one of the AR content generators. As discussed in more detail above, the AR content generator icons shown in the carousel arrangement correspond to a group of available AR content generators that has been curated and filtered according to metadata, which may define times or places of AR content generator availability. In the carousel arrangement of the user interface examples of <FIG>, the AR content generator icons shown in the carousel arrangement are from the available AR content generators provided by the app <NUM>.

As illustrated in user interfaces shown in <FIG>, selectable AR content generator icons <NUM> and <NUM> are displayed in a carousel <NUM> on the display screen of an electronic device (e.g., the client device <NUM>). In one example, a left or right swipe gesture is received along the carousel <NUM> via a touch screen of the client device <NUM>, and in response to receiving the swipe gesture, left or right movement of the items in the carousel is enabled to facilitate selection of a particular AR content generator corresponding to one of the AR content generator icons <NUM>, <NUM>. The desired AR content generator icon (e.g. AR content generator icon <NUM>) is then selected either via a touch input by the user over the AR content generator icon of interest, or by scrolling through the carousel and stopping when the desired AR content generator icon is located in the central position <NUM>, as can be seen in user interface <NUM>. Carousel parameters can also be defined by the provider of the SDK and/or the developer of the app. For example, it may be specified that the maximum number of AR content generator icons in a carousel is a certain number, for example <NUM>.

The user interface <NUM> corresponds to an initial screen that is shown in response to a call to the SDK <NUM> by the app logic <NUM> in which an AR content generator is not active, as can be seen by the lack of an AR content generator icon in the central position <NUM>. That is, the view of the user captured by the camera <NUM> and displayed on the display screen of the client device <NUM> is unadorned. The user interface <NUM> also includes a logo <NUM> corresponding to either the provider of the SDK or to an application (e.g. a messaging application) provided by the provider of the SDK. Also included are a front/rear camera flip icon <NUM> and a flash-enable icon <NUM> with which the user can interact to swap between a front and rear camera and to enable different flash modes as is known in the art. The user interface <NUM> also includes a close and return icon <NUM> on which the user can tap or swipe downward to dismiss the user interface <NUM> and return to a user interface provided by the app <NUM>.

In the second example of <FIG>, as shown in user interface <NUM>, upon selection of a particular AR content generator icon, which now occupies the central position <NUM>, AR effects <NUM> are rendered for display on the client device <NUM> in conjunction with the camera feed. In this example, the AR effects <NUM> includes a 3D object (e.g., a garland of roses as shown) and any other effects that are defined by the AR content generator corresponding to the selected AR content generator icon. Effects may include particle-based effects that are rendered spatially and that move in response to sensor information (e.g., gyroscopic data, and the like) on the viewer's electronic device (e.g., the client device <NUM>). Effects can also include color filtering and shader effects, which can or may also move in response to the sensor information. Examples of coloring filtering include a daylight effect that matches a time of day for a location corresponding to where a message is created (e.g., based on included location metadata with the message). Examples of shader effects include, but are not limited to liquid moving around the screen, glimmer effects, bloom effects, iridescent effects, text effects, changing the background based on movement, etc..

Also provide in the user interface <NUM> is a carousel return icon <NUM>, which, when touched by the user, returns to the no-AR-content-generator-active state and display of user interface <NUM>.

<FIG> illustrates example user interfaces depicting optional features that may be provided in the contemplated user interface. In user interface <NUM>, a text overlay <NUM> is provided that shows the name of the active AR content generator and/or the name of the its creator. Tapping the creator name allows the creator's profile to be viewed on an application (e.g. a messaging application) provided by the provider of the SDK. In addition, a product action UI element <NUM> may be provided for display and use by the developer of the app <NUM>. The contents of this element and the consequences of tapping it may be customized by the developer of the app <NUM>. For example, it may contain a product name and a link to a web-page or to another part of the app <NUM> relating to the product.

User interface <NUM> may be displayed if the logo <NUM> is tapped. Tapping this logo provides a response that is related to the provider of the SDK or that is related to an app or service provided by same. In this example, tapping on the logo <NUM> results in dialog boxes <NUM> being presented to the user. In the illustrated example, the user of the app <NUM> is provided with a choice of opening a messaging application in its default view with the AR content generator active or to view the app developer's profile in the messaging application. The profile to be viewed when choosing the latter option may be set by the developer, and could for example also be the AR content generator creator's profile. Also included is a cancel button, which will return the user interface to the previous interface, for example user interface <NUM> or user interface <NUM>.

<FIG> illustrates example user interfaces that may result from further user actions. In user interface <NUM>, the user of the app <NUM> has scrolled the carousel <NUM> to the left until there are no more available AR content generators to be shown. In such a case, a logo icon <NUM> is shown as the final option, with the text "More LENSES" underneath. Tapping the logo icon <NUM> takes the user to a repository of additional AR content generators that can be used, for example at an app store or in an application (e.g. a messaging application) or AR content generator store provided by the provider of the SDK. Whether or not the logo icon <NUM> is displayed at the end of the carousel <NUM> may also depend on various parameters than can be defined by the developer of the SDK and/or the developer of the app. For example, it may be specified that the logo icon <NUM> only applies to carousels having more than <NUM> AR content generators. In one example, the carousel <NUM> does not permit further scrolling to the left after the final icon (logo icon <NUM> in user interface <NUM>) has appeared in the carousel <NUM>. Alternatively, further scrolling to the left by the user will continue the carousel <NUM> at the first icon in the carousel, at the central position <NUM>, or return to the user interface <NUM>.

User interface <NUM> is an example of an interface that is shown after the user takes action to capture the enhanced camera feed, for example by tapping on the central position <NUM> when an AR content generator is active to capture an image, or by pressing and holding the central position <NUM> when an AR content generator is active to record a video clip. Once this user action has been completed, a representation of the modified and captured image or video clip is shown in user interface <NUM>. The user can save the image or video clip to local data storage <NUM> by tapping on save icon <NUM>, or the user can open a dialog box that provides various options for forwarding the image or video clip, as is known in the art, by tapping on the forward icon <NUM>.

Additionally, an app action icon <NUM> can be provided, with resulting steps that have been defined by the developer of the app <NUM>. For example, the user interface may return to the app's user interface where the captured image or video clip may be used or integrated with the app experience, or otherwise shared on the app platform or with other users of the app <NUM>. The user interface <NUM> also includes dismiss icon <NUM>, which discards the captured video clip or image and returns to the previous user interface, e.g. user interface <NUM>, user interface <NUM> or user interface <NUM>.

<FIG> shows a user interface that may be displayed if there is only one available AR content generator when the SDK <NUM> is called by the app logic <NUM>. In such a case, the user interface <NUM> may present immediately with the single AR content generator active and the associated AR content generator icon in the central position <NUM>. In this case, the carousel <NUM> and the carousel return icon <NUM> need not be shown since there is only one AR content generator that is active by default. Other user interface features will or may be provided as needed or preferred and as specified by the app developer, including text overlay <NUM>, product action UI element <NUM>, logo <NUM> and close and return icon <NUM>. Interacting with these features will provide the same responses as discussed above.

<FIG> is a flowchart illustrating example methods for navigating the user interfaces of <FIG>. The method commences after start operation <NUM> at operation <NUM> when the API <NUM> receives a call from the app logic <NUM> to provide image enhancement by the SDK <NUM>. In response, the SDK UI <NUM> generates and displays user interface <NUM> at operation <NUM>. The user then navigates the carousel <NUM> and selects an AR content generator icon <NUM>, <NUM> etc. corresponding to a desired AR content generator. Navigation of the carousel <NUM> in response to user input (e.g. left/right scrolling, selection of buttons or action items etc. by the user) and the resulting display of an updated user interface (e.g. as shown and described with reference in <FIG>) is performed by the SDK UI <NUM>.

Upon receipt by the SDK <NUM> of the selection of an AR content generator at operation <NUM>, SDK kit logic <NUM> obtains the AR content generator, either from local data storage <NUM> if the AR content generator has been downloaded or precached, or over network <NUM> from the SDK server system <NUM> or other server hosting the AR content generator. The SDK kit logic then provides the annotation system <NUM> with the AR content generator and any associated data, such as device configuration and tracking models. The <NUM> then processes the camera feed based on the selected AR content generator and its metadata, the configuration of the device, specified tracking models, user input and sensor (e.g. positional sensor data) or other data received from or via the app logic <NUM>, to generate and display at operation <NUM> (in conjunction with the SDK UI <NUM>), the user interface <NUM> including a camera feed that has been modified as defined by the selected AR content generator and associated data. Coordination between the SDK UI <NUM>, the annotation system <NUM>, the local data storage <NUM> and any remote servers is managed by the SDK kit logic <NUM>.

Alternatively, if the user does not select an AR content generator icon in the carousel <NUM> at operation <NUM> and operation <NUM>, but instead scrolls to the end of the carousel, the method continues from operation <NUM>.

From operation <NUM>, the product action UI element <NUM> and logo <NUM> and may be provided for display at operation <NUM> or operation <NUM> respectively, by the SDK UI <NUM>, if so defined in the selected AR content generator or as specified in an API call from the app logic <NUM>. If selection of the logo <NUM> is received at operation <NUM>, further options are displayed by the SDK UI <NUM> at operation <NUM>, as shown in user interface <NUM> and as described above with reference to <FIG>. Receipt of selection of an option (other than "Cancel") at operation <NUM> results in the SDK <NUM> opening an app (e.g. a messaging application) provided by the SKD provider at operation <NUM> in the state specified by the selected option. Alternatively, upon receipt of selection of the logo <NUM> at operation <NUM>, the SDK <NUM> may open the app provided by the SKD provider at operation <NUM> directly.

At operation <NUM>, upon return from the app that was opened in operation <NUM> (for example upon receipt of user interaction closing or dismissing the opened app), a user interface of the app <NUM> may be displayed. Alternatively, the SDK UI <NUM> may display user interface <NUM> or user interface <NUM> and the method may then continue at either operation <NUM> or operation <NUM> respectively.

At operation <NUM>, if a selection of a product action UI element <NUM> is received in response to operation <NUM>, the action associated with this UI element, as defined by the app developer, is performed at operation <NUM>. Upon completion of this action, the app <NUM> may return to user interface <NUM> or user interface <NUM>, or to an app-specific user interface.

If at either operation <NUM> or operation <NUM>, user input corresponding to scrolling to the end of the carousel is received as at operation <NUM>, the final icon in the carousel, logo icon <NUM>, is displayed by the SDK UI <NUM> at operation <NUM>. If selection of the logo icon <NUM> is received at operation <NUM>, a repository of additional AR content generators that is available for use or selection by the user is opened at operation <NUM>. This may be accomplished for example by the SDK <NUM> providing a call to an app store, or an application (e.g. a messaging application) or AR content generator store provided by the provider of the SDK. User selection of additional AR content generators will result in icons corresponding to the additional AR content generators being included by the SDK UI <NUM> in the carousel <NUM>. After obtaining or declining additional AR content generators, at operation <NUM> the method may return and user interface <NUM> or user interface <NUM> may be displayed, and the method may then continue at either operation <NUM> or operation <NUM> respectively.

Additionally, from operation <NUM>, an image or video capture input may be received at operation <NUM>. In response, the SDK UI <NUM> may display user interface <NUM> at operation <NUM>, including presenting the save icon <NUM>, forward icon <NUM>, app action icon <NUM> and dismiss icon <NUM>. If selection of the app action icon <NUM> is received at operation <NUM>, action(s) that have been defined by the developer of the app <NUM> are performed at operation <NUM>. For example, a user interface defined by app logic <NUM> may be presented, where the captured image or video clip may be used or integrated with the app experience, or otherwise shared on the app platform or with other users of the app <NUM>. In the event that there is a return to the method at operation <NUM> from the app action performed in <NUM> in response to user input, the method proceeds at one of the user interfaces, e.g. user interface <NUM>, user interface <NUM> or user interface <NUM> for example.

<FIG> is a diagrammatic representation of the machine <NUM> within which instructions <NUM> (e.g., software, a program, an application, an applet, an app, or other executable code) for causing the machine <NUM> to perform any one or more of the methodologies discussed herein may be executed. For example, the instructions <NUM> may cause the machine <NUM> to execute any one or more of the methods described herein. The instructions <NUM> transform the general, non-programmed machine <NUM> into a particular machine <NUM> programmed to carry out the described and illustrated functions in the manner described. The machine <NUM> may operate as a standalone device or may be coupled (e.g., networked) to other machines. In a networked deployment, the machine <NUM> may operate in the capacity of a server machine or a client machine in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine <NUM> may comprise, but not be limited to, a server computer, a client computer, a personal computer (PC), a tablet computer, a laptop computer, a netbook, a set-top box (STB), a personal digital assistant (PDA), an entertainment media system, a cellular telephone, a smartphone, a mobile device, a wearable device (e.g., a smartwatch), a smart home device (e.g., a smart appliance), other smart devices, a web appliance, a network router, a network switch, a network bridge, or any machine capable of executing the instructions <NUM>, sequentially or otherwise, that specify actions to be taken by the machine <NUM>. Further, while only a single machine <NUM> is illustrated, the term "machine" shall also be taken to include a collection of machines that individually or jointly execute the instructions <NUM> to perform any one or more of the methodologies discussed herein. The machine <NUM>, for example, may comprise the client device <NUM> or any one of a number of server devices forming part of the SDK server system <NUM>. In some examples, the machine <NUM> may also comprise both client and server systems, with certain operations of a particular method or algorithm being performed on the server-side and with certain operations of the particular method or algorithm being performed on the client-side.

The machine <NUM> may include processors <NUM>, memory <NUM>, and input/output I/O components <NUM>, which may be configured to communicate with each other via a bus <NUM>. In an example, the processors <NUM> (e.g., a Central Processing Unit (CPU), a Reduced Instruction Set Computing (RISC) Processor, a Complex Instruction Set Computing (CISC) Processor, a Graphics Processing Unit (GPU), a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Radio-Frequency Integrated Circuit (RFIC), another processor, or any suitable combination thereof) may include, for example, a processor <NUM> and a processor <NUM> that execute the instructions <NUM>. The term "processor" is intended to include multi-core processors that may comprise two or more independent processors (sometimes referred to as "cores") that may execute instructions contemporaneously. Although <FIG> shows multiple processors <NUM>, the machine <NUM> may include a single processor with a single-core, a single processor with multiple cores (e.g., a multi-core processor), multiple processors with a single core, multiple processors with multiples cores, or any combination thereof.

The I/O components <NUM> may include a wide variety of components to receive input, provide output, produce output, transmit information, exchange information, capture measurements, and so on. The specific I/O components <NUM> that are included in a particular machine will depend on the type of machine. For example, portable machines such as mobile phones may include a touch input device or other such input mechanisms, while a headless server machine will likely not include such a touch input device. It will be appreciated that the I/O components <NUM> may include many other components that are not shown in <FIG>. In various examples, the I/O components <NUM> may include user output components <NUM> and user input components <NUM>. The user output components <NUM> may include visual components (e.g., a display such as a plasma display panel (PDP), a light-emitting diode (LED) display, a liquid crystal display (LCD), a projector, or a cathode ray tube (CRT)), acoustic components (e.g., speakers), haptic components (e.g., a vibratory motor, resistance mechanisms), other signal generators, and so forth. The user input components <NUM> may include alphanumeric input components (e.g., a keyboard, a touch screen configured to receive alphanumeric input, a photo-optical keyboard, or other alphanumeric input components), point-based input components (e.g., a mouse, a touchpad, a trackball, a joystick, a motion sensor, or another pointing instrument), tactile input components (e.g., a physical button, a touch screen that provides location and force of touches or touch gestures, or other tactile input components), audio input components (e.g., a microphone), and the like.

The environmental components <NUM> include, for example, one or cameras (with still image/photograph and video capabilities), illumination sensor components (e.g., photometer), temperature sensor components (e.g., one or more thermometers that detect ambient temperature), humidity sensor components, pressure sensor components (e.g., barometer), acoustic sensor components (e.g., one or more microphones that detect background noise), proximity sensor components (e.g., infrared sensors that detect nearby objects), gas sensors (e.g., gas detection sensors to detection concentrations of hazardous gases for safety or to measure pollutants in the atmosphere), or other components that may provide indications, measurements, or signals corresponding to a surrounding physical environment.

With respect to cameras, the client device <NUM> may have a camera system comprising, for example, front cameras on a front surface of the client device <NUM> and rear cameras on a rear surface of the client device <NUM>. The front cameras may, for example, be used to capture still images and video of a user of the client device <NUM> (e.g., "selfies"), which may then be augmented with augmentation data (e.g., filters) described above. The rear cameras may, for example, be used to capture still images and videos in a more traditional camera mode, with these images similarly being augmented with augmentation data. In addition to front and rear cameras, the client device <NUM> may also include a <NUM>° camera for capturing <NUM>° photographs and videos.

Further, the camera system of a client device <NUM> may include dual rear cameras (e.g., a primary camera as well as a depth-sensing camera), or even triple, quad or penta rear camera configurations on the front and rear sides of the client device <NUM>. These multiple cameras systems may include a wide camera, an ultra-wide camera, a telephoto camera, a macro camera and a depth sensor, for example.

The position components <NUM> include location sensor components (e.g., a GPS receiver component), altitude sensor components (e.g., altimeters or barometers that detect air pressure from which altitude may be derived), orientation sensor components (e.g., magnetometers), and the like.

Communication may be implemented using a wide variety of technologies. The I/O components <NUM> further include communication components <NUM> operable to couple the machine <NUM> to a network <NUM> or devices <NUM> via respective coupling or connections. For example, the communication components <NUM> may include a network interface Component or another suitable device to interface with the network <NUM>. In further examples, the communication components <NUM> may include wired communication components, wireless communication components, cellular communication components, Near Field Communication (NFC) components, Bluetooth® components (e.g., Bluetooth® Low Energy), Wi-Fi® components, and other communication components to provide communication via other modalities. The devices <NUM> may be another machine or any of a wide variety of peripheral devices (e.g., a peripheral device coupled via a USB).

The instructions <NUM> may be transmitted or received over the network <NUM>, using a transmission medium, via a network interface device (e.g., a network interface component included in the communication components <NUM>) and using any one of several well-known transfer protocols (e.g., hypertext transfer protocol (HTTP)). Similarly, the instructions <NUM> may be transmitted or received using a transmission medium via a coupling (e.g., a peer-to-peer coupling) to the devices <NUM>.

The operating system <NUM> manages hardware resources and provides common services. The operating system <NUM> includes, for example, a kernel <NUM>, services <NUM>, and drivers <NUM>. The kernel <NUM> acts as an abstraction layer between the hardware and the other software layers. For example, the kernel <NUM> provides memory management, processor management (e.g., scheduling), component management, networking, and security settings, among other functionality. The services <NUM> can provide other common services for the other software layers. The drivers <NUM> are responsible for controlling or interfacing with the underlying hardware. For instance, the drivers <NUM> can include display drivers, camera drivers, BLUETOOTH® or BLUETOOTH® Low Energy drivers, flash memory drivers, serial communication drivers (e.g., USB drivers), WI-FI® drivers, audio drivers, power management drivers, and so forth.

The libraries <NUM> provide a common low-level infrastructure used by the applications <NUM>. The libraries <NUM> can include system libraries <NUM> (e.g., C standard library) that provide functions such as memory allocation functions, string manipulation functions, mathematic functions, and the like. In addition, the libraries <NUM> can include API libraries <NUM> such as media libraries (e.g., libraries to support presentation and manipulation of various media formats such as Moving Picture Experts Group-<NUM> (MPEG4), Advanced Video Coding (H. <NUM> or AVC), Moving Picture Experts Group Layer-<NUM> (MP3), Advanced Audio Coding (AAC), Adaptive Multi-Rate (AMR) audio codec, Joint Photographic Experts Group (JPEG or JPG), or Portable Network Graphics (PNG)), graphics libraries (e.g., an OpenGL framework used to render in two dimensions (2D) and three dimensions (3D) in a graphic content on a display), database libraries (e.g., SQLite to provide various relational database functions), web libraries (e.g., WebKit to provide web browsing functionality), and the like. The libraries <NUM> can also include a wide variety of other libraries <NUM> to provide many other APIs to the applications <NUM>.

The frameworks <NUM> provide a common high-level infrastructure that is used by the applications <NUM>. For example, the frameworks <NUM> provide various graphical user interface (GUI) functions, high-level resource management, and high-level location services. The frameworks <NUM> can provide a broad spectrum of other APIs that can be used by the applications <NUM>, some of which may be specific to a particular operating system or platform.

In an example, the applications <NUM> may include a home application <NUM>, a contacts application <NUM>, a browser application <NUM>, a book reader application <NUM>, a location application <NUM>, a media application <NUM>, a messaging application <NUM>, a game application <NUM>, and a broad assortment of other applications such as a third-party application <NUM>. The applications <NUM> are programs that execute functions defined in the programs. Various programming languages can be employed to create one or more of the applications <NUM>, structured in a variety of manners, such as object-oriented programming languages (e.g., Objective-C, Java, or C++) or procedural programming languages (e.g., C or assembly language). In a specific example, the third-party application <NUM> (e.g., an application developed using the ANDROID™ or IOS™ software development kit (SDK) by an entity other than the vendor of the particular platform) may be mobile software running on a mobile operating system such as IOS™, ANDROID™, WINDOWS® Phone, or another mobile operating system. In this example, the third-party application <NUM> can invoke the API calls <NUM> provided by the operating system <NUM> to facilitate functionality described herein.

"Component" refers to a device, physical entity, or logic having boundaries defined by function or subroutine calls, branch points, APIs, or other technologies that provide for the partitioning or modularization of particular processing or control functions. Components may be combined via their interfaces with other components to carry out a machine process. A component may be a packaged functional hardware unit designed for use with other components and a part of a program that usually performs a particular function of related functions. Components may constitute either software components (e.g., code embodied on a machine-readable medium) or hardware components. A "hardware component" is a tangible unit capable of performing certain operations and may be configured or arranged in a certain physical manner. In various example embodiments, one or more computer systems (e.g., a standalone computer system, a client computer system, or a server computer system) or one or more hardware components of a computer system (e.g., a processor or a group of processors) may be configured by software (e.g., an application or application portion) as a hardware component that operates to perform certain operations as described herein. A hardware component may also be implemented mechanically, electronically, or any suitable combination thereof. For example, a hardware component may include dedicated circuitry or logic that is permanently configured to perform certain operations. A hardware component may be a special-purpose processor, such as a field-programmable gate array (FPGA) or an application specific integrated circuit (ASIC). A hardware component may also include programmable logic or circuitry that is temporarily configured by software to perform certain operations. For example, a hardware component may include software executed by a general-purpose processor or other programmable processor. Once configured by such software, hardware components become specific machines (or specific components of a machine) uniquely tailored to perform the configured functions and are no longer general-purpose processors. It will be appreciated that the decision to implement a hardware component mechanically, in dedicated and permanently configured circuitry, or in temporarily configured circuitry (e.g., configured by software), may be driven by cost and time considerations. Accordingly, the phrase "hardware component"(or "hardware-implemented component") should be understood to encompass a tangible entity, be that an entity that is physically constructed, permanently configured (e.g., hardwired), or temporarily configured (e.g., programmed) to operate in a certain manner or to perform certain operations described herein. Considering embodiments in which hardware components are temporarily configured (e.g., programmed), each of the hardware components need not be configured or instantiated at any one instance in time. For example, where a hardware component comprises a general-purpose processor configured by software to become a special-purpose processor, the general-purpose processor may be configured as respectively different special-purpose processors (e.g., comprising different hardware components) at different times. Software accordingly configures a particular processor or processors, for example, to constitute a particular hardware component at one instance of time and to constitute a different hardware component at a different instance of time. Hardware components can provide information to, and receive information from, other hardware components. Accordingly, the described hardware components may be regarded as being communicatively coupled. Where multiple hardware components exist contemporaneously, communications may be achieved through signal transmission (e.g., over appropriate circuits and buses) between or among two or more of the hardware components. In embodiments in which multiple hardware components are configured or instantiated at different times, communications between such hardware components may be achieved, for example, through the storage and retrieval of information in memory structures to which the multiple hardware components have access. For example, one hardware component may perform an operation and store the output of that operation in a memory device to which it is communicatively coupled. A further hardware component may then, at a later time, access the memory device to retrieve and process the stored output. Hardware components may also initiate communications with input or output devices, and can operate on a resource (e.g., a collection of information). Whether temporarily or permanently configured, such processors may constitute processor-implemented components that operate to perform one or more operations or functions described herein. As used herein, "processor-implemented component" refers to a hardware component implemented using one or more processors. Similarly, the methods described herein may be at least partially processor-implemented, with a particular processor or processors being an example of hardware. For example, at least some of the operations of a method may be performed by one or more processors <NUM> or processor-implemented components. For example, at least some of the operations may be performed by a group of computers (as examples of machines including processors), with these operations being accessible via a network (e.g., the Internet) and via one or more appropriate interfaces (e.g., an API). The performance of certain of the operations may be distributed among the processors, not only residing within a single machine, but deployed across a number of machines. In some example embodiments, the processors or processor-implemented components may be located in a single geographic location (e.g., within a home environment, an office environment, or a server farm). In other example embodiments, the processors or processor-implemented components may be distributed across a number of geographic locations.

Claim 1:
A method of providing a user interface by a messaging application software development kit, SDK, included with a third party resource running on a portable device including a camera and a display, comprising:
receiving (<NUM>), by the SDK and from the third party resource, an API call to display an image processing user interface;
displaying (<NUM>, <NUM>) on the display of the portable device, a first user interface comprising a list of selectable graphical items corresponding to a group of available image modification features, wherein an item in the list of selectable graphical items is a logo related to a provider of the SDK;
receiving user selection of a desired graphical item from the list of selectable graphical items;
applying image modification features corresponding to the desired graphical item to an image received from the camera to generate a modified image;
displaying (<NUM>), on the display of the portable device, a second user interface including the modified image;
the method comprising:
receiving (<NUM>) user selection of the logo; and
opening (<NUM>) a messaging application that is provided by a provider of the SDK to a user interface with additional image modification features that are available for selection by a user.