Patent Description:
In the field of digital image graphics, an image gradient is a directional change in color (often termed a color gradient) and/or intensity of an image along one or more directions of picture elements (pixels). An image gradient may be applied to the entirety of an image or a portion thereof. One example of an image gradient is a one-dimensional gradient, in which the gradient causes a change in color or intensity of the image along a single direction or axis. In many cases, a one-dimensional gradient is aligned either vertically or horizontally relative to an orientation of an observer of the gradient, although diagonal orientations for one-dimensional gradients are also possible. In some implementations, the gradient may be based on a continuous density function, wherein the color and/or intensity of each of the pixels of a digital image are associated with a corresponding value of the function.

Another example of an image gradient is a two-dimensional image gradient, in which the color and/or intensity of an image change along two directions. In many instances, the two directions are orthogonal, such as vertically and horizontally, or diagonally to the left and diagonally to the right. However, two-dimensional image gradients are not necessarily so constrained, and may be aligned along any two axes of a two-dimensional image that are not necessarily orthogonal.

Image gradients have often been employed in graphical user interfaces (GUIs) of any number or type of electronic devices, such as desktop computers, laptop computers, game systems, set-top boxes, tablet computers, smart phones, and so on. Further, image gradients may be employed to provide realistic features, such as shadows, to an image, or merely to provide some visual interest to the image.

A document entitled "<NPL>, discloses a Javascript method using an SVG canvas including code for the generation of a 2D image with a black and white or colour gradient in one direction i.e. a linear gradient along either of the major axes in a 2D image.

The present invention provides a method and system for generating an image gradient.

Embodiments are illustrated by way of example and not limitation in the figures of the accompanying drawings, in which like references indicate similar elements and in which:.

In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the embodiments disclosed herein. It will be evident, however, to one skilled in the art that the embodiments may be practiced without these specific details.

<FIG> is a block diagram of an example user system <NUM> employable for generating an image gradient in a digital image. In the examples described below, the image gradient being generated is a one-dimensional image gradient within a two-dimensional digital image. In other examples, however, the generated image gradient may be a one-dimensional gradient incorporated within a three-dimensional digital image for systems that support three-dimensional graphics.

In the example of <FIG>, the user system <NUM> may include a user device <NUM> and a display device <NUM>. The display device <NUM> may be included as part of the user device <NUM>, or may exist as a separate device or system communicatively coupled via a wired or wireless communication connection to the user device <NUM>. Examples of the display device <NUM> may include, but are not limited to, a television, a computer monitor, a touchscreen, or any other device or component configured to display digital images. Examples of the user device <NUM> may include, but are not limited to, a media gateway, a television set-top box, a television, a gaming system, a streaming device (e.g., a Roku®), a desktop computer, a laptop computer, a tablet computer, a smart phone, and a personal digital assistant (PDA).

The user device <NUM>, as depicted in <FIG>, may include at least one control processor <NUM>, a hardware graphics processor <NUM>, a display device interface <NUM>, and a memory <NUM>. The memory <NUM> may include input image data <NUM> employed to generate a two-dimensional image using the hardware graphics processor <NUM>. In some examples, the memory <NUM> may also include or store two-dimensional image data <NUM> representing the generated two-dimensional image. In at least some embodiments, the user device <NUM> may include other components or devices, including, but not limited to, a user input interface (e.g., a keyboard, touchpad, joystick, mouse, and so on), a power supply, a communication network interface (e.g., an interface for a wide area network (WAN), a local area network (LAN), a cellular telephone network (e.g., a third-generation (<NUM>) or fourth-generation (<NUM>) network), and/or a Bluetooth® connection), and the like. However, such components are not discussed herein to simplify and focus the discussion provided hereafter.

The at least one control processor <NUM> may include one or more central processing units (CPUs), microprocessors, microcontrollers, or any other type of processor that may be configured or programmed to perform the functions ascribed to it herein, such as, for example, generating the input image data <NUM> and controlling the hardware graphics processor <NUM> to generate the two-dimensional image data <NUM> based on the input image data <NUM>. The control processor <NUM> may be a hardware-only processor (e.g., one or more integrated circuits (ICs), possibly including one or more field-programmable gate arrays (FPGAs)) or an algorithmic hardware processor capable of executing software or firmware instructions.

