Vision correction through graphics processing

An apparatus configured for graphics processing includes a memory configured to store graphics data, and one or more processors in communication with the memory, the one or more processors configured to output, for display, a plurality of test graphics images, receive input indicative of a perception of a user of the computing device of at least one test graphics image from the plurality of test graphics images, determine at least one parameter modification value and generate a corrected graphics image based at least in part on the at least one parameter modification value.

BACKGROUND

Computing devices and display devices continue to become smaller and more lightweight, allowing for more powerful processing in smaller packages. Lightweight devices with powerful capabilities allow technology to become more integrated with users' everyday lives. For instance, the power and display capabilities of past desktop computers may now be found in cellular telephones, laptop computers, tablet computers, and even in wearable computing devices, such as wrist-mounted devices (e.g., smartwatches) and head-mounted devices.

Visual content displayed by such devices, such as content for graphical user interfaces and video games, may be generated by a graphics processing unit (GPU). A GPU may convert two-dimensional (2D) or three-dimensional (3D) objects into a 2D pixel representation that may be displayed. In order to generate content for display, GPUs may perform various operations or commands to process images.

SUMMARY

This disclosure presents systems, techniques methods, and apparatuses for determining parameter modifications for graphics image generation and generating corrected graphics images based on the modified parameters. More specifically, the techniques described herein may enable a computing device to provide output to and receive feedback from a user in order to determine modification values that can be used to generate graphics images that account for users' eyesight imperfections, thereby producing graphics images that appear sharper and more in-focus to users who do not have perfect eyesight.

In one example of the disclosure, a method of graphics processing includes outputting for display, by a computing device, a plurality of test graphics images, receiving, by the computing device, input indicative of a perception of a user of the computing device of at least one test graphics image from the plurality of test graphics images, determining, by the computing device and based at least in part on the received input, at least one parameter modification value, and generating, by the computing device, a corrected graphics image based at least in part on the at least one parameter modification value.

In another example of the disclosure, an apparatus configured for graphics processing includes a memory configured to store graphics data and one or more processors in communication with the memory, the one or more processors configured to output, for display, a plurality of test graphics images, receive input indicative of a perception of a user of the computing device of at least one test graphics image from the plurality of test graphics images, determine, based at least in part on the received input, at least one parameter modification value, and generate a corrected graphics image based at least in part on the at least one parameter modification value.

In another example, this disclosure describes a computer-readable storage medium storing instructions that, when executed, cause one or more processors of a device configured for graphics processing to output, for display, a plurality of test graphics images, receive input indicative of a perception of a user of the computing device of at least one test graphics image from the plurality of test graphics images, determine, based at least in part on the received input, at least one parameter modification value, and generate a corrected graphics image based at least in part on the at least one parameter modification value.

In another example, this disclosure describes an apparatus configured to process graphics, the apparatus including means for outputting, for display, a plurality of test graphics images, means for receiving input indicative of a perception of a user of the computing device of at least one test graphics image from the plurality of test graphics images, means for determining, based at least in part on the received input, at least one parameter modification value, and means for generating a corrected graphics image based at least in part on the at least one parameter modification value.

DETAILED DESCRIPTION

For users without perfect eyesight, such as those who use contact lenses, glasses, or other vision correction implements, viewing content displayed to some display devices may be an unpleasant experience. For instance, wearing glasses may render the use of certain wearable devices (e.g., a head-mounted display device) almost impossible for some users. Without wearing corrective lenses, content displayed to the head-mounted display device may not appear as crisply to the users as it should. An inability to see the displayed content clearly may degrade the user experience.

Techniques of the present disclosure may enable display of content that appears sharper and clearer to users who have less-than-perfect eyesight by processing the content to account for vision imperfections of a user. That is, the techniques described herein may reduce the need for external vision correction by enabling more accurate display of content that compensates for a user's vision problems. By reducing the need for glasses, contacts, or other vision correction implements, the techniques of the present disclosure may allow users with less-than-perfect eyesight to more easily and comfortably interact with various types of computing devices and display devices, thereby improving the user experience.

FIG. 1is a conceptual diagram illustrating an example computing environment that includes a computing device2configured to implement the techniques of this disclosure. In the example ofFIG. 1, computing device2is a wearable computing device that a user (e.g., user4) may mount on the user's head for use. In other examples, computing device2may be external to the wearable display. Computing device2may have a goggles form factor, a visor form factor, a glasses form factor, or otherwise be usable to view content displayed to one or more displays of computing device2. In other examples, computing device2may be another type of wearable device (e.g., a wrist-mounted computing device, etc.), a personal computer, a desktop computer, a laptop computer, a tablet computer, a computer workstation, a video game platform or console, a mobile telephone (e.g., a cellular or satellite telephone), a landline telephone, an Internet telephone, a handheld device such as a portable video game device or a personal digital assistant (PDA), a personal music player, a video player, a display device, a television, a television set-top box, a server, an intermediate network device, a mainframe computer, any mobile device, or any other type of device that processes and/or displays graphical data.

In the example ofFIG. 1, computing device2may include one or more displays to which graphical content (e.g., one or more graphics images) may be displayed. Examples of a display or display device may include a monitor, a television, a projection device, a liquid crystal display (LCD), a plasma display panel, a light emitting diode (LED) array, such as an organic LED (OLED) display, a cathode ray tube (CRT) display, electronic paper, a surface-conduction electron-emitted display (SED), a laser television display, a nanocrystal display or another type of display unit. Each display of computing device2may viewable by an eye of user4. That is, computing device2may include two displays configured such that, when worn and used properly, a left display of computing device2is visible to the left eye of user4, and a right display of computing device2is visible to the right eye of user4. In other examples, computing device2may include a single display, three displays, or more. In some examples, computing device2may not include a display. That is, in some examples, computing device2may be operable to generate content to be displayed to one or more display devices external to computing device2. In some such examples, computing device2may be operable to store generated content and/or send generated content to one or more display devices operatively coupled to computing device2(e.g., via one or more wired and/or wireless connections).

User4, in the example ofFIG. 1, may have less-than-perfect vision. For instance, user4may suffer from myopia (i.e., nearsightedness). In order to account for the user's eyesight, user4may, in the example ofFIG. 1, regularly wear glasses. Many forms of imperfect eyesight (e.g., myopia or nearsightedness, hyperopia or farsightedness, astigmatism, and/or other vision imperfections) may result in vision being blurry, out-of-focus, and/or out of proportion due to the focal point of light entering the user's eye occurring at a spot other than the user's retina. That is, light that enters the eye is focused (e.g., by elements of the user's eye) at the wrong place. Myopia, for instance, is the result of light being focused before the retina. Vision correction implements such as glasses, contact lens, and monocles may compensate for various vision imperfections by modifying the direction of light entering the eye, such that the modified light is focused at the retina. Thus, using glasses may generally enable user4to see more clearly than without the user's glasses.

Wearing glasses, however, may make wearable computing devices or display devices, such as computing device2, difficult or uncomfortable to use. In the example ofFIG. 1, for instance, user4may be unable to wear computing device2over the user's glasses. Thus, in order to use computing device2, user4may remove the glasses. In some examples, users may be unable or unwilling to wear contact lenses or other vision correction implements. For instance, some users' vision may be affected in a minor way and the users may opt to live without vision correction. Regardless of the reason, users with imperfect vision may desire to use a computing device or display device without using vision correction implements. However, without vision correction implements, content displayed to the user may appear blurry or out of focus.

Graphics image6A illustrates one example of how a displayed graphics image may appear to a user with less-than-perfect eyesight when the user is not wearing any vision correction implements. For instance, graphics image6A may be displayed by computing device2to the left display, visible to the left eye of user4. When user4views graphics image6A at the left display, the user's left eye may be unable to properly focus the light received from the left display. Thus, graphics image6A may appear blurry and out-of-focus. That is, while the graphics image may be crystal clear at the left display, user4's left eye may be unable to focus the light, received from the display, on to the retina of the user's left eye, and thus the crystal clear image may appear blurry to user4.

