Apparatus and method

Abstract

A method of rendering blurred images, implemented by a computer comprises a processor and a memory, generating an output image from an input image using a randomly rotated kernel (RRK). Preferably the

Description

Field The present invention relates to rendering of images on display devices, particularly to blurring of images displayed thereon. Background to the invention User Interface Blur Effects Modern consumer electronic devices (for example mobile devices, mobile phones, television, tablets, smartwatches, etc) display rich user interfaces (Uis) on increasingly higher resolution displays. One of the most common rendering effects in these Uis is background blur used to focus attention on foreground UI elements, provide a sensation of depth or simulate semiopaque materials. Context for Optimised Blur Algorithms In tandem with both increased use within the UI, increased display resolutions and increased frame rates, the processing device (for example, a Graphics Processing Unit (GPU) or a Single Instruction, Multiple Data (SIMD) parallel processor) cost of generating high resolution blurred images has increased greatly. With fluid Uis and framerates as high as 120hz, blurring consumes a significant percentage of total display composition time. Optimised blur algorithms are required on all platforms but essential for mobile &TV UI applications. In comparison to desktop GPUs, mobile &TV GPUs have much less shading and sampling bandwidth which is the main requirement for blur algorithms. UI blur composition effects were previously reserved for high end devices but are now increasingly required on mid and low range devices with less computational resource, which necessitates the need for efficient blurring solutions. Additionally, display resolutions on devices are increasing which increases the computational resource demands for perform blurring effects - for example, a 1080p resolution display device is 1920x1080 pixels, whilst a 4k display device is 3840x2160 pixels and an 8k display device is 7680x4320 pixels - a 400% &1600% increase in pixels respectively. Computational resource in consumer devices has not kept up with this increasing workload. Conversely, small form factor devices bring the same demands from the opposing direction, via reduced computational resources and more stringent power consumption requirements. Naive Blur Cost A naive blur implementation for a 100 pixel radius blur would sample over 31000 input pixels for every one of the 10,000 output pixels. Various algorithms have been developed to reduce the cost of blur such as Gaussian 2 pass separable filters and more recently multi pass algorithms. Multi-pass Blur Algorithms Multi pass blur algorithms repeatedly blur the output from the previous passes. This accumulated blur approach reduces the total bandwidth required to complete the target radius blur. As the target radius blur increases so does the number of passes required. Most blur algorithms will also downscale the input image in the first pass to reduce overall bandwidth, for example GPU bandwidth, required. A typical downscale ratio of 'A x 'A results in a 93.75% reduction in required bandwidth. At very low blur radii the blurred results may be drawn blended with the original image to hide the reduced resolution of the blurred image. Hence, there is a need to improve blur algorithms and implementations thereof. Summary of the Invention It is one aim of the present invention, amongst others, to provide a method of blurring an image which at least partially obviates or mitigates at least some of the disadvantages of the prior art, whether identified herein or elsewhere. For instance, it is an aim of embodiments of the invention to provide a method of blurring an image having a reduced compute cost, reduced compute resource, reduced compute power and / or reduced compute bandwidth requirement, compared with conventional methods. For instance, it is an aim of embodiments of the invention to provide a method of blurring an image having a reduced pass requirement, compared with conventional methods. For instance, it is an aim of embodiments of the invention to provide a method of blurring an image suitable for higher resolutions and / or higher framerates, compared with conventional methods. A first aspect provides a method of rendering blurred images, the method implemented by a computer comprising a processor and a memory, the method comprising: generating an output image from an input image using a randomly rotated kernel. A second aspect provides an electronic device, for example a display device, including a computer comprising a processor and a memory, configured to: generate an output image, for example an output display image, from an input image using a randomly rotated kernel. A third aspect provides a computer comprising a processor and a memory configured to implement, at least in part, a method according to the first aspect, a computer program comprising instructions which, when executed by a computer comprising a processor and a memory, cause the computer to perform a method, at least in part, according to the first aspect or a non-transient computer-readable storage medium comprising instructions which, when executed by a computer comprising a processor and a memory, cause the computer to perform a method, at least in part, according to the first aspect. Detailed Description of the Invention According to the present invention there is provided a method, as set forth in the appended claims. Also provided is an electronic device. Other features of the invention will be apparent from the dependent claims, and the description that follows. Method The first aspect provides a method of rendering blurred images, the method implemented by a computer comprising a processor and a memory, the method comprising: generating an output image from an input image using a randomly rotated kernel. The RRK (Randomly Rotated Kernel) Blur Algorithm has been developed to generate a high-performance blur with the following features: • Reduced bandwidth, for example reduced GPU bandwidth • Limited number of passes • Dynamic number of passes • K axis filter kernel, where 1 <K <5, for example a 3 or 4 axis filter kernel • High quality at large blur radii • Reduced impact of number of passes transitions for animated blur radius Reduced GPU Bandwidth RRK-3 is extremely efficient consuming 20% less read bandwidth, for example GPU read bandwidth, than ‘Dual Kawase’ blur and 60% less read bandwidth than ‘Kawase’ blur. Limited number of passes Due to the computational, for example CPU, cost of issuing each render pass we limit RRK to 5 passes even at high blur radii. We are able to do this without visual artefacts due to randomised filter kernel rotation suppressing repetitive patterns. The previously detailed blur algorithms use 7+ render passes (for Kawase 7 passes at blur radii of 42 pixels and higher). If we limit the other blur algorithms to 5 passes, we see visual artefacts and repetitive patterns appear within typical Android UI blur radius ranges. These blur radii can reach up to 350 pixels for certain UI elements. Dynamic number of passes To increase performance at lower blur radii RRK uses 1, 3 or 5 render passes. At radii below the 3 pass threshold, a single combined downscale and blur pass is executed. As the radius exceeds the 3 pass threshold, a further downscale &upscale pair of passes are added. Finally, a further pair of downscale &upscale passes are added when the radius exceeds the 5 pass radius threshold. K axis filter kernels Utilizing an K axis filter kernel (where 1 <K <5, for example a 3 or 4 axis filter kernel) allows the trade-off between a lower bandwidth (lower K) or higher quality (higher K) blur. A 3 axis RRK-3 filter kernel will reduce read bandwidth by more than 20% in comparison to a 4 axis RRK-4 filter with just a small reduction in blur image quality, whilst higher K values produce no significant gains in image quality. This allows matching of the blur filter kernel properties to the blur application and device capabilities. High quality at large blur radii RRK can generate high quality, large radius blurs without visual artefacts using just 5 render passes. This limited number of passes is made possible by adding kernel filter random rotation. For every blurred pixel we generate a random unit value which is then scaled to produce up to a 90° rotation for RRK-4 and 120° for RRK-3. The rotation ranges are due to the filter kernel rotational symmetry values for RRK-4 and RRK-3 respectively. This rotation allows us to generate very high blur radii without artefacts using a maximum of 5 render passes. Reduced impact of number of passes transitions for animated blur radius RRK is required to generate gradually changing blur radius effects as seen in typical UI transitions. As the blur radius increases, RRK transitions from 1 to 3 to 5 render passes. At each transition threshold we modify the effective radius to reduce the impact of further down &up sampling render passes The Android User Interface as an example. The default Android blur method is based on the Kawase blur algorithm. This algorithm uses between 1 and 7 render passes, based on the input blur radius. At a blur radius of 42 pixels and above the algorithm uses all 7 passes. For context, most blurred Android UI elements have a blur radius over 100 pixels and so will use all 7 render passes. Blur effects in Android typically vary in radius as UI elements transition visibility or are dragged in and out of view. This means the blur method should handle animated blur radii without visible steps. The invention proposes a more efficient algorithm for generating variable radius blurred images for use in graphical effects such as a mobile device User Interface. Other Uses for This Algorithm This approach is suitable for any effect in an application render pipeline requiring blur such as bloom effects, depth of field etc. The invention allows efficient generation of large radii blurs, for example by a GPU, without artefacts while in comparison to previous algorithms it uses a lower number of render passes, reduces texture sampling bandwidth and reduces processing unit, for example GPU, fragment fill rate. Optional In one example, generating the output image from the input image using the randomly rotated kernel comprises generating the output image from the input image using the randomly rotated kernel for each pixel of the input image. In one example, generating the output image from the input image using the randomly rotated kernel for each pixel of the input image comprises providing a random unit value for each pixel. In one example, the method comprises scaling the random unit value for each pixel, for example according to a number of axes of the randomly rotated kernel. In one example, the randomly rotated kernel comprises and / or is a K axis filter kernel, wherein 1 <K <5, for example wherein K = 3 or wherein K = 4. In one example, the randomly rotated kernel comprises and / or is a 3 axis or a 4 axis filter kernel. In one example, generating the output image from the input image comprises performing M down sampling render passes, for example successively, using the randomly rotated kernel, wherein M is a natural number greater than or equal to 1, for example 1, 2, 3, 4, 5 or more, optionally wherein the M down sampling render passes each comprise down sampling image resolution by 50%, preferably by 75%. In one example, generating the output image from the input image comprises performing N up sampling render passes, for example successively, using the randomly rotated kernel, wherein N is a natural number greater than or equal to 1, for example 1, 2, 3, 4, 5 or more, optionally wherein the N up sampling render passes each comprise up sampling image resolution by 200%. In one example, M = N + 1, for example wherein M = 1 and N = 0 or wherein M = 2 and N = 1 or wherein M = 3 and N = 2. In one example, M <3 and N <2. In one example, the output image resolution is equal to the down sampled image resolution where M = 1. In one example, M = N, for example wherein M = 1 and N = 1 or wherein M = 2 and N = 2. In one example, M <2 and N <2. In one example, the blur radius is in a range from 10 to 10,000, preferably in a range from 20 to 1,000, more preferably in a range from 40 to 5,000, for example at least 42, at least 97, at least 300 or at least 350. In one example, generating the output image from the input image using the randomly rotated kernel comprises generating the output image from the input image using the randomly rotated kernel comprising executing sin / cos maths instructions and / or querying a lookup table. In one example, the output image comprises and / or is a blurred image. In one example, the input image comprises and / or is a full HD image (1080p, 1920 x 1080 pixels), a 2K image (1440p, 2560 x 1440 pixels), a 4K image (2160p, 3840 x 2160 pixels), an 8K image (4320p, 7680 x 4320 pixels), a 1440 x 3088 pixels image, a 1080 x 2340 pixels image or higher resolution. In one example, generating the output image from the input image using the randomly rotated kernel comprises generating the output image from the input image using the randomly rotated kernel at a rate (i.e. a frame rate) of at least 24 fps, at least 30 fps, at least 60 fps or at least 120 fps. In one example, generating the output image from the input image using the randomly rotated kernel comprises generating the output image from the input image using the randomly rotated kernel at a rate (i.e. a frame rate) at least equal to the refresh rate of a display device. In one example, the method comprises displaying the output image. In one example, the method comprises acquiring the input image. Electronic device The second aspect provides an electronic device, for example a display device, including a computer comprising a processor and a memory, configured to: generate an output image from an input image using a randomly rotated kernel. The electronic apparatus may be configured to implement the method according to the first aspect. In one example, the electronic device comprises a display, wherein the electronic device is configured to display the output image on the display. In one example, the electronic device comprises a camera, wherein the electronic device is configured to acquire the input image using the camera. Computer, computer program, non-transient computer-readable storage medium The third aspect provides a computer comprising a processor and a memory configured to implement, at least in part, a method according to the first aspect, a computer program comprising instructions which, when executed by a computer comprising a processor and a memory, cause the computer to perform a method, at least in part, according to the first aspect or a non-transient computer-readable storage medium comprising instructions which, when executed by a computer comprising a processor and a memory, cause the computer to perform a method, at least in part, according to the first aspect. Definitions Throughout this specification, the term “comprising” or “comprises” means including the components) specified but not to the exclusion of the presence of other components. The term “consisting of’ or “consists of’ means including the components specified but excluding other components. Whenever appropriate, depending upon the context, the use of the term “comprises” or “comprising” may also be taken to include the meaning “consists essentially of’ or “consisting essentially of’, and also may also be taken to include the meaning “consists of’ or “consisting of’. The optional features set out herein may be used either individually or in combination with each other where appropriate and particularly in the combinations as set out in the accompanying claims. The optional features for each aspect or exemplary embodiment of the invention, as set out herein are also applicable to all other aspects or exemplary embodiments of the invention, where appropriate. In other words, the skilled person reading this specification should consider the optional features for each aspect or exemplary embodiment of the invention as interchangeable and combinable between different aspects and exemplary embodiments. Brief description of the drawings For a better understanding of the invention, and to show how exemplary embodiments of the same may be brought into effect, reference will be made, by way of example only, to the accompanying diagrammatic Figures, in which: Figure 1 schematically depicts Kawase Blur Filter Render Passes; Figure 2 schematically depicts ‘Dual Filter’ Kawase Blur Filter Render Passes; Figure 3 schematically depicts RRK-4 Up Sample + Down Sample Filter Kernels with Sample Weights; Figure 4 schematically depicts RRK-3 Up Sample + Down Sample Filter Kernels with Sample Weights; Figure 5 schematically depicts the effect of RRK-4 filter kernel rotation; Figure 6 schematically depicts filter kernel rotation for a Per Pixel Randomly Rotated Kernel Example (RRK-4); Figure 7 schematically depicts RRK-3 using a 3 axis randomised filter pattern; Figure 8 shows images of blur result with &without kernel rotation (RRK-4); Figure 9 schematically depicts Render Pass Logic; Figure 10 schematically depicts RRK 1 pass; Figure 11 schematically depicts RRK 3 pass; Figure 12 schematically depicts RRK 5 pass; Figure 13 shows 97 pixel Blur Comparative Render Passes Illustration; Figure 14 shows a bar chart of ‘GPU Render Passes’ Comparison of Kawase, Dual Filter Kawase and RRK; Figure 15 shows a bar chart of GPU Utilisation Comparison of Kawase, Dual Filter Kawase and RRK-4; Figure 16 shows a bar chart of GPU Read / Write Bandwidth Comparison of Kawase, Dual Filter Kawase and RRK-3 &RRK-4; Figure 17 shows a bar chart of GPU Read / Write Bandwidth Comparison of Dual Filter Kawase and RRK-3 &RRK-4; Figure 18 shows bar charts of CPU time spent in two Android UI composition routines: BackgroundBlurQ and drawLayersO. Figure 19 shows a bar chart showing current draw comparison between algorithms (Blur Test Application Samsung Exynos S906B SOC Total Current Drain); Figure 20 shows a bar chart showing current draw comparison between algorithms taking into account SOC idle power draw (Blur Test Application S906B Relative Current Drain). Detailed Description of the Drawings Kawase Blur Algorithm Figure 1 schematically depicts Kawase Blur Filter Render Passes. Masaki Kawase presented the first such filter for bloom effects in his Game Developer Conference (GDC) 2003 presentation “Frame Buffer Postprocessing Effects in DOUBLE-S.T.E.A.L (Wreckless)” As implemented in Android this multi pass filter uses from 1 to 7 render passes dependent on blur radius. A blur radius of 42 pixel or more uses all 7 passes. Figure 2 schematically depicts ‘Dual Filter’ Kawase Blur Filter Render Passes. An update to Kawase named ‘Dual Filter Kawase’ was presented by Marius Bjorge of Arm at SIGGRAPH 2015. This method added 50% resolution downscale render passes together with a matching number of upscale passes. The results closely approximate Kawase but with the benefit of reduced texture read / write bandwidth. Randomly Rotated Kernel (RRK) Blur Algorithm The RRK (Randomly Rotated Kernel) Blur Algorithm has been developed to generate a high-performance blur with the following features: • Reduced bandwidth, for example GPU bandwidth • Limited number of passes • Dynamic number of passes • K axis filter kernel, where 1 <K <5, for example a 3 or 4 axis filter kernel • High quality at large blur radii • Reduced impact of number of passes transitions for animated blur radius Reduced GPU Bandwidth RRK-3 is extremely efficient consuming 20% less read, for example GPU read, bandwidth than ‘Dual Kawase’ blur and 60% less read bandwidth than ‘Kawase’ blur. Limited number of passes Due to the computational, for example CPU, cost of issuing each render pass we limit RRK to 5 passes even at high blur radii. We are able to do this without visual artefacts due to randomised filter kernel rotation suppressing repetitive patterns. The previously detailed blur algorithms use 7+ render passes (for Kawase 7 passes at blur radii of 42 pixels and higher). If we limit the other blur algorithms to 5 passes, we see visual artefacts and repetitive patterns appear within typical Android UI blur radius ranges. These blur radii can reach up to 350 pixels for certain UI elements. Dynamic number of passes To increase performance at lower blur radii RRK uses 1, 3 or 5 render passes. At radii below the 3 pass threshold, a single combined downscale and blur pass is executed. As the radius exceeds the 3 pass threshold, a further downscale &upscale pair of passes are added. Finally, a further pair of downscale &upscale passes are added when the radius exceeds the 5 pass radius threshold. K axis filter kernels Utilizing an K axis filter kernel (where 1 <K <5, for example a 3 or 4 axis filter kernel) allows the trade-off between a lower bandwidth (lower K) or higher quality (higher K) blur. A 3 axis RRK-3 filter kernel will reduce read bandwidth by more than 20% in comparison to a 4 axis RRK-4 filter with just a small reduction in blur image quality, whilst higher K values produce no significant gains in image quality. This allows matching of the blur filter kernel properties to the blur application and device capabilities. High quality at large blur radii RRK can generate high quality, large radius blurs without visual artefacts using just 5 render passes. This limited number of passes is made possible by adding kernel filter random rotation. For every blurred pixel we generate a random unit value which is then scaled to produce up to a 90° rotation for RRK-4 and 120° for RRK-3. The rotation ranges are due to the filter kernel rotational symmetry values for RRK-4 and RRK-3 respectively. This rotation allows us to generate very high blur radii without artefacts using a maximum of 5 render passes. Reduced impact of number of passes transitions for animated blur radius RRK is required to generate gradually changing blur radius effects as seen in typical UI transitions. As the blur radius increases, RRK transitions from 1 to 3 to 5 render passes. At each transition threshold we modify the effective radius to reduce the impact of further down &up sampling render passes The Android User Interface as an example. The default Android blur method is based on the Kawase blur algorithm. This algorithm uses between 1 and 7 render passes, based on the input blur radius. At a blur radius of 42 pixels and above the algorithm uses all 7 passes. For context, most blurred Android UI elements have a blur radius over 100 pixels and so will use all 7 render passes. Blur effects in Android typically vary in radius as UI elements transition visibility or are dragged in and out of view. This means the blur method should handle animated blur radii without visible steps. The invention proposes a more efficient algorithm for generating variable radius blurred images for use in graphical effects such as a mobile device User Interface. Other Uses for This Algorithm This approach is suitable for any effect in an application render pipeline requiring blur such as bloom effects, depth of field etc. Summary The invention allows a processing device, for example a GPU, to efficiently generate large radii blurs without artefacts while in comparison to previous algorithms, it uses a lower number of render passes, reduces texture sampling bandwidth and reduces GPU fragment fill rate. Dynamic Selection of Number of Render Passes Lower blur radii require less render passes so we dynamically select the render pass count. The selection is either 1, 3 or 5 render passes. Our method implements a % resolution first pass, then a further 1 or 2 pairs of downscale &upscale passes. Each added downscale render pass requires a matching upscale render pass. 1, 3, 5 Pass Transition To ensure smooth animated blur radius transitions, we reduce the visual impact of switching between 1, 3 &5 render passes by defining blur radius thresholds together with matching blur radius modifications. The number of render passes is selected according to the thresholds then the effective radius is accordingly modified. Per Fragment Filter Kernel Random Rotation To reduce the number of render passes needed to generate a high quality blur and to prevent visual artefacts or repetitive patterns at high blur radius, we implement a per fragment filter kernel random rotation. The non-rotated filter kernel offsets for up &down sampling (also known as scaling) render passes are shown in Figures 3 and 4. Each sample offset includes a sample weight. Each sample is read and multiplied by its weight, all samples are summed and divided by the filter kernel total sample weight. This creates a sample bias. Figure 3 schematically depicts RRK-4 Up Sample + Down Sample Filter Kernels with Sample Weights. Figure 4 schematically depicts RRK-3 Up Sample + Down Sample Filter Kernels with Sample Weights. Figure 5 schematically depicts the effect of RRK-4 filter kernel rotation. The effect of filter kernel offset rotations is shown in Figure 5. All offsets are relative to the currently generated blurred pixel located at sample ‘a’. For every pixel, a random rotation value is generated. Figure 6 schematically depicts filter kernel rotation for a Per Pixel Randomly Rotated Kernel Example (RRK-4). Figure 6 is a simple 2x2 pixel example of how a random rotation removes repetitive patterns using the RRK-4 filter kernel. For larger radii this is repeated over several passes which completely suppresses repetition pattern artefacts. The rotation angle is in the range 0° to 90° due to the filter kernel symmetry across the x and y axes. The red points show the centre of the pixel being blurred while the green points show the randomly rotated filter kernel positions. Figure 7 schematically depicts RRK-3 using a 3 axis randomised filter pattern. Figure 7 shows a visualisation of 3 passes of the randomly rotated 3 axis filter kernel used in the RRK-3 variant. The centre pixel is influenced by each sampling point depicted. Figure 8 shows images of blur result with &without kernel rotation (RRK-4). Figure 8 shows the effect of filter kernel rotation removing repetitive artefacts from large radius blurs. The middle image shows a 5 pass blur with visual artefacts and patterns. The right image shows the same image blurred with 5 passes but without artefacts and patterns due to per fragment random rotation. In summary the invention describes a method for efficiently generating blurred images with reduced computation, for example CPU, cost and reduced memory, for example GPU, read / write bandwidth requirements. RRK Multi Pass Blur Sequence Overview RRK uses 1, 3 or 5 render passes based on the required blur radius. Each downscale render pass reads image samples from the larger source image using the rotated downscale filter kernel. Each upscale render pass reads image samples from the 50% sized source image using the rotated up-sample filter kernel. Figure 9 schematically depicts Render Pass Logic. Figure 9 shows the overall render pass logic flow with the output of each pass becoming the input of the next. Figure 10 schematically depicts RRK 1 pass. As shown in Figure 10, the 1 render pass method downscales to % resolution with rotated blur. Figure 11 schematically depicts RRK 3 pass. The 3 render pass method firstly downscales to % resolution with rotated blur followed by a 50% down scale and a 200% upscale pass. Figure 12 schematically depicts RRK 5 pass. The 5 render pass method firstly downscales to % resolution with rotated blur followed by a pair of 50% downscale passes then a matching pair of 200% upscale passes. Alternative implementations of the invention Optional Down Scale Render Pass For our implementation, with our target device screen pixel density we first implement a down scale render pass. We down scale to 25% of input image resolution leading to an effective reduction in GPU read / write bandwidth of 93.75%. For other devices with lower resolution, for example lower DPI, screens this pass can be omitted or the down scale percentage can be adjusted as required. If the downscale pass is omitted this would lead to 2 or 4 render passes being utilised instead of 1,3 or 5 in our implementation. Rotation angle lookups In our implementations’ shader code, we utilise sin / cos math instructions to perform the filter kernel rotation. For processing devices, for example GPUs, where these instructions are expensive a simple lookup table can be utilised to provide a fixed number of potential random rotations. Advantages &Novel features of the invention The invention generates high quality, CPU &GPU efficient blurs by adding filter kernel random rotation to a reduced number of render passes together with a mechanism to reduce visual steps between render pass counts. The invention enables the use of blurring effects to be extended to lower end, lesser computationally capable display devices due to reduced memory bandwidth requirements. For example, the invention enables the use of blur to be expanded to lower end mobile devices and TV SOC’s due to reduced GPU bandwidth requirements. The invention shows the following advantages in comparison to Kawase &Dual Filter Kawase: • In comparison to Kawase, RRK-3 has o Much lower read (-60%) and much lower write (-63%) bandwidth o Fewer render passes (5 vs 7) leading to lower CPU composition time • In comparison to Dual Filter Kawase, RRK-3 has o 20% lower read bandwidth o Fewer render passes (5 vs 9) leading to lower CPU composition time o A method to reduce visual steps when switching between 1,3 or 5 passes o Better Image quality for large blur radii Differentiation & Novel Aspects The industry standard approach to implementing an efficient blur typically entails a multi pass blur algorithm such as Kawase or latterly Dual Filter Kawase. The inventors’ approach extends the multi pass algorithm to include kernel filter rotation together with dynamic render pass counts with a maximum of 5 passes RRK proves to be more bandwidth efficient, for example for CPU &GPU, while producing large radius blurs without artefacts. Testing Results of the invention Comparative Performance Figures 13 and 14 show the maximum number of render passes used by RRK blur algorithm vs typical number of render passes for other algorithms. A lower number of render passes used in blur generation results in a lower CPU load. For a 97x97 pixel blur, Kawase, Dual Kawase and RRK execute the 7, 8 and 5 render passes respectively. This is shown in Figures 13 and 14. As is shown, RRK issues 5 render passes. Figure 13 shows 97 pixel Blur Comparative Render Passes Illustration. Figure 14 shows a bar chart of ‘GPU Render Passes’ Comparison of Kawase, Dual Filter Kawase and RRK. GPU Occupancy We measured GPU occupancy % (utilisation %) while running an Android based blur test application. This application draws a blurred image with a repeatedly varying blur radius (0 pixel -> 300 pixel -> 0 pixel). Measurements were recorded on an Exynos S906B device. Figure 15 shows a bar chart of GPU Utilisation Comparison of Kawase, Dual Filter Kawase and RRK-4. The GPU occupancy is an overall system measurement which will include all system UI composition tasks including the blur test application. We observe a 9% reduction in GPU occupancy when using RRK-4 in comparison to Kawase together with a 3% reduction when comparing RRK-4 to Dual Kawase. GPU Bandwidth Figures 16 and 17 show read &write bandwidth of each blur algorithm. Both Dual Filter Kawase &RRK use much less bandwidth than Kawase. RRK-3 consumes 20% less bandwidth than Dual Filter Kawase and can produce large radii blur without artefacts while also using less CPU time, due to issuing at most 5 GPU render passes. Figure 16 shows a bar chart of GPU Read / Write Bandwidth Comparison of Kawase, Dual Filter Kawase and RRK-3 &RRK-4 and Table 1 summaries RRK bandwidth comparison to Kawase (@7 pass). Read Bandwidth Reduction Write Bandwidth Reduction RRK-4 52.6% 63.4% RRK-3 60.0% 63.4% Table 1: RRK bandwidth comparison to Kawase (@7 pass) Figure 17 shows a bar chart of GPU Read / Write Bandwidth Comparison of Dual Filter Kawase and RRK-3 &RRK-4 and Table 2 summarises RRK bandwidth comparison to Dual Kawase (@9 pass). Read Bandwidth Reduction Write Bandwidth Reduction RRK-4 4.2% 3.8% RRK-3 20.0% 3.8% Table 2: RRK bandwidth comparison to Dual Kawase (@9 pass) CPU Time Due to RRK using a lower number of render passes in comparison to Kawase and Dual Kawase, we can measure a reduction in CPU time when blurring images within the Android UI composition process. Figure 18 shows bar charts of CPU time spent in two Android UI composition routines: BackgroundBlurQ and drawLayersQ. When executing ‘BackGroundBlur’ with each algorithm and taking Kawase as a baseline: • RRK reduces CPU time by 21% • Dual Kawase increases CPU time by 22% For composition routine ‘DrawLayers’, taking Kawase as a baseline . RRK reduces CPU time by 8% • Dual Kawase increases CPU time by 7% These results are as expected due to RRK issuing fewer render passes than the other algorithms. Power Use Figure 19 shows a bar chart showing current draw comparison between algorithms (Blur Test Application Samsung Exynos S906B SOC Total Current Drain). We measured battery current drain while running an Android based blur test application. This application draws a blurred image with a repeatedly varying blur radius (0 pixel -> 300 pixel -> 0 pixel). Kawase executes 7 passes, Dual Kawase 8 passes and RRK-4 executes 5 passes. Measurements were recorded on an Exynos S906B device. For total SOC current drain we measured an 8% reduction using RRK blur compared to using Kawase blur. Recording Perfetto trace item ‘batt.current_ua’ gives the following results: Figure 20 shows a bar chart showing current draw comparison between algorithms taking into account SOC idle power draw (Blur Test Application S906B Relative Current Drain). A more accurate power draw comparison between algorithms takes into account SOC idle power draw. After subtracting idle power draw we measured the following specific power draw values for each blur algorithm. RRK-4 is 17% lower than Kawase and 21 % lower than Dual Kawase. Although a preferred embodiment has been shown and described, it will be appreciated by those skilled in the art that various changes and modifications might be made without departing from the scope of the invention, as defined in the appended claims and as described above. At least some of the example embodiments described herein may be constructed, partially or wholly, using dedicated special-purpose hardware. Terms such as ‘component’, ‘module’ or ‘unit’ used herein may include, but are not limited to, a hardware device, such as circuitry in the form of discrete or integrated components, a Field Programmable Gate Array (FPGA) or Application Specific Integrated Circuit (ASIC), which performs certain tasks or provides the associated functionality. In some embodiments, the described elements may be configured to reside on a tangible, persistent, addressable storage medium and may be configured to execute on one or more processors. These functional elements may in some embodiments include, by way of example, components, such as software components, object-oriented software components, class components and task components, processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays, and variables. Although the example embodiments have been described with reference to the components, modules and units discussed herein, such functional elements may be combined into fewer elements or separated into additional elements. Various combinations of optional features have been described herein, and it will be appreciated that described features may be combined in any suitable combination. In particular, the features of any one example embodiment may be combined with features of any other embodiment, as appropriate, except where such combinations are mutually exclusive. Throughout this specification, the term “comprising” or “comprises” means including the components) specified but not to the exclusion of the presence of others. Attention is directed to all papers and documents which are filed concurrently with or previous to this specification in connection with this application and which are open to public inspection with this specification, and the contents of all such papers and documents are incorporated herein by reference. All of the features disclosed in this specification (including any accompanying claims, abstract and drawings), and / or all of the steps of any method or process so disclosed, may be combined in any combination, except combinations where at least some of such features and / or steps are 5 mutually exclusive. Each feature disclosed in this specification (including any accompanying claims, abstract and drawings) may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise. Thus, unless expressly stated otherwise, each 10 feature disclosed is one example only of a generic series of equivalent or similar features. The invention is not restricted to the details of the foregoing embodiment(s). The invention extends to any novel one, or any novel combination, of the features disclosed in this specification (including any accompanying claims, abstract and drawings), or to any novel one, or any novel 15 combination, of the steps of any method or process so disclosed.