The hardware graphics processor <NUM> may include one or more graphics processing units (GPUs) or any other hardware units configured to execute one or more operations for producing the two-dimensional digital image represented by the two-dimensional image data <NUM> based on the input image data <NUM> generated by the control processor <NUM>. To that end, the hardware graphics processor <NUM> may be configured to execute a one-dimensional "stretching" or "filling" graphics operation that may receive the input image data <NUM> and use that data to generate the two-dimensional image data <NUM>. In one example, the hardware graphics processor <NUM> may implement the one-dimensional stretching operation using a stretching/shrinking operation that may be applied to image data of any size up to some maximum size. Further, a one-dimensional stretching operation may enlarge the size of an input image along a single dimension or direction, either vertically or horizontally, by duplicating and/or interpolating pixels of the input image data to generate the larger output image. Oppositely, a one-dimensional shrinking operation may reduce the size of an input image along a single dimension or direction, either vertically or horizontally, by removing pixels of the input image data to produce the smaller output image. In some embodiments, the hardware graphics processor <NUM> may be configured to execute two-dimensional stretching/shrinking commands, but such commands are not the focus of the various embodiments discussed herein.

The memory <NUM> may be any rewritable memory, including, but not limited to, dynamic random access memory (DRAM) and static random access memory (SRAM), capable of storing the input image data <NUM>, and possibly the two-dimensional image data <NUM> generated therefrom. While the same memory <NUM> is illustrated in <FIG> as including both the input image data <NUM> and the two-dimensional image data <NUM>, the input image data <NUM> and the two-dimensional image data <NUM> may be stored in separate memory modules or sections. In one example, the two-dimensional image data <NUM> may be stored in a frame buffer or similar memory structure that may be accessed by the hardware graphics processor <NUM> or that may reside within the hardware graphics processor <NUM>. Presuming a frame buffer or similar structure is employed, the two-dimensional image data <NUM> may also be accessed within that structure via the display device interface <NUM> for presentation to a user via the display device <NUM>.

Accordingly, the display device interface <NUM> may be configured to access the two-dimensional image data <NUM> and provide that data <NUM> in some form usable by the display device <NUM> to the display device <NUM> for presentation to the user. Depending on the particular display device <NUM> being employed, the display device interface <NUM> may incorporate, for example, a coaxial video interface, a composite video interface, a component video interface, a high-definition multimedia interface (HDMI), an internal graphical or visual display interface of a standard or proprietary design, or any other interface capable of delivering the two-dimensional image data <NUM> for display to a user as a digital image.

<FIG> is a flow diagram of an example method <NUM> of generating an image gradient. While the following discussion of the method <NUM> presumes the use of the user device <NUM> of <FIG>, other user devices or systems not explicitly discussed herein may also be employed to perform the operations of method <NUM> in some embodiments.

In the method <NUM>, at least one control processor <NUM> may provide input image data <NUM> to the hardware graphics processor <NUM> to generate two-dimensional image data <NUM> (operation <NUM>). In one example, the input image data <NUM> may be one pixel in length along one direction and multiple pixels in length along a second direction that is perpendicular or orthogonal to the first direction. In addition, the multiple pixels along the second direction may represent an image gradient, such as, for example, a color gradient, an intensity gradient, a transparency gradient, or the like. As employed herein, an image gradient may be represented by any sequence of pixels for which at least the intensity, color, transparency, and/or other aspect or trait of the pixel changes over the pixel sequence. Also, in some examples, the first direction may be a horizontal direction and the second direction may be a vertical direction, or vice- versa.

The at least one control processor <NUM> may then initiate a one-dimensional stretching operation at the hardware graphics processor <NUM> based on the provided input image data <NUM> to generate the two-dimensional image data <NUM> (operation <NUM>). In one example, the two-dimensional image data <NUM>, as a result of the one-dimensional stretching operation, includes multiple pixels along the first direction for each corresponding one of the single pixels of the input image data <NUM>, with each of the multiple pixels being a copy of its corresponding single pixel. <FIG> and <FIG>, described in detail below, each illustrate an example of the input image data <NUM> and the two-dimensional image data <NUM> resulting from the one-dimensional stretching operation. The two-dimensional image data <NUM> may then be provided to the display device <NUM> via the display device interface <NUM> for presentation of the two-dimensional image to a user.