In accordance with the techniques described herein, computing device2may be configured to determine one or more ways in which to modify content to be displayed in order to compensate for the particular vision imperfections of user4. That is, computing device2may determine how to process content to account for imperfections in the vision of user4(e.g., myopia, hyperopia, astigmatism, and/or other conditions) and thereby provide user4with images that appear crisper and clearer to user4.

In order to properly account for a user's vision imperfections, computing device2may allow a user to provide feedback or input indicative of the user's vision problems. In the example ofFIG. 1, for instance, computing device2may provide a graphical user interface (GUI) or physical control with which user4may interact in order to provide information indicative of the vision imperfections of user4. In various examples, computing device2may allow users to input different information for each eye, different information for two or more axes (e.g., a first value for a first axis and a second value for a second axis) of one or both eyes, different information for different portions (e.g., regions) of a display, or otherwise provide precise information indicative of the user's particular vision conditions.

In some examples, computing device2may be configured to explicitly receive user eyesight correction values (e.g., a corrective lens prescription). For instance, computing device2may be configured to receive magnification values (e.g., for correcting myopia and hyperopia) in diopters, focal lengths, or other units. Computing device2may additionally or alternatively be configured to receive an angle value (e.g., for correcting astigmatism) associated with one or more magnification values. The angle value may be specified in degrees, radians, meridians, or other units. In some examples, computing device2may use one or more approximation tables to determine parameter modification values based on received user eyesight correction values. For instance, computing device2may use an approximation table that specifies—for a particular level of myopia—a corresponding increase (or decrease) in any level of blurring that is to be applied to graphics images.

In some examples, computing device2may provide a user interface, such as a graphical user interface (GUI), to assist users in providing information about their vision imperfections. Users may be able to interact with computing device2via the user interface and provide input (e.g., feedback). For instance, computing device2may output one or more simple graphics images for display to user4. Computing device2may receive information (e.g., input by user4) indicating how the displayed graphics images are perceived by user4. Received information may, in various examples, be a simple indication of whether or not the image is acceptable (e.g., “yes” or “no”), an indication of whether a currently displayed graphics image is better or worse than a previously displayed graphics image, an indication of a location or region of a displayed graphics image that is perceived as incorrect, or other information about user4's perception of the graphics image.

Computing device2may use information derived from the received feedback when generating graphics images for display. For instance, computing device2may modify values used by vertex and/or pixel/fragment shaders when generating graphics images and/or to perform post processing on generated graphics images, thereby distorting the images such that, when displayed to a display, the content appears more in-focus to the user. That is, graphics images generated using parameters that are modified based on received user input may appear distorted to those having perfect vision but, by distorting the graphics images in a fashion and to an extent that is in accordance with the vision imperfections of a particular user, the graphics images may appear more in-focus and/or clearer to the particular user.

In some examples, the image processing techniques described herein may take advantage of ray tracing principles to provide for a vision-corrected image. For instance, each graphics image to be displayed to a display device can be represented as rays of light passing through a focal point or focal plane (e.g., the display surface). These rays of light can be quantized down to a ray per pixel of the display. By re-negotiating the paths for the rays of light, the content to be displayed can be distorted in order to determine a new end-location of a given pixel based on a user's provided input. In other words, instead of a fixed focal plane at the viewport (e.g., the screen of a display), applying the techniques described herein may move the plane based on the received prescription information, thereby bringing graphics images more “into focus” for users with imperfect vision.

Graphics image6B illustrates one example of how a graphics image, modified using the techniques described herein and displayed by computing device2, may appear to user4when user4is not wearing any vision correction implements. For instance, graphics image6B may be displayed by computing device2to the left display, visible to the left eye of user4. When user4views graphics image6B at the left display, the user's left eye may be continue to improperly focus the light received from the left display. However, because the graphics image was modified based on user4's input (e.g., indicating the degree to which user4's left eye is affected by myopia), the light received from the display showing graphics image6B may better focus at the retina of user4's left eye. Thus, graphics image6B may appear less blurry and more in-focus to user4. That is user4's left eye may still be unable to focus the received light on to the retina of the user's left eye, but because the graphics image was processed to account for such inability, graphics image6B may appear clearer and sharper to user4.

In other words, techniques of the present disclosure may assist a user in “tuning” the application of the techniques described herein to determine the correct parameter values to use during image processing. For instance, computing device2may provide an “optometrist mode” in which a user may be prompted to answer a series of questions (e.g., “Which is better: option 1 or option 2?”) in order to determine the parameter values. Thus, computing device2may enable users to accurately specify how to better process images that account for the users' eyesight imperfections, even when the users do not know their eyeglass prescription or specific eyesight problems.

Thus, in some examples, computing device2may be configured to process graphics images to account for a user's eyesight without the user having to enter any prescription values. In other words, computing device2may, in various examples, provide the optometrist mode to determine the proper parameter values to correct for a user's eyesight (e.g., without previously having received any indication of prescription values for the user), or to perfect the parameter values (e.g., to verify and/or improve specified prescription values).

The techniques of the present disclosure may, in various examples, be used to adapt content displayed to a single display device and to multiple display devices. For instance, while described in the example ofFIG. 1as being applied to content displayed to the left display of computing device2, the techniques described herein may additionally or alternatively applied to content displayed to the right display of computing device2. Furthermore, the techniques described herein may, in some examples, be applied to stereo content. Stereo content may be content displayed in a stereo fashion (e.g., to simulate a three dimensional environment). Stereo content may be displayed as two sets of content to single display device (e.g., “3DTV”) or as a first set of content to a first display (e.g., visible to a left eye of the user) and a second set of content to a second display (e.g., visible to a right eye of the user). In some examples, the processing techniques described herein may be independently applied to each set of content to compensate for different vision maladies in each of a user's eyes. In the example ofFIG. 1, for instance, user4may be more myopic in the user's left eye than in the user's right eye. Thus, computing device2may apply stronger processing to the content displayed to the left display of computing device2and apply weaker processing to the content displayed to the right display of computing device2.

FIG. 2is a block diagram illustrating further details of computing device2as shown inFIG. 1. That is, in the example ofFIG. 2, computing device2may be configured to obtain information indicative of user eyesight imperfections, determine parameter modification values based on the obtained information, and process graphics images to be displayed such that displayed content appears in-focus to users who do not have perfect eyesight. As illustrated in the example ofFIG. 2, computing device2includes user input interface24, central processing unit (CPU)26, memory controller28, system memory30, graphics processing unit (GPU)32, graphics memory34, display interface36, display38and buses40and42. While GPU32and graphics memory34are shown in the example ofFIG. 2as separate components, graphics memory34may, in some examples, be “on-chip” with GPU32. In some examples, all hardware elements show inFIG. 2may be on-chip (e.g., in a system on a chip (SoC) design).

User input interface24, CPU26, memory controller28, GPU32and display interface36may communicate with each other using bus40. Memory controller28and system memory30may also communicate with each other using bus42. Buses40,42may be any of a variety of bus structures or other communication links, such as a third generation bus (e.g., a HyperTransport bus or an InfiniBand bus), a second generation bus (e.g., an Advanced Graphics Port bus, a Peripheral Component Interconnect (PCI) Express bus, an Advanced eXentisible Interface (AXI) bus), or any other type of bus or interconnection capable of communicating information. It should be noted that the specific configuration of components, buses, and communication interfaces shown in the example ofFIG. 2is merely exemplary, and other configurations of computing devices and/or other graphics processing systems with the same or different components may be used to implement the techniques of this disclosure.

In the example ofFIG. 2, CPU26may comprise a general-purpose or a special-purpose processor that controls operation of computing device2. A user may provide input to computing device2to cause CPU26to execute one or more software applications. The software applications that execute on CPU26may include, for example, an operating system, a word processor application, an email application, a spread sheet application, a media player application, a video game application, a graphical user interface application or any other program. Additionally, CPU26may execute a GPU driver27for controlling the operation of GPU32. In some examples, the user may provide input to computing device2via one or more input devices (not shown) such as a keyboard, a mouse, a microphone, a touch pad or another input device that is coupled to computing device2via user input interface24.

The software applications that execute on CPU26may include one or more graphics rendering instructions that instruct CPU26to cause the rendering of a graphics image for display to display38. In some examples, the instructions may conform to a graphics application programming interface (API), such as, e.g., an Open Graphics Library (OpenGL®) API, an Open Graphics Library Embedded Systems (OpenGL ES) API, a Direct3D API, an X3D API, a RenderMan API, a WebGL API, or any other public or proprietary standard graphics API. In order to process the graphics rendering instructions, CPU26may issue one or more graphics rendering commands to GPU32(e.g., through GPU driver27) to cause GPU32to perform some or all of the rendering of the graphics data. In some examples, the graphics data to be rendered may include a list of graphics primitives, e.g., points, lines, triangles, quadrilaterals, triangle strips, etc.

Memory controller28, in the example ofFIG. 2, may facilitate the transfer of data going into and out of system memory30. For example, memory controller28may receive memory read and write commands, and service such commands with respect to system memory30in order to provide memory services for the components in computing device2. Memory controller28is communicatively coupled to system memory30via memory bus42. Although illustrated inFIG. 2as being a processing module that is separate from both CPU26and system memory30, some or all of the functionality of memory controller28may, in some examples, be implemented on one or both of CPU26and system memory30.

In the example ofFIG. 2, system memory30may store program modules and/or instructions that are accessible for execution by CPU26and/or data for use by the programs executing on CPU26. For instance, system memory30may store a window manager application that is used by CPU26to present a graphical user interface (GUI) on display38. In addition, system memory30may store user applications and application surface data associated with the applications. System memory30may additionally store information for use by and/or generated by other components of computing device2. For instance, system memory30may act as a device memory for GPU32and may store data to be operated on by GPU32as well as data resulting from operations performed by GPU32. In various examples, system memory30may store any combination of texture buffers, depth buffers, stencil buffers, vertex buffers, frame buffers, or the like. System memory30may include one or more volatile or non-volatile memories or storage devices, such as, for example, random access memory (RAM), static RAM (SRAM), dynamic RAM (DRAM), read-only memory (ROM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), Flash memory, a magnetic data media or an optical storage media.

GPU32, in the example ofFIG. 2, may be configured to perform graphics operations to render one or more graphics primitives to display38. Thus, when one of the software applications executing on CPU26requires graphics processing, CPU26may provide graphics commands and graphics data to GPU32for rendering to display38. The graphics data may include drawing commands, state information, primitive information, texture information, or other data. GPU32may, in some examples, be built with a highly-parallel structure that provides more efficient processing of complex graphic related operations than CPU26. For instance, GPU32may include a plurality of processing elements that are configured to operate on multiple vertices or pixels in a parallel manner. A highly-parallel structure may allow GPU32to draw graphics images (e.g., GUIs and two dimensional (2D) and/or three dimensional (3D) graphics scenes) to display38more quickly than drawing the images directly to display38using CPU26.

GPU32may, in some examples, be integrated into a motherboard of computing device2. In other examples, GPU32may be present on a graphics card that is installed in a port in the motherboard of computing device2or may be otherwise incorporated within a peripheral device configured to interoperate with computing device2. GPU32may include one or more processors, such as one or more microprocessors, application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), digital signal processors (DSPs), or other equivalent integrated or discrete logic circuitry.