Claims

1. A method of rendering blurred images, the method implemented by a computer comprising a processor and a memory, the method comprising:generating an output image from an input image using a randomly rotated kernel.

2. The method according to claim 1, wherein generating the output image from the input image using the randomly rotated kernel comprises generating the output image from the input image using the randomly rotated kernel for each pixel of the input image.

3. The method according to claim 2, wherein generating the output image from the input image using the randomly rotated kernel for each pixel of the input image comprises providing a random unit value for each pixel.

4. The method according to claim 3, comprising scaling the random unit value for each pixel, for example according to a number of axes of the randomly rotated kernel.

5. The method according to any previous claim, wherein the randomly rotated kernel comprises and / or is a K axis filter kernel, where 1 <K <5, for example wherein K = 3 or wherein K = 4,6. The method according to any previous claim, wherein generating the output image from the input image comprises performing M down sampling render passes, for example successively, using the randomly rotated kernel, wherein M is a natural number greater than or equal to 1, for example 1, 2, 3, 4, 5 or more, optionally wherein the M down sampling render passes each comprise down sampling image resolution by 50%, preferably by 75%.

7. The method according to claim 6, wherein generating the output image from the input image comprises performing N up sampling render passes, for example successively, using the randomly rotated kernel, wherein N is a natural number greater than or equal to 1, for example 1, 2, 3, 4, 5 or more, optionally wherein the N up sampling render passes each comprise up sampling image resolution by 200%.