While the operations <NUM> and <NUM> of <FIG> are shown as occurring in a specific order, concurrent or overlapping execution of those operations, as well as operations of other methods described herein, are also possible. In one example, while the hardware graphics processor <NUM> is performing the one-dimensional stretching operation of a first set of input image data <NUM>, the at least one control processor <NUM> may be generating and/or providing a subsequent set of input image data <NUM>. In other examples, the operations <NUM> and <NUM> may be performed in some other repetitive manner, possibly in a parallel, simultaneous, or concurrent fashion.

<FIG> is a flow diagram of another example method <NUM> of generating an image gradient. As with the method <NUM> of <FIG>, while the following discussion of the method <NUM> presumes the use of the user device <NUM> of <FIG>, other user devices or systems not explicitly discussed herein may also be employed to perform the operations of method <NUM> in other embodiments.

In the method <NUM>, the at least one control processor <NUM> may generate the input image data <NUM> based on an image gradient (operation <NUM>). In one example, the control processor <NUM> may employ a formula or equation, such as a continuous density function relating a position of each of the multiple pixels along the second direction of the digital image to one or more aspects of that pixel, such as intensity, transparency, color, and the like. Examples of a continuous density function may include, but are not limited to, linear functions, parabolic functions, and so on. In other examples, the at least one control processor <NUM> may employ a discontinuous function, such as a saw-tooth, stair-step, or pulse-train function, to determine one or more aspects of each of the multiple pixels along the second direction. In yet other embodiments, the at least one control processor <NUM> may set the values of the aspects of each of the multiple pixels along the second direction randomly, on a pixel-by-pixel basis, or by any other deterministic or non-deterministic basis.

The control processor <NUM> may store the generated input image data <NUM> at a location in the memory <NUM> (operation <NUM>) and then generate a first input for the hardware graphics processor <NUM> that indicates an address of the location of the input image data <NUM> in the memory <NUM> (operation <NUM>). In another example, the control processor <NUM> may store the input image data <NUM> in a location of the memory <NUM> at which the hardware graphics processor <NUM> expects the input image data <NUM> for execution of a one-dimensional stretching operation. Consequently, in that case, the control processor <NUM> may not provide an explicit first input indicating the address of the location of the input image data <NUM> in the memory <NUM>.

The control processor <NUM> may also generate a second input for the hardware graphics processor <NUM> that indicates a stretching factor for a one-dimensional stretching operation to be performed by the hardware graphics processor <NUM> (operation <NUM>). In one embodiment, the stretching factor may indicate how much the input image data <NUM>, which may specify the multiple pixels along the second direction of the image, are to be stretched or copied along the first direction. For example, for an image that is intended to be a particular number of pixels along the first direction, the control processor <NUM> may set the stretching factor to be one less than the number of pixels along the first direction.

The control processor <NUM> may then provide the first input and the second input to the hardware graphics processor <NUM> before, or as part of, the initiation of the one- dimensional stretching operation at the hardware graphics processor <NUM>. In other embodiments, the control processor <NUM> may supply different, fewer, or additional input values for the stretching operation. For example, the control processor <NUM> may provide an input indicating a position along the first direction at which the input image data <NUM> is located, as well as a second input indicating which way along the first direction (e.g., left or right along a horizontal direction, up or down along a vertical direction, etc.) the input image data <NUM> is to be stretched or duplicated. In some examples, the stretching may occur both ways along the first direction.

<FIG> is a graphical representation of the generation of a two-dimensional digital image <NUM> based on two-dimensional image data <NUM> generated from vertically-oriented input image data <NUM> using the hardware graphics processor <NUM>. As depicted in <FIG>, the two-dimensional digital image <NUM> is represented by a set of pixels <NUM> visually arranged as a two-dimensional array of N horizontal rows <NUM> of pixels <NUM> by M vertical columns <NUM> of pixels <NUM>. To generate the two-dimensional image data <NUM> for the two-dimensional digital image <NUM>, the input image data <NUM> may be interpreted as a single vertical column of Npixels <NUM>, with a value (e.g., an indication of one or more values for the intensity, transparency, color, and/or other aspects) of each of the pixels <NUM> of the input image data <NUM> indicated by numbers <NUM> through N corresponding to the one of the rows <NUM> of the two-dimensional digital image <NUM>. As described above, the values of the input image data <NUM> may represent some image gradient, such as a linear, parabolic, or some other deterministic or non-deterministic gradient.