As shown in the example ofFIG. 2, GPU32may be directly coupled to graphics memory34. Thus, GPU32may read data from and write data to graphics memory34without using bus40. In other words, GPU32may process data locally using a local storage, instead of off-chip memory. This may allow GPU32to operate in a more efficient manner by eliminating the need of GPU32to read and write data via bus40, which may experience heavy bus traffic. In some examples, however, GPU32may not include a separate memory, but instead utilize system memory30via bus40. Graphics memory34may include one or more volatile or non-volatile memories or storage devices, such as, e.g., random access memory (RAM), static RAM (SRAM), dynamic RAM (DRAM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), Flash memory, a magnetic data media or an optical storage media.

CPU26and/or GPU32may store rendered graphics images as image data in a frame buffer35. Frame buffer35may be an independent memory or may be allocated within system memory30. Display interface36may retrieve the image data from frame buffer35and configure display38to display the graphics image represented by the rendered image data. In some examples, display interface36may include a digital-to-analog converter (DAC) that is configured to convert the digital values retrieved from frame buffer35into an analog signal consumable by display38. In other examples, display interface36may pass the digital values directly to display38for processing. Display38may include a monitor, a television, a projection device, a liquid crystal display (LCD), a plasma display panel, a light emitting diode (LED) array, such as an organic LED (OLED) display, a cathode ray tube (CRT) display, electronic paper, a surface-conduction electron-emitted display (SED), a laser television display, a nanocrystal display or another type of display unit. As shown in the example ofFIG. 2, display38may, in some examples, be integrated within computing device2. For instance, display38may be a screen of a mobile telephone or a head-mounted computing device. Alternatively, display38may, in some examples, be a standalone device coupled to computing device2via a wired or wireless communications link. For instance, display38may be a computer monitor or flat panel display connected to a personal computer or other computing device via a cable or wireless link.

According to one example of the disclosure, CPU26and/or GPU driver27may be configured to generate rendering commands for rendering a graphics image. GPU32may be configured to execute the rendering commands and render a corrected graphics image based at least in part on input indicative of user eyesight imperfections. In some examples, GPU32may be configured to render the corrected graphics image as part of executing the rendering commands. That is, at least a portion of the rendering commands may cause GPU32to render the graphics image using parameters that are modified based on the received input. In some examples, GPU32may be configured to render the corrected graphics image by post processing a graphics image. That is, the rendering commands may cause GPU32to apply post processing using modified parameters to generate the corrected graphics image. In other words, GPU32may, in various examples, render a corrected graphics images as part of the rendering process and/or during post processing of the graphics image.

FIG. 3is a block diagram illustrating one example of processing units (e.g., CPU26, GPU32, and system memory30ofFIG. 2) configured to implement the techniques of this disclosure. In the example ofFIG. 3, CPU26may include at least one software application44, a graphics API46, and a GPU driver27, each of which may be one or more software applications or services that execute on CPU26. GPU32may include a graphics processing pipeline50that includes a plurality of graphics processing stages that operate together to execute graphics processing commands. GPU32may be configured to execute graphics processing pipeline50to render corrected graphics images based at least in part on input indicative of user eyesight imperfections. For instance, GPU32may account for the eyesight imperfections of the user during the rendering process and/or during a post-processing step. As shown in the example ofFIG. 3, graphics processing pipeline50may include a command engine52, a geometry processing stage54, a rasterization stage56, and a pixel processing pipeline58. Each of the components in graphics processing pipeline50may be implemented as fixed-function components, programmable components (e.g., as part of a shader program executing on a programmable shader unit), or as a combination of fixed-function and programmable components. Memory available to CPU26and GPU32may include system memory30and frame buffer35. Frame buffer35may be a part of system memory30or may be separate from system memory30. Frame buffer35may store rendered image data.

Software application44may be any application that utilizes the functionality of GPU32. For example, software application44may be a GUI application, an operating system, a portable mapping application, a computer-aided design program for engineering or artistic applications, a video game application, or another type of software application that uses 2D or 3D graphics.

Software application44may include one or more drawing instructions that instruct GPU32to render a graphical user interface (GUI) and/or a graphics scene. For example, the drawing instructions may include instructions that define a set of one or more graphics primitives to be rendered by GPU32. In some examples, the drawing instructions may, collectively, define all or part of a plurality of windowing surfaces used in a GUI. In additional examples, the drawing instructions may, collectively, define all or part of a graphics scene that includes one or more graphics objects within a model space or world space defined by the application.