8. The method according to claim 7, wherein M = N + 1, for example wherein M = 1 and N = 0 or wherein M = 2 and N = 1 or wherein M = 3 and N = 2.

9. The method according to claim 8, wherein M <3 and N <2.

10. The method according to any of claims 6 to 9, wherein the output image resolution is equal to the down sampled image resolution where M = 1.

11. The method according to claim 7, wherein M = N, for example wherein M = 1 and N = 1 or wherein M = 2 and N = 2.

12. The method according to claim 11, wherein M <2 and N <2.

13. The method according to any previous claim, wherein the blur radius is in a range from 10 to 10,000, preferably in a range from 20 to 1,000, more preferably in a range from 40 to 5,000, for example at least 42, at least 97, at least 300 or at least 350.

14. The method according to any previous claim, generating the output image from the input image using the randomly rotated kernel comprises generating the output image from the input image using the randomly rotated kernel comprising executing sin / cos maths instructions and / or querying a lookup table.

15. The method according to any previous claim, wherein the output image comprises and / or is a blurred image.

16. The method according to any previous claim, wherein the input image comprises and / or is a full HD image (1080p, 1920 x 1080 pixels), a 2K image (1440p, 2560 x 1440 pixels), a 4K image (2160p, 3840 x 2160 pixels), an 8K image (4320p, 7680 x 4320 pixels), a 1440 x 3088 pixels image, a 1080 x 2340 pixels image or higher resolution.

17. The method according to any previous claim, wherein generating the output image from the input image using the randomly rotated kernel comprises generating the output image from the input image using the randomly rotated kernel at a rate (i.e. a frame rate) at least equal to the refresh rate of a display device.

18. The method according to any previous claim, comprising displaying the output image.

19. The method according to any previous claim, comprising acquiring the input image.

20. An electronic device, for example a display device, including a computer comprising a processor and a memory, configured to:generate an output image from an input image using a randomly rotated kernel.

21. The electronic device according to claim 20, comprising a display, wherein the electronic device is configured to display the output image on the display.

22. The electronic device according to any of claims 20 to 21, comprising a camera, wherein the electronic device is configured to acquire the input image using the camera.

Images