Presuming the input image data <NUM> is to be placed at the extreme left side of the two-dimensional digital image <NUM>, a horizontal stretching operation <NUM> to the right having a stretching factor of M-<NUM>, as initiated by the control processor <NUM> at the hardware graphics processor <NUM>, may then result in each of the pixels <NUM> of the input image data <NUM> being duplicated M-l times to the right to fill the pixels <NUM> of the two-dimensional digital image <NUM>. In one example, the size of the two-dimensional digital image <NUM> (e.g., N-by-M pixels) may fill or match the dimensions of the display device <NUM>. In other embodiments, the size of the two-dimensional digital image <NUM> may be less in the vertical and/or horizontal directions than one or both dimensions of the display device <NUM>. While the stretching operation <NUM> of <FIG> is configured such that the input image data <NUM> is presumed to be located on the extreme left end of the two-dimensional digital image <NUM>, and is configured to fill the pixels <NUM> toward the right end of the digital image <NUM>, the stretching operation <NUM> may instead be configured to presume that the input image data <NUM> is to be located at the extreme right end of the two-dimensional digital image <NUM>, and may be configured to fill the pixels <NUM> toward the left end of the digital image <NUM>. In yet another example, the stretching operation <NUM> may be configured to place the input image data <NUM> at some column <NUM> other than the leftmost column (e.g., column <NUM>) or the rightmost column (e.g., column M) and be configured to duplicate the pixels <NUM> of the input image data <NUM> horizontally in both the left and right directions.

<FIG> is a graphical representation of the generation of a two-dimensional digital image <NUM> based on two-dimensional image data <NUM> generated from horizontally-oriented input image data <NUM> using the hardware graphics processor <NUM>. As shown in <FIG>, the two-dimensional digital image <NUM> is represented by a set of pixels <NUM> visually arranged as a two-dimensional array of N horizontal rows <NUM> of pixels <NUM> by M vertical columns <NUM> of pixels <NUM>, in a manner similar to that of <FIG>. However, in this example, to generate the two-dimensional image data <NUM> for the two-dimensional digital image <NUM>, the input image data <NUM> may be interpreted as a single horizontal row of M pixels <NUM>, with a value (e.g., an indication of one or more values for the intensity, transparency, color, and/or other aspects) of each of the pixels <NUM> of the input image data <NUM> indicated by numbers <NUM> through M corresponding to the one of the columns <NUM> of the two-dimensional digital image <NUM>. As discussed earlier, the values of the input image data <NUM> may represent some image gradient.

Presuming the input image data <NUM> is to be placed at the extreme top end of the two-dimensional digital image <NUM>, a vertical stretching operation <NUM> from top to bottom having a stretching factor N-<NUM>, as initiated by the control processor <NUM> at the hardware graphics processor <NUM>, may then result in each of the pixels <NUM> of the input image data <NUM> being duplicated N-<NUM> times toward the bottom to fill the pixels <NUM> of the two-dimensional digital image <NUM>. As before, the size of the two-dimensional digital image <NUM> (e.g., N-by-M pixels) may fill or match the dimensions of the display device <NUM>. In other embodiments, the size of the two-dimensional digital image <NUM> may be less in the vertical and/or horizontal directions. Also, while the stretching operation <NUM> of <FIG> is configured such that the input image data <NUM> is presumed to be located at the extreme top end of the two-dimensional digital image <NUM>, and may be configured to fill the pixels <NUM> toward the bottom end of the digital image <NUM>, the stretching operation <NUM> may instead be configured to presume that the input image data <NUM> is to be located at the extreme bottom end of the two-dimensional digital image <NUM>, and may be configured to fill the pixels <NUM> toward the top end of the digital image <NUM>. In other embodiments, the stretching operation <NUM> may be configured to place the input image data <NUM> at some row <NUM> other than the topmost row (e.g., row <NUM>) or the bottommost row (e.g., row N) and to duplicate the pixels <NUM> of the input image data <NUM> vertically in both the up and down directions.