Software application44may invoke GPU driver27, via graphics API46, to issue one or more commands to GPU32for rendering one or more graphics primitives into a displayable graphics image. For example, software application44may invoke GPU driver27, via graphics API46, to provide primitive definitions to GPU32. In some instances, the primitive definitions may be provided to GPU32in the form of a list of drawing primitives, e.g., triangles, rectangles, triangle fans, triangle strips, etc. The primitive definitions may include vertex specifications that specify one or more vertices associated with the primitives to be rendered. The vertex specifications may include positional coordinates for each vertex and, in some instances, other attributes associated with the vertex, such as, e.g., color coordinates, normal vectors, and texture coordinates. The primitive definitions may also include primitive type information (e.g., triangle, rectangle, triangle fan, triangle strip, etc.), scaling information, rotation information, and the like.

Based on the instructions issued by software application44to GPU driver27, GPU driver27may formulate one or more commands that specify one or more operations for GPU32to perform in order to render the primitive. When GPU32receives a command from CPU26, graphics processing pipeline50decodes the command and configures one or more processing elements within graphics processing pipeline50to perform the operation specified in the command. After performing the specified operations, graphics processing pipeline50outputs the rendered data to frame buffer35associated with a display device (e.g., display38).

GPU driver27may be further configured to compile one or more shader programs, and to download the compiled shader programs onto one or more programmable shader units contained within GPU32. The shader programs may be written in any shading language. The compiled shader programs may include one or more instructions that control the operation of a programmable shader unit within GPU32. For example, the shader programs may include vertex shader programs and/or pixel shader programs. A vertex shader program may control the execution of a programmable vertex shader unit or a unified shader unit, and include instructions that specify one or more per-vertex operations. A pixel shader program may include pixel shader programs that control the execution of a programmable pixel shader unit or a unified shader unit, and include instructions that specify one or more per-pixel operations. In accordance with some example embodiments of this disclosure, a pixel shader program may also include instructions that selectively cause texture values to be retrieved for source pixels based on corresponding destination alpha values for the source pixels.

Graphics processing pipeline50may be configured to receive one or more graphics processing commands from CPU26, via GPU driver27, and to execute the graphics processing commands to generate a displayable graphics image. As discussed above, graphics processing pipeline50includes a plurality of stages that operate together to execute graphics processing commands. It should be noted, however, that such stages need not necessarily be implemented in separate hardware blocks. For example, portions of geometry processing stage54and pixel processing pipeline58may be implemented as part of a unified shader unit.

Command engine52may receive graphics processing commands and configure the remaining processing stages within graphics processing pipeline50to perform various operations for carrying out the graphics processing commands. The graphics processing commands may include, for example, drawing commands and graphics state commands. The drawing commands may include vertex specification commands that specify positional coordinates for one or more vertices (e.g., of an object or primitive in 3D space) and, in some instances, other attribute values associated with each of the vertices, such as, e.g., color coordinates, normal vectors, texture coordinates and fog coordinates. The graphics state commands may include primitive type commands, transformation commands, lighting commands, etc. The primitive type commands may specify the type of primitive to be rendered and/or how the vertices are combined to form a primitive. The transformation commands may specify the types of transformations to perform on the vertices. The lighting commands may specify the type, direction and/or placement of different lights within a graphics scene. Command engine52may cause geometry processing stage54to perform geometry processing with respect to vertices and/or primitives associated with one or more received commands.

Geometry processing stage54may perform per-vertex operations and/or primitive setup operations on one or more vertices in order to generate primitive data for rasterization stage56. Each vertex may be associated with a set of attributes, such as, e.g., positional coordinates, color values, a normal vector, and texture coordinates. Geometry processing stage54modifies one or more of these attributes according to various per-vertex operations. For example, geometry processing stage54may perform one or more transformations on vertex positional coordinates to produce modified vertex positional coordinates. Geometry processing stage54may, for example, apply one or more of a modeling transformation, a viewing transformation, a projection transformation, a ModelView transformation, a ModelViewProjection transformation, a viewport transformation and a depth range scaling transformation to the vertex positional coordinates to generate the modified vertex positional coordinates. In some instances, the vertex positional coordinates may be model space coordinates, and the modified vertex positional coordinates may be screen space coordinates. The screen space coordinates may be obtained after the application of the modeling, viewing, projection and viewport transformations. In some instances, geometry processing stage54may also perform per-vertex lighting operations on the vertices to generate modified color coordinates for the vertices. Geometry processing stage54may also perform other operations including, e.g., normal transformations, normal normalization operations, view volume clipping, homogenous division and/or backface culling operations.

In some examples, all or part of geometry processing stage54may be implemented by one or more shader programs executing on one or more shader units. For example, geometry processing stage54may be implemented, in such examples, by a vertex shader, a geometry shader or any combination thereof. In other examples, geometry processing stage54may be implemented as a fixed-function hardware processing pipeline or as a combination of fixed-function hardware and one or more shader programs executing on one or more shader units.

In some examples, in order to generate a graphics image that corrects for user eyesight imperfections, geometry processing stage54may use a modified transformation matrix to transform vertices' 3D positions in virtual space to 2D coordinates at which the vertices should appear in a rendered image. That is, geometry processing stage54may process data that defines one or more 3D objects using a transformation matrix composed of one or more modified parameters to generate the graphics image. The modified parameters may be determined based on the received information indicative of user eyesight imperfections. For instance, geometry processing stage54may multiply one or more parameters of the transformation matrix by a determined parameter modification value and/or add a determined parameter modification value to one or more parameters in order to create the modified transformation matrix. By using a modified transformation matrix, the resulting output of geometry processing stage54may be different than it would be had the transformation matrix parameters not been modified based on the user eyesight imperfections.

Geometry processing stage54may produce primitive data that includes a set of one or more modified vertices that define a primitive to be rasterized as well as data that specifies how the vertices combine to form a primitive. Each of the modified vertices may include, for example, modified vertex positional coordinates and processed vertex attribute values associated with the vertex. The primitive data may collectively correspond to a primitive to be rasterized by further stages of graphics processing pipeline50. Conceptually, each vertex may correspond to a corner of a primitive where two edges of the primitive meet. Geometry processing stage54may provide the primitive data to rasterization stage56for further processing.

Rasterization stage56is configured to receive, from geometry processing stage54, primitive data that represents a primitive to be rasterized, and to rasterize the primitive to generate a plurality of source pixels that correspond to the rasterized primitive. In some examples, rasterization stage56may determine which screen pixel locations are covered by the primitive to be rasterized, and generate a source pixel for each screen pixel location determined to be covered by the primitive. Rasterization stage56may determine which screen pixel locations are covered by a primitive by using techniques known to those of skill in the art, such as, e.g., an edge-walking technique, evaluating edge equations, etc. Rasterization stage56may provide the resulting source pixels to pixel processing pipeline58for further processing.

The source pixels generated by rasterization stage56may correspond to a screen pixel location, e.g., a destination pixel, and be associated with one or more color attributes. All of the source pixels generated for a specific rasterized primitive may be said to be associated with the rasterized primitive. The pixels that are determined by rasterization stage56to be covered by a primitive may conceptually include pixels that represent the vertices of the primitive, pixels that represent the edges of the primitive and pixels that represent the interior of the primitive.

Pixel processing pipeline58is configured to receive a source pixel associated with a rasterized primitive or fragment, and to perform one or more per-pixel operations on the source pixel. Per-pixel operations that may be performed by pixel processing pipeline58include, e.g., alpha test, texture mapping, color computation, pixel shading, per-pixel lighting, fog processing, blending, a pixel ownership text, a source alpha test, a stencil test, a depth test, a scissors test and/or stippling operations. In addition, pixel processing pipeline58may execute one or more pixel shader programs or fragment shader programs to perform one or more per-pixel or per-fragment operations. The resulting data produced by pixel processing pipeline58may be referred to herein as destination pixel data and stored in frame buffer35. The destination pixel data may be associated with a destination pixel in frame buffer35that has the same display location as the source pixel that was processed. The destination pixel data may include data such as, e.g., color values, destination alpha values, depth values, etc.

