We present a new method, Motion Picture Texture Compression (MPTC), to compress a series of video frames into a compressed video-texture format, such that the decoded output can be rendered using commodity texture mapping hardware. Our approach reduces the file size of compressed textures by exploiting redundancies in both the temporal and spatial domains. Furthermore, we ensure that the overall rendering quality of the compressed video-textures is comparable to that of compressed image-textures. At runtime, we render each frame of the video decoded from the MPTC format using texture mapping hardware on GPUs. Overall, MPTC improves the bandwidth from CPU to GPU memory up to 4−6× ona desktop and enables rendering of high-resolution videos (2K or higher) on current Head Mounted Displays (HMDs). We observe 3 − 4× improvement in rendering speeds for rendering high-resolution videos on desktop. Furthermore, we observe 9 − 10× improvement in frame rate on mobile platforms using a series of compressed-image textures for rendering high-resolution videos.

Abstract Recent advances in computer graphics have relied on high‐quality textures in order to generate photorealistic real‐time images. Texture compression standards meet these growing demands for data, but current texture compression schemes use fixed‐rate methods where statically sized blocks of pixels are represented using the same numbers of bits irrespective of their data content. In order to account for the natural variation in detail, we present an alternative format that allows variable bit‐rate texture compression with minimal changes to texturing hardware. Our proposed scheme uses one additional level of indirection to allow the variation of the block size across the same texture. This single change is exploited to both vary the amount of bits allocated to certain parts of the texture and to duplicate redundant texture information across multiple pixels. To minimize hardware changes, the method picks combinations of block sizes and compression methods from existing fixed‐rate standards. With this approach, our method is able to demonstrate energy savings of up to 50%, as well as higher quality compressed textures over current state of the art techniques.

Modern GPUs supporting compressed textures allow interactive application developers to save scarce GPU resources such as VRAM and bandwidth. Compressed textures use fixed compression ratios whose lossy representations are significantly poorer quality than traditional image compression formats such as JPEG. We present a new method in the class of supercompressed textures that provides an additional layer of compression to already compressed textures. Our texture representation is designed for endpoint compressed formats such as DXT and PVRTC and decoding on commodity GPUs. We apply our algorithm to commonly used formats by separating their representation into two parts that are processed independently and then entropy encoded. Our method preserves the CPU-GPU bandwidth during the decoding phase and exploits the parallelism of GPUs to provide up to 3X faster decode compared to prior texture supercompression algorithms. Along with the gains in decoding speed, our method maintains both the compression size and quality of current state of the art texture representations.

We present an algorithm to accelerate resolution independent curve rendering on mobile GPUs. Recent trends in graphics hardware have created a plethora of compressed texture formats specific to GPU manufacturers. However, certain implementations of platform independent path rendering require generating grayscale textures on the CPU containing the extent that each pixel is covered by the curve. In this paper, we demonstrate that generating a compressed grayscale texture prior to uploading it to the GPU creates faster rendering times in addition to the memory savings. We implement a real-time compression technique for coverage masks and compare our results against the GPU-based implementation of the highly optimized Skia rendering library. We also analyze the worst case properties of our compression algorithms. We observe up to a 2 × speed improvement over the existing GPU-based methods in addition to up to a 9:1 improvement in GPU memory gains. We demonstrate the performance on multiple mobile platforms.

We present an algorithm to accelerate resolution independent curve rendering on mobile GPUs. The bottleneck for certain platform independent GPU implementations is in generating grayscale textures on the CPU containing the amount that each pixel is covered by the curve. In this paper, we demonstrate that generating a compressed grayscale texture prior to uploading it to the GPU creates faster rendering times in addition to the memory savings. We implement a real-time compression technique for coverage masks and compare our results against the GPU-based implementation of the highly optimized Skia rendering library. We observe up to a 2X speed improvement over the existing GPU-based methods in addition to up to a 9:1 improvement in GPU memory gains. We demonstrate the performance on multiple mobile platforms.

We present a real-time algorithm for compressing textures based on low frequency signal modulated (LFSM) texture compression. Our formulation is based on intensity dilation and exploits the notion that the most important features of an image are those with high contrast ratios. We present a simple two pass algorithm for propagating the extremal intensity values that contribute to these contrast ratios into the compressed encoding. We use our algorithm to compress PVRTC textures in real-time and compare our performance with prior techniques in terms of speed and quality. http://gamma.cs.unc.edu/FasTC

We present a new algorithm for encoding low dynamic range images into fixed-rate texture compression formats. Our approach provides orders of magnitude improvements in speed over existing publicly-available compressors, while generating high quality results. The algorithm is applicable to any fixed-rate texture encoding scheme based on Block Truncation Coding and we use it to compress images into the OpenGL BPTC format. The underlying technique uses an axis-aligned bounding box to estimate the proper partitioning of a texel block and performs a generalized cluster fit to compute the endpoint approximation. This approximation can be further refined using simulated annealing. The algorithm is inherently parallel and scales with the number of processor cores. We highlight its performance on low-frequency game textures and the high frequency Kodak Test Image Suite.

Estimation of tissue stiffness is an important means of noninvasive cancer detection. Existing elasticity reconstruction methods usually depend on a dense displacement field (inferred from ultrasound orMR images) and known external forces.Many imaging modalities, however, cannot provide details within an organ and therefore cannot provide such a displacement field. Furthermore, force exertion and measurement can be difficult for some internal organs, making boundary forces another missing parameter. We propose a general method for estimating elasticity and boundary forces automatically using an iterative optimization framework, given the desired (target) output surface. During the optimization, the input model is deformed by the simulator, and an objective function based on the distance between the deformed surface and the target surface is minimized numerically. The optimization framework does not depend on a particular simulation method and is therefore suitable for different physical models. We show a positive correlation between clinical prostate cancer stage (a clinical measure of severity) and the recovered elasticity of the organ. Since the surface correspondence is established, our method also provides a non-rigid image registration, where the quality of the deformation fields is guaranteed, as they are computed using a physics-based simulation.

Simulating fluids in large-scale scenes with appreciable quality using state-of-the-art methods can lead to high memory and compute requirements. Since memory requirements are proportional to the product of domain dimensions, simulation performance is limited by memory access, as solvers for elliptic problems are not compute-bound on modern systems. This is a significant concern for large-scale scenes. To reduce the memory footprint and memory/compute ratio, vortex singularity bases can be used. Though they form a compact bases for incompressible vector fields, robust and efficient modeling of nonrigid obstacles and free-surfaces can be challenging with these methods. We propose a hybrid domain decomposition approach that couples Eulerian velocity-based simulations with vortex singularity simulations. Our formulation reduces memory footprint by using smaller Eulerian domains with compact vortex bases, thereby improving the memory/compute ratio, and simulation performance by more than 1000x for single phase flows as well as significant improvements for free-surface scenes. Coupling these two heterogeneous methods also affords flexibility in using the most appropriate method for modeling different scene features, as well as allowing robust interaction of vortex methods with free-surfaces and nonrigid obstacles.