In both the examples of <FIG> and <FIG>, the hardware graphics processor <NUM> may store or forward the resulting two-dimensional digital image <NUM> and <NUM> to a frame buffer or other memory construct accessible by the display device interface <NUM> so that the two-dimensional digital image <NUM>, <NUM> may be presented on the display device <NUM> to a user. In some examples, the two-dimensional digital image <NUM>, <NUM> may be stored in a temporary location so that other operations, such as, for example, overlaying and possibly animating another image atop the two-dimensional digital image <NUM>, <NUM> may be performed without regenerating the two-dimensional digital image <NUM>, <NUM> using the stretching operation <NUM>, <NUM> of the hardware graphics processor <NUM>. Also, in some embodiments, the two-dimensional digital image <NUM>, <NUM> may be presented to the user as part of a GUI, such as, for example, a background area upon which selectable menu items may be presented to the user to allow user activation of commands, selection of command options, and the like.

In at least some of the embodiments described above, at least one control processor may employ a one-dimensional stretching operation or command provided by a hardware graphics processor to generate two-dimensional graphical images in which an image gradient is provided along one of the dimensions. In such embodiments, the control processor may generate or specify, and subsequently store, the gradient along one dimension, such as a row or column, of the two-dimensional image, thus reducing the amount of memory consumed to represent the image. Also, by employing the hardware graphics processor to generate the overwhelming majority of the image, thus relieving the control processor of that burden, the overall image generation may be accelerated while allowing the control processor to perform other operations.

Additionally, in at least some embodiments, the use of input image data dimensioned as a single row (or column) by multiple columns (or rows) of pixels, as described above, as input for a hardware graphics processor may avoid the generation of common visual artifacts associated with the stretching or expansion of extremely small images to significantly larger images. In fact, image data as narrow as two pixels along one dimension, in which some variation in color, intensity, or transparency is employed across the two pixels, when expanded or stretched along that same dimension, will often result in a blurry or blocky image, depending on the particular algorithm employed in the hardware graphics processor to perform the stretching operation. For example, two-pixel-wide image data that exhibits a black-and-white checkerboard pattern, when stretched using a nearest-neighbor interpolation algorithm, may generate a pattern in which the left and right halves of the resulting stretched image are inverted relative to each other. In another example, the same two-pixel-wide image data, when stretched using a bilinear interpolation algorithm, may generate a stretched image in which the center of the image converges to grey. Oppositely, when single-pixel-wide image data is employed, as described in conjunction with at least some of the embodiments disclosed herein, such artifacts are eliminated in the resulting stretched or expanded image.

<FIG> illustrates a diagrammatic representation of a machine in the example form of a computer system <NUM> within which a set of instructions <NUM> may be executed for causing the machine to perform any one or more of the methodologies discussed herein. In alternative embodiments, the machine operates as a standalone device or may be connected (e.g., networked) to other machines. In a networked deployment, the machine may operate in the capacity of a server or a client machine in server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer, a tablet computer, a set-top box (STB), a personal digital assistant (PDA), a cellular telephone, a web appliance, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term "machine" shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

The example computer system <NUM> includes a processor <NUM> (e.g., a central processing unit (CPU), a graphics processing unit (GPU) or both), a main memory <NUM> and a static memory <NUM> which communicate with each other via a bus <NUM>. The computer system <NUM> may further include a video display <NUM> (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)). The computer system <NUM> also includes an alphanumeric input device <NUM> (e.g., a keyboard), a user interface (UI) navigation device <NUM> (e.g., a mouse), a disk drive unit <NUM>, a signal generation device <NUM> (e.g., a speaker), and a network interface device <NUM>.

The disk drive unit <NUM> includes a machine-readable medium <NUM> on which is stored one or more sets of instructions and data structures (e.g., instructions <NUM>) embodying or utilized by any one or more of the methodologies or functions described herein. The instructions <NUM> may also reside, completely or at least partially, within the static memory <NUM>, within the main memory <NUM>, and/or within the processor <NUM> during execution thereof by the computer system <NUM>, the main memory <NUM> and the processor <NUM> also constituting machine-readable media.

The instructions <NUM> may further be transmitted or received over a computer network <NUM> via the network interface device <NUM> utilizing any one of a number of well-known transfer protocols (e.g., HyperText Transfer Protocol (HTTP)).

While the machine-readable medium <NUM> is shown in an example embodiment to be a single medium, the term "machine-readable medium" should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, and/or associated caches and servers) that store the one or more sets of instructions <NUM>. The term "machine-readable medium" shall also be taken to include any medium that is capable of storing, encoding or carrying a set of instructions <NUM> for execution by the machine and that cause the machine to perform any one or more of the methodologies of the present inventive subject matter, or that is capable of storing, encoding or carrying data structures utilized by or associated with such a set of instructions <NUM>. The term "machine-readable medium" shall accordingly be taken to include, but not be limited to, solid-state memories, and optical and magnetic media.