Frame buffer35stores destination pixels for GPU32. Each destination pixel may be associated with a unique screen pixel location. In some examples, frame buffer35may store color components and a destination alpha value for each destination pixel. For example, frame buffer35may store Red, Green, Blue, Alpha (RGBA) components for each pixel where the “RGB” components correspond to color values and the “A” component corresponds to a destination alpha value. Although frame buffer35and system memory30are illustrated as being separate memory units, in other examples, frame buffer35may be part of system memory30.

In some examples, one or more components of graphics processing pipeline50may be configured to receive post-processing commands from CPU26, via GPU driver27, and to execute the post-processing commands to modify a graphics image based on input indicative of user eyesight imperfections. For instance, command engine52may receive commands specifying a graphics image (e.g., a collection of destination pixels stored at frame buffer35) and configure one or more of the remaining components of graphics processing pipeline50(e.g., pixel processing pipeline58) to execute the commands. The pixel shaders and/or fragment shaders of pixel processing pipeline58may, in some examples, apply a deconvolution filter, a blurring filter, or other image effects to the graphics image to account for user eyesight. Parameters for such filters or effects may be determined based on input indicative of eyesight imperfections. Thus, the output of the pixel shaders and/or fragment shaders of pixel processing pipeline58may appear more clear to a user than if the post processing was not performed. That is, by performing various filtering operations and/or other post processing on the graphics image, shaders of pixel processing pipeline58may provide a graphics image that is actually more corrupted (e.g., blurred), but that may be perceived, by a user that has imperfect eyesight, as more correct.

In this way, GPU32may be configured to render a corrected graphics image based on input indicative of user eyesight imperfections. In some examples, GPU32may utilize parameters modified based on the input as part of executing rendering commands. In some examples, GPU32may utilize parameters modified based on the input as part of post-processing the graphics image. Further examples and details regarding use of such parameters are provided below inFIGS. 4-6.

FIG. 4is a block diagram illustrating an example process implementing one or more techniques of the present disclosure. For purposes of illustration only, the example process ofFIG. 4is described below within the context ofFIGS. 1-3. In the example ofFIG. 4, computing device2may be configured to generate a graphics image using parameters that are modified based on input indicative of a user's eyesight imperfections. That is, computing device2may receive input indicative of the user's eyesight imperfections, determine appropriate parameter modification values, and, during rendering of a graphics image, use parameters modified in accordance with the parameter modification values.

Graphics processing pipeline50, in the example ofFIG. 4, may execute graphics rendering commands80. Graphics rendering commands80may correspond to a request (e.g., by an application executing at computing device2) for a rendered graphics image. Graphics rendering commands80may, in some examples, include drawing commands and graphics state commands. In the example ofFIG. 4, graphics rendering commands80may include one or more graphics state commands to cause the requested rendering to take into account a user's eyesight imperfections. For instance, graphics rendering commands80may include calls to an API of one or more components of graphics processing pipeline50(e.g., geometry processing stage54and/or pixel processing stage58) thereby indicating that the requested graphics image is rendered in a fashion that compensates for the user's eyesight.

As one example, graphics rendering commands80may include a shader instruction that would be inserted into an appropriate geometry processing shader. Such a shader instruction may be used by GPU driver27to insert commands to render the corresponding graphics image using parameters that are modified based on information indicative of the user's eyesight imperfections. As another example, graphics rendering commands80may include a function call to post-process the position output from a shader. Such a function call may be useful in the case where an application has simple shaders, and does not want to modify the shader content.

In the example ofFIG. 4, command engine52may receive graphics rendering commands80and configure one or more other components of graphics processing pipeline50to execute graphics rendering commands80. For instance, command engine52may configure geometry processing stage54to perform transformations using modified parameters and/or may configure pixel processing pipeline58to perform filtering using modified parameters. In the example ofFIG. 4, command engine52may cause both geometry processing stage54and pixel processing pipeline58to utilize modified parameters. In some examples, command engine52may cause one of geometry processing stage54or pixel processing pipeline58to perform operations using modified parameters. That is, in various examples, generation of a corrected graphics image may include the use of modified parameters during a geometry processing stage (e.g., to perform operations on vertices or other geometric objects) and/or during a pixel processing stage (e.g., to perform operations on pixels, etc.).

As part of processing graphics rendering commands80, geometry processing stage54and/or pixel processing pipeline58may receive or otherwise obtain parameter modification values84. For instance, GPU32may receive parameter modification values84from CPU26, or may obtain parameter modification values84from system memory30. Parameter modification values84may specify a value or values that geometry processing stage54and/or pixel processing pipeline58may use to modify parameters involved in rendering a graphics image. In some examples, parameter modification values84may be values, coefficients, or other modifiers of a transformation matrix, values, coefficients, or other modifiers of a filter, or other indications of how to modify parameters to account for a user's vision imperfections.

In the example ofFIG. 4, for instance, geometry processing stage54may be configured to perform one or more transformations using parameters that are modified based on parameter modification values84. Such transformations may include transforming Model Space into World Space, transforming World Space into Camera Space, and/or transforming Camera Space into Homogeneous Space (or Projection Space). Each transformation may utilize a set of parameters (e.g., a transformation matrix) to transform image data (e.g., vertices of a model) from one space to another. For instance, transforming Model Space into World Space may be accomplished by applying a Model matrix to each vertex of a model.

A Model matrix may, in some examples, be a matrix usable to modify the values of a vertex of an object in order to move the object in a space. The Model matrix may be composed of a number of underlying matrices, such as a translation matrix, T, one or more rotation matrices R, and a scaling matrix, S, as shown below.

As can be seen in the examples above, the underlying matrices of the Model matrix include parameter values defining how vertices of the object are to be modified in order to increase or decrease the size of the object (e.g., the Sx, Sy, and Szparameters), rotate the object (e.g., the α parameter), and/or move the object (e.g., Tx, Ty, and Tzparameters). Thus, the resulting Model matrix may be used to scale, rotate, and translate vertices of an object in one transformation. By changing the parameter values of the underlying matrices, the resulting Model matrix may be modified, and the object will be transformed differently than if the parameter values were unchanged. In other words, parameter modification values84may indicate that one or more of Sx, Sy, Sz, α, Tx, Ty, or Tzshould be changed before transforming vertices as part of rendering a graphics image.

In a similar fashion, transforming World Space into Camera Space may be accomplished by applying a View matrix to vertices in the World Space. Modifying parameter values of the View matrix (or matrices that make up the View matrix) will modify the way that the World Space is transformed.

Transforming Camera Space into Homogenous Space (or Projection Space) may be accomplished using a Projection matrix. An example projection matrix, P, is shown below.

Modifying parameters of the Projection matrix will also change the way in which the Camera Space is transformed. For instance, if parameter modification values84specify a modifier for the “near” value shown in the Projection matrix above, this will modify the way in which the projection is displayed on a display by modifying the location of the near plane for transforming content to the Homogeneous Space. Modifying the “near” value shown in the Projection matrix above may correspond to modifying a focal point for objects displayed in the resulting graphics image. That is, the near parameter may define the focal plane of the image.

In the example ofFIG. 4, geometry processing stage54may account for various user eyesight imperfections by rendering graphics images using parameters modified based on parameter modification values84. For instance, a user may be using a head-mounted computing device having two displays—one for each eye. The user may have trouble focusing correctly on the same location of a stereo graphics image with both eyes. In such example, computing device2may employ the techniques described herein to determine parameter modification values84that include a parameter modification value for a horizontal translation parameter and/or a vertical translation parameter. Geometry processing stage54may apply parameter modification values84to base values of the horizontal and/or vertical translation parameters to create a modified transformation matrix and thereby render graphics images that account for the poor focus experienced by the user. That is, one or both displays may display graphics images that are modified to be “centered” for the respective eye of the user. Various other parameter modification values may be used by geometry processing stage54, including horizontal, vertical, or depth scaling parameter modification values, horizontal, vertical, or depth translation parameter modification values, rotation parameter modification values, near plane location parameter modification values, or other parameter modification values.