Although individual operations of one or more methods are illustrated and described as separate operations, one or more of the individual operations may be performed concurrently, and the operations may be performed in an order other than that illustrated.

Certain embodiments are described herein as including logic or a number of components, modules, or mechanisms. Modules may constitute either software modules (e.g., code embodied on a machine-readable medium or in a transmission signal) or hardware modules. A "hardware module" 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 modules 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 module that operates to perform certain operations as described herein.

In some embodiments, a hardware module may be implemented mechanically, electronically, or any suitable combination thereof. For example, a hardware module may include dedicated circuitry or logic that is permanently configured to perform certain operations. For example, a hardware module may be a special-purpose processor, such as a field-programmable gate array (FPGA) or an application-specific integrated circuit (ASIC). A hardware module may also include programmable logic or circuitry that is temporarily configured by software to perform certain operations. For example, a hardware module may include software encompassed within a general-purpose processor or other programmable processor.

Accordingly, the term "hardware module" 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. As used herein, "hardware-implemented module" refers to a hardware module. Considering embodiments in which hardware modules are temporarily configured (e.g., programmed), each of the hardware modules need not be configured or instantiated at any one instance in time. For example, where the hardware modules comprise a general-purpose processor configured by software to become a special-purpose processor, the general-purpose processor may be configured as respectively different hardware modules at different times. Software may accordingly configure a processor, for example, to constitute a particular hardware module at one instance of time and to constitute a different hardware module at a different instance of time.

Unless specifically stated otherwise, discussions herein using words such as "processing," "computing," "calculating," "determining," "presenting," "displaying," or the like may refer to actions or processes of a machine (e.g., a computer) that manipulates or transforms data represented as physical (e.g., electronic, magnetic, or optical) quantities within one or more memories (e.g., volatile memory, non- volatile memory, or any suitable combination thereof), registers, or other machine components that receive, store, transmit, or display information. Furthermore, unless specifically stated otherwise, the terms "a" or "an" are herein used, as is common in patent documents, to include one or more than one instance. Finally, as used herein, the conjunction "or" refers to a non-exclusive "or," unless specifically stated otherwise.

The Abstract of the Disclosure is provided to allow the reader to quickly ascertain the nature of the technical disclosure. The Abstract is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, in the foregoing Detailed Description, it can be seen that various features are grouped together in a single embodiment for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that the claimed embodiments include more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter lies in less than all features of a single disclosed embodiment. Thus the following claims are hereby incorporated into the Detailed Description, with each claim standing on its own as a separate embodiment.

Although embodiments of the present disclosure have been described with reference to specific example embodiments, it will be evident that various modifications and changes may be made to these embodiments without departing from the broader scope of these embodiments. Accordingly, the specification and drawings are to be regarded in an illustrative rather than a restrictive sense. The accompanying drawings that form a part hereof, show by way of illustration, and not of limitation, specific embodiments in which the subject matter may be practiced. The embodiments illustrated are described in sufficient detail to enable those skilled in the art to practice the teachings disclosed herein. Other embodiments may be utilized and derived therefrom, such that structural and logical substitutions and changes may be made without departing from the scope of this disclosure. This Detailed Description, therefore, is not to be taken in a limiting sense, and the scope of various embodiments is defined only by the appended claims.

Claim 1:
A server-implemented method of generating an image gradient, characterised by:
initiating (<NUM>) a one-dimensional stretching operation based on one-dimensional image data and a stretching factor to generate a two-dimensional digital image, wherein the one-dimensional image data comprises a single pixel along a first direction of the two-dimensional digital image and multiple pixels along a second direction of the two-dimensional digital image, wherein the second direction is orthogonal to the first direction, wherein the multiple pixels along the second direction of the two-dimensional digital image comprise an image gradient, and wherein the stretching factor indicates how much the one-dimensional image data is to be stretched in the first direction of the two-dimensional digital image;
wherein the one-dimensional stretching operation, when initiated, duplicates each of the pixels along the second direction by the stretching factor in the first direction to generate the two-dimensional digital image comprising multiple pixels along the first direction for each pixel of the one-dimensional image data, with each of the multiple pixels along the first direction duplicating the corresponding pixel.