Pixel processing pipeline58may, in the example ofFIG. 4, be configured to perform one or more operations using parameters that are modified based on parameter modification values84. Such operations may include the application of various blurring filters, de-blurring filters (e.g., deconvolution filters), or other filters. Operations may also include application of transformations, such as operations to transform pixels based on radial distortion, based on lens projections (e.g., transformations that correct for characteristics of optical lenses), and other transformations. Such operations may depend on various parameters, such as parameters indicating the level of blur or deconvolution to be applied, the size of the lens to use for a lens projection or lens compensation projection, and any other value that can be modified to modify the resulting pixels.

As a result of performing the transformations and filters using modified parameter values, graphics processing pipeline50may render a corrected graphics image, such as corrected image88. In accordance with the techniques of the present disclosure, corrected image88may account for a level of user eyesight correction, thereby providing the user with a graphics image that appears more correct to the user, even when the user does not have perfect vision and is not wearing vision correction implements such as glasses or contacts. By exposing a vision correction API to applications executing at computing device2and rendering graphics images using parameter values that are modified based on input indicative of a user's eyesight imperfections, the techniques described herein may allow computing device2to more accurately account for the user's eyesight.

FIG. 5is a block diagram illustrating an example process implementing one or more techniques of the present disclosure. For purposes of illustration only, the example process ofFIG. 4is described below within the context ofFIGS. 1-3. In the example ofFIG. 5, computing device2may be configured to generate a corrected graphics image by applying post processing to a graphics image using parameters that are modified based on input indicative of a user's eyesight imperfections. That is, computing device2may receive input indicative of the user's eyesight imperfections, determine appropriate parameter modification values, and use parameters that are modified based on the values to post process a graphics image to produce a corrected graphics image.

Graphics processing pipeline50, in the example ofFIG. 5, may execute graphics rendering commands100. Graphics rendering commands100may correspond to a request (e.g., by an application executing at computing device2) for a rendered graphics image. By executing graphics rendering commands100, graphics processing pipeline50may render uncorrected image102.

In the example ofFIG. 5, uncorrected image102may represent a graphics image that does not compensate for users' eyesight imperfections. That is, uncorrected image102may, if displayed to a display device, appear in-focus to users having perfect vision but appear out-of-focus or otherwise incorrect to those users that do not have perfect vision. In some examples, after rendering uncorrected image102, GPU32may store uncorrected image102(e.g., within graphics memory34).

GPU32may, in the example ofFIG. 5, utilize pixel processing pipeline58of graphics processing pipeline50to modify uncorrected image102to account for a user's eyesight maladies. For instance, GPU32may cause pixel processing pipeline58to perform post processing based on parameters determined using parameter modification values104. Post processing may include the various operations performable by pixel processing pipeline58as described above with respect toFIG. 4. That is, in the example ofFIG. 5, pixel processing pipeline58may be operable to apply various filters to the pixel data, perform various transformations on the pixel data (e.g., to compensate for or apply lens projections), and other operations.

Post processing using parameters determined based on parameter modification values104may produce corrected image106. In accordance with the techniques of the present disclosure, corrected image106may account for a level of user eyesight imperfection, thereby providing the user with a graphics image that appears more correct to the user, even when the user does not have perfect vision and is not wearing vision correction implements such as glasses or contacts. By utilizing a post-processing step to modify a rendered uncorrected image and generate a corrected image, the techniques described herein may enable a computing device to correct for a user's eyesight impairment without participation by applications. That is, by generating corrected graphics images through post processing, the user eyesight correction process may be application-agnostic.

FIG. 6is a block diagram illustrating an example computing device2and graphics images160and162for obtaining information indicative of user eyesight imperfections in accordance with the techniques of the present disclosure. For purposes of illustration only, the example ofFIG. 6is described below within the context ofFIGS. 1-3.

Computing device2, as shown in the example ofFIG. 6, may be configured to output graphics images160and162as part of a GUI for obtaining feedback indicative of user eyesight imperfections. The feedback received may be used to determine parameter modification values that are usable to determine parameters used in rendering graphics images that appear more correct to a user. That is, the process described in the example ofFIG. 6may enable a user of computing device2to provide input that computing device2can use to determine modified parameters for rendering graphics images. In some examples, such as when computing device2includes two or more displays (e.g., stereo displays of a headset), the process described in the example ofFIG. 6may be performed for each display. That is, computing device2may determine one or more parameter modification values for each display (e.g., corresponding to respective eyes of the user). In some examples, the process described in the example ofFIG. 6may be performed on one or more portions of a display (e.g., not on the display as a whole, but instead on particular regions or portions).

In the example ofFIG. 6, GPU32may render graphics image160for display to display38. For instance, display38may output graphics image160during a user's initial setup and configuration of computing device2or in response to computing device2receiving user input instructing computing device2to determine the user's eyesight imperfections (e.g., by accessing a settings configuration application executed by computing device2). GPU32may not correct for user eyesight imperfections when rendering graphics image160. That is, graphics image160may be rendered without taking any imperfections in the user's vision into account. Thus graphics image160may appear blurry or out-of-focus to a user having imperfect vision.

Responsive to displaying graphics image160to display38, computing device2may, in the example ofFIG. 6, receive user input instructing computing device2to continue with the eyesight correction determination. For instance, the user may press a button (e.g., a physical button, a user interface element displayed to a touch-sensitive or presence-sensitive display, etc.) of computing device2, press a button of a device communicatively coupled to computing device2, speak a voice command (e.g., “Continue,” “Okay,” etc.) or otherwise indicate to computing device2that the user wishes to continue.

In the example ofFIG. 6, responsive to receiving input from the user instructing computing device2to continue, computing device2may cause the displayed graphics image to incrementally change in some fashion. For instance, GPU32may render progressive versions of graphics image160for output to display38, while using incrementally different parameter values for a blurring filter (e.g., applied by pixel processing pipeline58). For instance, GPU32may render a first version of graphics image160using extremely small parameter values and display38may display the first version. Each version of graphics image160may be displayed for a short time (e.g., 0.5 seconds, 1 second, 2 seconds, or other duration).

GPU32may render a second version of graphics image160using parameter values that are slightly increased from that used in rendering the first version and display38may display the second version. For instance, if GPU32renders the first version using a value of 0.1 for a parameter indicating a level of blur to be applied (e.g., on a scale of 0-10), GPU32may render the second version using a parameter value of 0.2. This incremental increase may continue until GPU32renders a version of graphics image160using a defined maximum parameter value (e.g., 10.0). Once a defined maximum parameter value is reached, GPU32may begin rendering versions of graphics image160using incrementally smaller parameter values. In this way, computing device2may display a graphics image that cycles through various degrees of image modification. In some examples, computing device2may cycle through each parameter once (e.g., from a minimum value to a maximum value). In some examples, computing device2may cycle through each parameter multiple times (e.g., from a minimum value to a maximum value and then back to a minimum).

In some examples, computing device2may cycle through more than one parameter for each version of graphics image160. For instance, GPU32may render versions of graphics image160while cycling through a first parameter corresponding to scaling of a horizontal axis of graphics image160and then while cycling through a second parameter corresponding to scaling of a vertical axis of graphics image160. As another example, GPU32may render versions of graphics image160while cycling through a first parameter that is involved in a blurring filter, as well as a second parameter that is involved in a deconvolution filter. In this way, computing device2may display a graphics image that also cycles through compensation for various degrees and/or types of vision afflictions.

As computing device2displays versions of graphics images160rendered using progressively increasing or decreasing parameter values, computing device2may, in the example ofFIG. 6, receive input from a user when the user believes that the displayed graphics image appears better (e.g., more in-focus, more properly proportioned, or otherwise improved). For instance, the user may push a button, provide voice input, or otherwise provide an indication to computing device2when a currently displayed version of graphics image160appears better than the other displayed versions. In some examples, computing device2may receive a single indication. In other examples, such as when computing device2cycles through values multiple times, computing device2may receive multiple indications, providing a small range of possible parameter values.

In the example ofFIG. 6, computing device2may determine approximate parameter modification values based on the received indications. For instance, when computing device2receives a single indication that the displayed graphics image appears in-focus, computing device2may determine the approximate parameter modification value or values as the parameter value or values used to render the graphics image displayed when the indication was received. As another example, when computing device2receives two or more indications that the displayed graphics image appears in-focus, computing device2may determine the approximate parameter modification value or values as the average of each value that was used to render the respective graphics image displayed when each indication was received. In yet other examples, computing device2may determine the approximate parameter modification values as the values having the most corresponding indications, or in some other fashion. In other words, computing device2may determine one or more approximate parameter modification values based on the received indications.

In this way, computing device2may enable the user to provide information indicative of eyesight imperfections and may determine parameter modification values for use in rendering graphics images without the user having to manually enter values. This may be useful when, for instance, the user does not know the user's eyeglass prescription or have knowledge of various graphics processing techniques. Additionally, while the distance between display38and the user's eye may be factored in when determining parameter modification values, a fixed approximation may be used in the example process ofFIG. 6.

FIG. 7is a block diagram illustrating an example computing device2and graphics images180,184, and186for obtaining information indicative of user eyesight imperfections in accordance with the techniques of the present disclosure. For purposes of illustration only, the example ofFIG. 7is described below within the context ofFIGS. 1-3.

Computing device2, as shown in the example ofFIG. 7, may be configured to output graphics images180,184, and186as part of a GUI for obtaining feedback indicative of user eyesight imperfections by guiding a user through a series of selections to choose the parts of images that appear more correct. The feedback received may be used to determine parameter modification values that may be taken into account when rendering subsequent graphics images in order to make the subsequent graphics images appear more correct to the user. In some examples, the process described in the example ofFIG. 7may enable a user of computing device2to “fine tune” parameter modification values. The process ofFIG. 7may enable computing device2to provide clearer, more in-focus graphics images to a user, in accordance with the techniques described herein. In some examples, such as when computing device2includes two or more displays (e.g., stereo displays), the process described in the example ofFIG. 7may be performed for each display. In other words, computing device2may determine one or more respective parameter modification values for each display.

In some examples, computing device2may perform the process described in the example ofFIG. 7subsequent to a user providing input that instructs computing device2to continue after performing the process described in the example ofFIG. 6. In some examples, computing device2may perform the process described in the example ofFIG. 7responsive to receiving input (e.g., voice input, a selection of a displayed value, or other means of input) to select one or more approximate parameter modification values. That is, in some examples, computing device2may perform the process described inFIG. 7to obtain exact parameter modification values from previously determined or received approximate parameter modification values. In some examples, computing device2may perform the process described in the example ofFIG. 7based on input instructing computing device2to determine parameter modification values. That is, in some examples, computing device2may determine specific parameter modification values without previously determining approximate values.

In the example ofFIG. 7, computing device2may have stored an approximate modification value of 0.3 for a blurring filter parameter. That is, a user of computing device2may have provided input or otherwise indicated that he or she perceives images as more correct when the graphics image is subjected to a blurring filter with an additional 0.3 units more than normal. The input or indication may have been provided by the user inputting a value of 0.3, providing input that experientially indicates a value of 0.3 (or values that average to 0.3) or otherwise providing input usable to determine an approximate blurring parameter modification value of 0.3.

Based at least in part on the approximate value of 0.3, GPU32may, in the example ofFIG. 7, render graphics image180for display to display38. Graphics image180may include content rendered using different parameter values, from which the user may choose the “better” looking content. That is, GPU32may render at least two portions of graphics image180(e.g., portion182A and182B). Each portion may be rendered using different parameter values. For instance, portion182A may be rendered using a parameter value of 0.25, while portion182B may be rendered using a parameter value of 0.35. Consequently, one portion of the content may appear more correct to the user than the other portion.

In the example ofFIG. 7, subsequent to displaying graphics image180, computing device2may receive input (e.g., voice input, touch input, input using a physical button or key, or other input) indicating a selection of portion182A. That is, the user may indicate that he or she believes that portion182A appears better or more in-focus than portion182B.

Based on a received selection of portion182A, GPU32may, in the example ofFIG. 7, render graphics image184. Graphics image184includes portions186A and186B. Portion186A may be rendered using a parameter value of 0.25, while portion186B may be rendered using a value of 0.3. That is, because the user indicated that a portion of a first graphics image, rendered based on a parameter value of 0.25, appeared better than a portion of the first graphics image rendered using 0.35, computing device2may, in the example ofFIG. 7, render portions of a second image (e.g.,186A and186B) using values of 0.25 and 0.3 to determine whether the user's eyesight requires less correction, or whether the best correction is using a parameter modification value between 0.25 and 0.3.

In the example ofFIG. 7, computing device2may receive input indicating a selection of portion186B. That is, the user may indicate that content rendered using a value of 0.3 appears more accurate than content rendered using a value of 0.25. Based on the received input, computing device2may determine that it is likely that the user's eyesight would benefit from a parameter value nearer 0.3 than 0.25.

Subsequent to receiving the input selecting portion186B, computing device2may render and display another graphics image (not shown) having portions rendered using 0.275 and 0.3. Computing device2may receive a selection of one of the portions (e.g., the portion rendered using 0.275). Based on the selection, computing device2may render and display another graphics image (not shown) having portions rendered using 0.275 and 0.288. Computing device2may continue in like fashion to narrow down the user's selections to an exact parameter value, outputting two portions of a graphics image that are rendered using different parameter values, receiving input selecting of one of the portions, and outputting a subsequent graphics image having portions rendered using new parameter values.

In some examples, this process may continue until the user indicates that neither portion of a graphics image looks more accurate than the other. In some examples, this process may continue until the user has gone back and forth between two values in three successive graphics images, or otherwise reached a point where any difference in parameter values is negligible (e.g. 0.1, 0.05, 0.001, or other value). In other words, the process ofFIG. 7may, in various examples, present the user with two images at a time, each image being rendered based on different values of a parameter. The parameter may continue to change values in successive images until the user stops uniquely identifying an image as “better.” In some examples, the process described above may additionally or alternatively be performed using different values for other parameters (e.g., a parameter for positional translation, a parameter for a deconvolution filter, etc. to account for other vision issues). In some examples, the process may additionally or alternatively be performed using other methods of identifying eyesight imperfections of a user.

After the user has indicated that there appears to be no difference between two portions of a displayed graphics image, or otherwise provided input that causes computing device2to determine exact parameter modification values, GPU32may render graphics image188for display to display38. Graphics image188may be rendered using the determined exact parameter modification values. Thus, graphics image188may appear more correct to the user. Thereafter, computing device2may use the determined exact parameter modification values when performing the techniques described herein to generate corrected graphics images.

FIG. 8is a block diagram illustrating an example computing device2and graphics images190,192, and194for obtaining information indicative of user eyesight imperfections in accordance with the techniques of the present disclosure. For purposes of illustration only, the example ofFIG. 8is described below within the context ofFIGS. 1-3.

Computing device2, as shown in the example ofFIG. 8, may be configured to output graphics images192,194, and196as part of a GUI for obtaining feedback indicative of a user's eyesight imperfections. Computing device2may utilize the received feedback to determine parameter modification values. Computing device2and/or other computing devices may use the determined parameter modification values to determine parameter values that are usable during image rendering to generate graphics images that account for the user's eyesight imperfections.

As shown in the example ofFIG. 8, graphics images192,194, and196include a number of objects. These objects may represent a set of training data that may assist the user in providing feedback indicative of the user's eyesight problems. In order to obtain useful feedback, the user may be informed beforehand of the nature of the training data. That is, computing device2(or a manual for computing device2, a startup guide, or any other material) may inform the user about an object or objects that exist in the training data (e.g., shape, location, and/or other information), so that the user knows what he or she is supposed to see. In the example ofFIG. 8, for instance, the user may be informed that he or she is supposed to see 3 concentric circles, two of the concentric circles being completely visible and one extending vertically off the screen, as well as two equal length, straight lines crossing the center of the circles—one horizontally and one vertically. While simple 2D objects are used inFIG. 8, training data may, in other examples, be any number of 2D and/or 3D images or video. For instance, in some examples, the training data may include 2D concentric circles drawn on a 3D sphere. In some examples, training data may be shown individually to each eye of a user. For instance, training data be shown to a left eye of a user separately from the training data shown to the right eye of the user.

In the example ofFIG. 8, GPU32may render graphics image192for display to display38. For instance, display38may output graphics image192during initial setup and configuration of computing device2. Graphics image192may be rendered without taking any imperfections in the user's vision into account. Thus, graphics image192may appear incorrect in one or more ways to a user having imperfect vision. As seen in the example ofFIG. 8, for instance, the user may have an astigmatism or other vision ailment that causes a horizontal axis to be focused differently than a vertical axis. Thus, while graphics image192may display three concentric circles and two equal length lines, the user may perceive three ellipses and two lines of unequal length. In other words, though data representing the three circles and two lines was rendered using unmodified transformation matrices, the resulting graphics image may appear to the user to have a larger scaling factor along the horizontal axis than along the vertical axis.

In order to determine ways in which to modify image rendering to account for the user's eyesight imperfections, computing device2may cause the displayed graphics image to incrementally change in various ways and obtain feedback from the user regarding the displayed images. The feedback may be indicative of the user's perception of the displayed images. For instance, GPU32may render progressive versions of graphics image192for output to display38, while using incrementally different parameter values for various parameters of one or more transformation matrices. Computing device2may receive input indicating whether or not the image as perceived by the user corresponds to the description of the training data.

The example ofFIG. 8may represent one way in which computing device2may incrementally change graphics image192. In the example ofFIG. 8, GPU32may use progressively different values for a horizontal scaling parameter of a transformation matrix. If graphics image192is rendered using a horizontal scaling parameter value of 0, for instance, GPU32may render a subsequent image (e.g., graphics image194) with a horizontal scaling parameter value of −0.2 and output the image for display. Thereafter, GPU32may render more graphics images (not shown) with horizontal scaling parameter values of −0.4, −0.6, −0.8, and so on.

Upon viewing one or more of the displayed images, the user may provide input indicating whether or not the displayed image aligns with what the user expects to see, given the prior description of the training data. For instance, the user may provide input indicating whether a displayed graphics image is “better” or “worse” than a previously displayed graphics image, whether the parameter that is currently being modified should be larger, smaller, or is correct as-is, or other input indicative of the user's perception of the image or images. User input may be provided in any of a number of ways, such as verbal input, a press of a button or GUI element, or other input.

In the example ofFIG. 8, this process may continue, with computing device2outputting successive images and the user providing feedback input. In some examples, the user's perception of a displayed graphics image may eventually match the user's expectation. For instance, GPU32may render graphics image196for display. Graphics image196may be rendered using a horizontal scaling parameter value of −0.4.

As seen inFIG. 8, the objects in graphics image196—in the perception of the user—may match the user's expectation, based on the description of the training data. Computing device2may receive user input indicating the user's satisfaction with the horizontal scaling parameter value used to render graphics image196. Based on this input, computing device2may determine a modification value for the parameter. That is, based on user input indicating that a horizontal scaling parameter value resulted in the user perceiving the correct image, computing device2may determine a modification value for subsequent horizontal scaling parameter values. In the example ofFIG. 8, for instance, computing device2may determine a parameter modification value of −0.6.

While described with respect to a horizontal scaling parameter, the process described in the example ofFIG. 8may be performed similarly for various other parameter values as described herein. For instance, the process may be performed for a vertical scaling parameter, an overall scaling parameter, a vertical and/or horizontal translation parameter, rotation parameters, and other parameters. In some examples, computing device2may first determine parameters relating to shape aspects of the graphics image. Computing device2may next determine focus of the objects based on subsequent user feedback. In some examples, such as examples in which computing device2includes multiple displays, (e.g., stereo displays) computing device2may also determine parameters relating to the perceived depth aspects resulting from displayed graphics images. For instance, computing device2may render and display various stereo versions of a graphics image until the user indicates that objects in the graphics images properly appear three dimensional.

FIG. 9is a block diagram illustrating an example computing device2and graphics images for obtaining information indicative of user eyesight imperfections in accordance with the techniques of the present disclosure. For purposes of illustration only, the example ofFIG. 9is described below within the context ofFIGS. 1-3.

Computing device2, as shown in the example ofFIG. 9, may be configured to output graphics images, such as graphics images200,202, and204, in order to obtain feedback indicative of a user's eyesight imperfections and/or correct for the user's eyesight imperfections. In some examples, a user's eyesight imperfections may not be uniform. That is, a user may have various eyesight issues that cause vision distortion in some areas of the user's view more than in other areas. In order to compensate for such imperfections, the techniques of the present disclosure may be applied to various portions of a display in a non-uniform manner, thereby providing stronger and/or different correction where needed without over-correcting in other areas.

Graphics image200provides one example of a corrected graphics image having different regions201A and201B. In the example ofFIG. 9, GPU32may render region201A based on a first set of one or more parameter values, and region201B based on a second set of one or more parameter values. In various instances, one or both of the sets of parameter values may include parameter values based on parameter modification values determined using the techniques described herein. For instance, region201A may be rendered using a first blurring parameter value, while region201B is rendered using a second blurring parameter value.

Graphics image202provides another example of a corrected graphics image having different regions203A-203D. In the example ofFIG. 9, GPU32may render each of regions203A-203D using different sets of parameter values. Graphics image204provides a third example of a corrected graphics image having different regions205A and205B. GPU32may render region205A using a different set of parameter values than those used in rendering region205B.

The techniques of the present disclosure may be used to render graphics images using different parameter values for any number of regions, having any size or shape. For instance, different parameter modification values may be determined and applied for each of a large number of concentric ringed regions. As another example, different parameter modification values may be determined and applied for numerous different square regions in a single image. Various other shapes and sizes of regions may be used in accordance with the techniques described herein.

FIG. 10is a flow diagram illustrating example operations of a computing device configured to implement the techniques of the present disclosure. For purposes of illustration only, the example operations ofFIG. 10are described below within the context ofFIGS. 1-3.

In the example ofFIG. 10, computing device2may output, for display, a plurality of test graphics images. Each test graphics image from the plurality may be generated (e.g., by GPU32) based on a respective set of one or more parameter test values. For instance, GPU32may generate a first test graphics image based on a first set of parameter test values, generate a second test graphics image based on a second set of parameter test values, and so on. In some examples, each of the plurality of test graphics images may be output for display by computing device2in succession while in other examples, two or more of the plurality of test graphics images may be output for display concurrently.

Computing device2, in the example ofFIG. 10, may receive input indicative of a user's perception of at least one test graphics image (302). For instance, computing device2may receive a button press or voice input when the particular test graphics image is displayed, may receive input indicating the particular test graphics image (e.g., when more than one test graphics image is displayed concurrently), or receive other input indicative of the user's perception of at least one test graphics image. In some examples, computing device2may receive a single input. In other examples, computing device2may receive more than one input.

In the example ofFIG. 10, computing device2may determine at least one parameter modification value based at least in part on the received input (304). For instance, when a single input associated with a single particular test graphics image is received, computing device2may determine parameter modification values to be the same as the parameter test values associated with the particular test graphics image. When multiple inputs are received (e.g., associated with multiple test graphics images), computing device2may determine parameter modification values by averaging the parameter test values associated with the multiple test graphics images or based on the parameter test values associated with the multiple test graphics images in some other way.

Computing device2, in the example ofFIG. 10, may generate a corrected graphics image based on the at least one parameter modification value (306). In some examples, computing device2(e.g., GPU32) may render the corrected graphics image using a modified transformation matrix that is determined based on the at least one parameter modification value. In some examples, computing device2(e.g., GPU32) may additionally or alternatively post process a rendered graphics image using a parameter value determined based on the at least one parameter modification value to generate the corrected graphics image.

The code may be executed by one or more processors, such as one or more DSPs, general purpose microprocessors, ASICs, FPGAs, or other equivalent integrated or discrete logic circuitry. In addition, in some aspects, the functionality described herein may be provided within dedicated hardware and/or software modules. Also, the techniques could be fully implemented in one or more circuits or logic elements.