Community hub
0 subscribers7 pages, 0 posts
Recent from talks
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Welcome to the community hub built to collect knowledge and have discussions related to Bitmap.
Nothing was collected or created yet.
Bitmap
View on Wikipediafrom Wikipedia
 | This article needs additional citations for verification. (April 2024) |
In computing, a bitmap (also called raster) graphic is an image formed from rows of different colored pixels.[1] A GIF is an example of a graphics image file that uses a bitmap.[2]
As a noun, the term "bitmap" is very often used to refer to a particular bitmapping application: the pix-map, which refers to a map of pixels, where each pixel may store more than two colors, thus using more than one bit per pixel. In such a case, the domain in question is the array of pixels which constitute a digital graphic output device (a screen or monitor). In some contexts, the term bitmap implies one bit per pixel, whereas pixmap is used for images with multiple bits per pixel.[3][4]
A bitmap is a type of memory organization or image file format used to store digital images. The term bitmap comes from the computer programming terminology, meaning just a map of bits, a spatially mapped array of bits. Now, along with pixmap, it commonly refers to the similar concept of a spatially mapped array of pixels. Raster images in general may be referred to as bitmaps or pixmaps, whether synthetic or photographic, in files or memory.
Many graphical user interfaces use bitmaps in their built-in graphics subsystems.[5] For example, the Microsoft Windows and OS/2 platforms' GDI subsystem uses the Windows and OS/2 bitmap file format, usually named with the file extension .BMP (or .DIB for device-independent bitmap). Besides BMP, other file formats that store literal bitmaps include InterLeaved Bitmap (ILBM), Portable Bitmap (PBM), X Bitmap (XBM), and Wireless Application Protocol Bitmap (WBMP). Similarly, most other image file formats, such as JPEG, TIFF, PNG, and GIF, also store bitmap images (as opposed to vector graphics), but they are not usually referred to as bitmaps, since they use compressed formats internally.
Pixel storage
[edit]In typical uncompressed bitmaps, image pixels are generally stored with a variable number of bits per pixel which identify its color (the color depth). Pixels of 8 bits and fewer can represent either grayscale or indexed color. An alpha channel (for transparency) may be stored in a separate bitmap, where it is similar to a grayscale bitmap, or in a fourth channel that, for example, converts 24-bit images to 32 bits per pixel.
The bits representing the bitmap pixels may be packed or unpacked (spaced out to byte or word boundaries), depending on the format or device requirements. Depending on the color depth, a pixel in the picture will occupy at least n/8 bytes, where n is the bit depth.
For an uncompressed, packed-within-rows bitmap, such as is stored in Microsoft DIB or BMP file format, or in uncompressed TIFF format, a lower bound on storage size for a n-bit-per-pixel (2n colors) bitmap, in bytes, can be calculated as:
where width and height are given in pixels.
In the formula above, header size and color palette size, if any, are not included. Due to effects of row padding to align each row start to a storage unit boundary, such as a word, additional bytes may be needed.
Device-independent bitmaps and BMP file format
[edit]Microsoft has defined a particular representation of color bitmaps of different color depths, as an aid to exchanging bitmaps between devices and applications with a variety of internal representations. They called these device-independent bitmaps "DIBs", and the file format for them is called DIB file format or BMP file format. According to Microsoft support:[6]
A device-independent bitmap (DIB) is a format used to define device-independent bitmaps in various color resolutions. The main purpose of DIBs is to allow bitmaps to be moved from one device to another (hence, the device-independent part of the name). A DIB is an external format, in contrast to a device-dependent bitmap, which appears in the system as a bitmap object (created by an application...). A DIB is normally transported in metafiles (usually using the StretchDIBits() function), BMP files, and the Clipboard (CF_DIB data format).
Here, "device independent" refers to the format, or storage arrangement, and should not be confused with device-independent color.
Other bitmap file formats
[edit]The X Window System uses a similar XBM format for black-and-white images, and XPM (pixelmap) for color images. Numerous other uncompressed bitmap file formats are in use, though most not widely.[7] For most purposes, standardized compressed bitmap files such as GIF, PNG, TIFF, and JPEG are used. Lossless compression in particular provides the same information as a bitmap in a smaller file size.[8] TIFF and JPEG have various options. JPEG is usually lossy compression. TIFF is usually either uncompressed, or lossless Lempel–Ziv–Welch compressed like GIF. PNG uses deflate lossless compression, another Lempel-Ziv variant.
There are also a variety of "raw" image files, which store raw bitmaps with no other information. Such raw files are just bitmaps in files, often with no header or size information (they are distinct from photographic raw image formats, which store raw unprocessed sensor data in a structured container such as TIFF format along with extensive image metadata).
See also
[edit]- Free space bitmap, an array of bits that tracks which disk storage blocks are in-use
- Raster graphics
- Raster scan
- Rasterization
- Sprite (computer graphics)
- Voxels
- Vector graphics
- Image tracing
References
[edit]- ^ "ARCHIVED: What are bitmap and vector graphics, and how are they different". University Information Technology Servivces. September 22, 2023. Archived from the original on April 21, 2024. Retrieved April 21, 2024.
- ^ Gregersen, Erik (January 26, 2022). "bitmap". Encyclopædia Britannica. Archived from the original on April 21, 2024. Retrieved April 21, 2024.
- ^ James D. Foley (1995). Computer Graphics: Principles and Practice. Addison-Wesley Professional. p. 13. ISBN 0-201-84840-6.
The term bitmap, strictly speaking, applies only to 1-bit-per-pixel bilevel systems; for multiple-bit-per-pixel systems, we use the more general term pix-map (short for pixel map).
- ^ V.K. Pachghare (2005). Comprehensive Computer Graphics: Including C++. Laxmi Publications. p. 93. ISBN 81-7008-185-8.
- ^ Julian Smart; Stefan Csomor & Kevin Hock (2006). Cross-Platform GUI Programming with Wxwidgets. Prentice Hall. ISBN 0-13-147381-6.
- ^ "DIBs and Their Uses". Microsoft Help and Support. 2005-02-11.
- ^ "List of bitmap file types". File-Extensions.org.
- ^ J. Thomas; A. Jones (2006). Communicating Science Effectively: a practical handbook for integrating visual elements. IWA Publishing. ISBN 1-84339-125-2.
Bitmap
View on Grokipediafrom Grokipedia
A bitmap is a digital image representation composed of a rectangular grid of pixels, where each pixel is defined by a specific color value encoded using one or more bits, forming the basis of raster graphics.[1] This structure allows computers to store, process, and display visual information by mapping binary data directly to screen elements or file formats.[2]
The key characteristics of bitmaps include their resolution, determined by the number of pixels (width and height), and bit depth, which specifies the range of colors available—for instance, 1 bit per pixel supports 2 colors (monochrome), 8 bits supports 256 colors, and 24 bits enables over 16 million colors through RGB components.[1] Bitmaps may use a color palette for indexed formats or store color data directly, and they often include metadata such as dimensions and compression details.[3] Unlike vector graphics, which use mathematical equations for scalable shapes, bitmaps are fixed-resolution and can appear pixelated when enlarged, making them ideal for capturing photographic details but less suitable for resizing without quality loss.[4]
Common file formats for bitmaps include the BMP (Bitmap Image File) format, developed by Microsoft in the late 1980s as a device-independent standard for storing uncompressed or run-length encoded raster images on Windows systems.[5] Other widely used formats are JPEG for lossy compression of photographs, PNG for lossless compression with transparency support, and TIFF for high-quality archival imaging, each balancing file size, quality, and functionality for applications like web display, printing, and digital preservation.[6] Bitmaps originated in early computer graphics during the 1970s, with pioneering systems like Xerox PARC's Alto using single-bit-per-pixel frame buffers to render simple displays, evolving from basic memory mapping to support complex color imaging in modern computing.[7] Today, bitmaps underpin digital photography, video games, user interfaces, and scientific visualization, enabling precise pixel-level manipulation while posing challenges in storage due to their data-intensive nature.[4]
This grid forms a checkerboard-like image, demonstrating how individual pixel assignments collectively create the overall visual.[8]
Fundamentals
Definition and Characteristics
A bitmap is a type of raster image that represents digital visuals through a grid of discrete pixels, where each pixel encodes a specific color or intensity value.[8] This grid-based structure allows bitmaps to capture detailed visual information by assigning values to individual picture elements, forming the foundational method for storing and displaying computer-generated images.[1] Key characteristics of bitmaps include their fixed resolution, defined by the number of pixels in width and height, which determines the image's detail level but limits scalability.[9] When enlarged beyond the original resolution, bitmaps exhibit pixelation, as the finite grid becomes visibly blocky without additional data to interpolate finer details.[8] This makes bitmaps particularly suitable for complex, non-geometric images such as photographs, where they excel at rendering smooth gradients, textures, and natural variations in color and shading.[1] In terminology, bitmaps fall under the broader category of raster graphics, which encompass any pixel-array representations, though "bitmap" specifically emphasizes the bit-level encoding of pixel data.[10] Unlike vector graphics, which use mathematical descriptions for scalable rendering, bitmaps rely on this fixed pixel matrix, prioritizing fidelity to photographic realism over infinite resizing.[9] For illustration, consider a simple 2x2 bitmap grid representing a basic pattern, where each cell denotes a pixel's color value:| Pixel (0,0) | Pixel (0,1) |
|---|---|
| Black | White |
| Pixel (1,0) | Pixel (1,1) |
|---|---|
| White | Black |
Pixels and Resolution
In a bitmap image, a pixel serves as the smallest addressable element, forming a two-dimensional grid where each pixel is defined by its position in terms of row and column coordinates and by its value, which represents either a color or a grayscale intensity.[11][12] This grid structure allows for precise mapping of visual data, with the pixel's value determining how it contributes to the overall image appearance.[13] Resolution in bitmaps is characterized by metrics such as the total pixel count, calculated as the product of the image's width and height in pixels, and the density measures of pixels per inch (PPI) or dots per inch (DPI), which indicate how many pixels fit into a linear inch when the image is displayed or printed.[14] Higher PPI or DPI values enable greater detail in the rendered image by packing more pixels into the same physical space, but bitmaps exhibit limited scalability; enlarging a low-resolution image beyond its native pixel dimensions results in pixelation and loss of sharpness, as no additional detail can be interpolated without artifacts.[15][16] The file size of an uncompressed bitmap is directly tied to its resolution, with the pixel data portion computed as the total number of pixels multiplied by the bytes required per pixel; for example, in an 8-bit grayscale image where each pixel uses 1 byte, the size equals width × height × 1 byte.[17] Increasing resolution enhances visual fidelity by capturing finer details, but it proportionally escalates storage requirements—doubling both width and height quadruples the pixel count and thus the file size—and demands more computational resources for processing tasks like rendering or filtering, due to the larger dataset involved.[11][18]Storage Mechanisms
In-Memory Representation
In raster graphics systems, bitmaps are typically stored in memory using a row-major order, where pixels are arranged sequentially by scanlines from top to bottom and left to right, forming a linear array that facilitates efficient traversal during rendering.[19] This layout aligns with the horizontal scanning pattern of display devices, allowing hardware and software to process entire rows contiguously for improved cache performance and reduced memory access latency.[20] To optimize memory access and hardware compatibility, each scanline is often padded with extra bytes to ensure alignment to boundaries such as 4 or 32 bytes, preventing fragmentation and enabling faster SIMD operations or DMA transfers.[19] The storage efficiency of bitmaps in memory depends on the bit depth, which determines how pixels are packed into bytes. For 1-bit monochrome images, each bit represents a pixel (e.g., 0 for black, 1 for white), allowing 8 pixels per byte through bit packing.[21] In 4-bit formats supporting 16 colors, two pixels are packed per byte, with each pixel using the upper and lower 4 bits.[22] Similarly, 8-bit indexed color modes store one pixel per byte, referencing a palette of up to 256 entries. These packing schemes minimize memory usage for lower-depth images while requiring unpacking operations for access. Pixel values within these formats are interpreted via color encoding schemes like RGB or indexed palettes. A practical example of memory layout is a 640×480 bitmap at 24-bit depth (8 bits per RGB channel), which requires 640 × 480 × 3 = 921,600 bytes for the raw pixel data, excluding padding.[20] With row padding to 4-byte alignment, each scanline of 640 pixels (1,920 bytes) remains unpadded since it is already a multiple of 4, but narrower images would add trailing bytes per row to meet the boundary. This results in a total allocation slightly larger than the raw size to accommodate alignment. Accessing pixels in this in-memory representation uses direct indexing, such as offset = y × (width × bytes_per_pixel + padding) + x × bytes_per_pixel, enabling constant-time retrieval for point operations like color sampling.[20] In graphics APIs like OpenGL or Vulkan, this linear layout supports efficient texture uploads and fragment shader reads, where sequential scanline access boosts rendering throughput by leveraging GPU memory coalescing and minimizing bank conflicts.[19]Color Encoding
Color encoding in bitmaps refers to the methods used to represent the color or intensity of each pixel within the image data structure. The choice of encoding determines the range of colors or shades that can be displayed and influences storage efficiency and rendering capabilities. Common approaches include indexed (palette-based) and direct color models, which vary in bit depth—the number of bits allocated per pixel—to balance color fidelity with memory usage.[23] Bit depth levels define the granularity of color representation in bitmaps. A 1-bit depth supports only two colors, typically black and white, where each pixel is either on (1) or off (0), suitable for simple binary images like line art or text.[8] An 8-bit depth allows for 256 distinct values, often used in paletted modes for limited color images or 256 shades of gray in grayscale variants.[24] At 24 bits per pixel, known as true color, each pixel encodes approximately 16.7 million colors by allocating 8 bits each to red, green, and blue components in the RGB model.[12] Extending to 32 bits adds an 8-bit alpha channel to the 24-bit RGB, enabling per-pixel transparency levels from fully opaque to fully transparent.[23] In palette-based encoding, also called indexed color, pixel values store indices rather than direct color data, referencing a separate color lookup table (CLUT) that maps each index to an actual color, typically in RGB format. This approach conserves space for images with few distinct colors; for instance, an 8-bit bitmap uses a 256-entry palette where each entry is a 24-bit RGB triplet, allowing efficient rendering by substituting indices with palette colors during display.[24] The palette itself is stored alongside the pixel data, and its size matches the bit depth (e.g., 16 entries for 4-bit). This method was particularly prevalent in early computing and web graphics to reduce file sizes without sacrificing visual quality in constrained environments. Direct color models store color components explicitly in each pixel without a palette, providing greater flexibility for high-fidelity images. The RGB model, the most common for on-screen display, allocates bits directly to red, green, and blue primaries; for example, 8 bits per channel in a 24-bit bitmap yields 256 levels per primary, combining additively to form the full color spectrum.[12] For print applications, the CMYK model uses subtractive primaries—cyan, magenta, yellow, and black—with similar bit allocations (e.g., 32 bits total for 8 bits each), absorbing light to produce colors on paper.[25] Grayscale variants simplify to a single channel, where bit depth determines shades of gray; an 8-bit grayscale bitmap supports 256 levels from black to white, ideal for monochrome photography or scientific imaging.[23] Transparency in bitmaps is handled through additional channels or masks to composite images over backgrounds. The alpha channel in a 32-bit ARGB format stores an opacity value (0-255) per pixel, where 0 is fully transparent and 255 is opaque, allowing smooth blending via formulas like the standard alpha compositing equation.[26] For simpler cases, a bitmask provides binary transparency, designating pixels as fully transparent or opaque based on a threshold color or separate mask bitmap, commonly used in legacy formats for cutouts or sprites.[23]| Color Depth | Bits per Pixel | Color Count | Typical Use | Encoding Type |
|---|---|---|---|---|
| 1-bit | 1 | 2 | Monochrome | Binary (B/W) |
| 8-bit | 8 | 256 | Paletted or Grayscale | Indexed or Single Channel |
| 24-bit | 24 | 16.7 million | True Color | Direct RGB |
| 32-bit | 32 | 16.7 million + Alpha | Transparent True Color | Direct ARGB |
File Formats
BMP and DIB Specifications
The BMP (Bitmap) file format is a raster graphics format developed by Microsoft in the 1980s to store device-independent 2D images, supporting uncompressed pixel data or run-length encoding (RLE) compression, with color depths ranging from 1 bit to 32 bits per pixel.[6][5] It is commonly used in Windows environments and allows images to be rendered consistently across different devices without relying on specific hardware capabilities.[27] The BMP file structure begins with a 14-byte BITMAPFILEHEADER, which identifies the file type and provides metadata for locating the image data. This header includes the following fields:bfType (a 2-byte WORD set to 0x4D42 or "BM" to indicate a BMP file), bfSize (a 4-byte DWORD specifying the total file size in bytes), bfReserved1 and bfReserved2 (2-byte WORDs set to zero for reserved purposes), and bfOffBits (a 4-byte DWORD giving the byte offset from the start of the file to the pixel array).[28] Following this is a 40-byte BITMAPINFOHEADER (for Windows variants), which describes the image dimensions and format: biSize (4-byte DWORD, set to 40), biWidth (4-byte LONG for pixel width), biHeight (4-byte LONG for pixel height, positive for bottom-up orientation), biPlanes (2-byte WORD, always 1), biBitCount (2-byte WORD for bits per pixel, e.g., 24 for true color), biCompression (4-byte DWORD, such as 0 for BI_RGB uncompressed or 1 for BI_RLE8), biSizeImage (4-byte DWORD for compressed image size or 0 for uncompressed), biXPelsPerMeter and biYPelsPerMeter (4-byte LONGs for resolution), biClrUsed (4-byte DWORD for colors in the palette, or 0 for default), and biClrImportant (4-byte DWORD for important colors, or 0 for all).[29] After the headers, an optional color table (array of RGBQUAD structures for indexed colors) precedes the pixel data, which is stored row by row with each row padded to a multiple of 4 bytes for alignment.[27]
At its core, the BMP format relies on the Device-Independent Bitmap (DIB), which encapsulates the image data and metadata in a way that enables platform-independent rendering. DIBs can use a color table for palettized images (e.g., 8-bit with 256 entries) or direct RGB values for higher depths like 24-bit or 32-bit, allowing the operating system to map colors to the display device without hardware-specific adjustments.[27] This structure supports rendering via the Windows Graphics Device Interface (GDI), where the DIB section follows the info header and provides the raw pixel array.[29]
BMP variants include the Windows format (version 3 and later, using the 40-byte BITMAPINFOHEADER) and the earlier OS/2 format (using a 12-byte BITMAPCOREHEADER for basic compatibility).[30] Later extensions like BITMAPV4HEADER and BITMAPV5HEADER add support for features such as alpha channels in 32-bit images (though legacy applications may ignore them).[5] A key limitation is the lack of standard transparency support, as BMP does not natively handle alpha blending outside of specific 32-bit variants, and compression is restricted to simple RLE methods for 4-bit and 8-bit images without advanced options like JPEG.[27]
For example, in an uncompressed 24-bit BMP image measuring 100 pixels wide by 100 pixels high, each row requires 100 × 3 = 300 bytes (no padding needed, as 300 is a multiple of 4), yielding 100 × 300 = 30,000 bytes for the pixel data. With the 14-byte BITMAPFILEHEADER and 40-byte BITMAPINFOHEADER (no color table required for 24-bit), the bfOffBits would be 54, and the total file size (bfSize) would be 30,054 bytes.[28][29][27]
Alternative Raster Formats
The Graphics Interchange Format (GIF), introduced by CompuServe in 1987, is an 8-bit paletted raster format that supports up to 256 colors per image and uses Lempel–Ziv–Welch (LZW) lossless compression to reduce file sizes.[23][31] It gained popularity for web graphics due to its ability to handle simple animations through frame sequencing and transparency via a single-color index, making it suitable for icons, logos, and short looping sequences despite its limited color depth. The JPEG File Interchange Format (JFIF), standardized in 1992, employs lossy compression based on the discrete cosine transform (DCT) to efficiently store photographic images in 24-bit color depth.[32] This approach discards less perceptible details to achieve significantly smaller file sizes compared to uncompressed formats like BMP, rendering it ideal for web distribution and storage of continuous-tone images such as photographs, though it introduces artifacts at high compression levels.[33] Developed in 1996 as a patent-free alternative to GIF, the Portable Network Graphics (PNG) format provides lossless compression using the DEFLATE algorithm, supporting up to 48-bit truecolor and an optional alpha channel for variable transparency.[34] Its extensibility and support for progressive loading make it versatile for web and print applications requiring high fidelity, including illustrations and images with smooth gradients or semi-transparency.[35] The Tagged Image File Format (TIFF), first specified by Aldus Corporation in 1986, offers a highly flexible structure for professional imaging, accommodating multiple pages within a single file and various compression options such as LZW (lossless) and JPEG (lossy).[36] Widely adopted in desktop publishing and scanning workflows since the 1980s, it supports extensive metadata tagging and high bit depths, enabling archival-quality storage for documents and multi-layer scans.[37]| Format | Compression Type | Color Support | Transparency Support |
|---|---|---|---|
| GIF | Lossless (LZW) | 8-bit paletted (up to 256 colors) | Single-color index |
| JPEG | Lossy (DCT) | 24-bit RGB | None (JFIF baseline) |
| PNG | Lossless (DEFLATE) | Up to 48-bit truecolor + 16-bit alpha | Full alpha channel |
| TIFF | Variable (LZW, JPEG, etc.) | Up to 32-bit per channel | Via alpha or masks |
Historical Context
Origins in Computing
The origins of bitmaps in computing trace back to the 1960s, when early computer graphics systems began leveraging cathode-ray tube (CRT) displays and plotters to render visual data. These devices primarily used vector-based approaches, drawing lines and shapes directly, but conceptual foundations for raster graphics—representing images as grids of pixels—emerged during this period. Ivan Sutherland's Sketchpad system, demonstrated in 1963, pioneered interactive computer-aided design on a CRT display, allowing users to create and manipulate line drawings in real time, which influenced subsequent pixel-grid representations in graphics.[38] Concurrently, at Bell Labs, Ken Knowlton's BEFLIX programming language, developed in 1963, enabled the creation of bitmap-based animated films by generating raster mosaic graphics on a Stromberg-Carlson SC-4020 microfilm plotter, marking one of the earliest uses of pixel arrays for image synthesis.[39][40] In the 1970s, bitmap technology advanced significantly with the integration of memory-mapped displays, allowing direct manipulation of pixel data in RAM. The Xerox Alto, developed at Xerox PARC in 1973, featured the first high-resolution bitmap display (606 × 808 pixels) for a graphical user interface (GUI), storing the entire screen as an array of pixels to support windows, icons, and interactive editing.[41] This innovation, combined with a mouse for input, demonstrated bitmaps' potential for dynamic, device-independent graphics rendering, influencing future personal computing systems.[42] The 1980s saw widespread adoption of bitmapped graphics in consumer operating systems, driven by the need for precise, scalable visual interfaces. Apple's Macintosh, released in 1984, popularized bitmap displays with its 512x342 monochrome screen and QuickDraw graphics library, which handled pixel-level operations to enable what-you-see-is-what-you-get (WYSIWYG) editing in applications like MacPaint.[43] This approach made bitmaps accessible to non-experts, fostering the growth of desktop publishing and graphical software.[44] A key milestone came in 1990 with Microsoft's introduction of the Bitmap (BMP) file format alongside Windows 3.0, which formalized the storage of pixel data in a device-independent manner. Building on the Device Independent Bitmap (DIB) specification originally developed for OS/2's Presentation Manager in the late 1980s, BMP allowed images to be rendered consistently across different hardware, supporting color depths up to 24 bits per pixel and establishing a standard for raster image interchange in Windows environments.[45][46]Standardization and Evolution
The standardization of key bitmap formats advanced through international bodies in the 1990s and early 2000s, establishing interoperable specifications for raster image compression and storage. The Joint Photographic Experts Group (JPEG) format was formalized as ITU-T Recommendation T.81 in September 1992, defining a lossy compression algorithm optimized for continuous-tone photographic images, which became foundational for digital photography and multimedia. In response to patent concerns with earlier formats like GIF, the Portable Network Graphics (PNG) format was developed as a lossless alternative and ratified as ISO/IEC 15948:2004, supporting features such as alpha transparency and progressive loading for web and print applications.[47] Operating system vendors also drove bitmap evolution by extending native formats to meet growing demands for color management and compatibility. Microsoft introduced BMP version 5 with Windows 98 in 1998, adding support for International Color Consortium (ICC) profiles, 16-bit color depths, and alpha channel transparency to enhance cross-device rendering and integration with advanced graphics APIs.[6] Similarly, Apple shifted macOS from the legacy QuickDraw-based PICT format—used for mixed vector and bitmap graphics in classic Mac OS—to the Quartz imaging model in Mac OS X (2001), which adopts PDF as its core representation, thereby minimizing reliance on pure bitmap structures in favor of resolution-independent rendering.[48] The World Wide Web Consortium (W3C) influenced bitmap adoption through HTML specifications in the 1990s, recommending raster formats for inline image embedding to enable rich web content. Early HTML drafts from 1993 supported GIF and JPEG, but by 1996, the W3C elevated PNG to Recommendation status, promoting its use for lossless images with transparency, which spurred browser implementations and widespread deployment of JPEG for photos and PNG for graphics across web platforms.[34] In recent decades, bitmap technology has progressed toward high-fidelity and performance-oriented capabilities. The OpenEXR format, developed by Industrial Light & Magic in 1999 for high dynamic range (HDR) imaging in visual effects, supports multi-channel floating-point data to capture extended luminance ranges beyond standard 8-bit bitmaps, and was open-sourced in 2003 for broader industry use. Concurrently, the 2000s saw GPU acceleration transform bitmap processing, with programmable shaders in cards like NVIDIA's GeForce 3 (2001) enabling parallel raster operations such as convolution filters and resizing, further boosted by general-purpose frameworks like CUDA in 2006 for real-time image manipulation in applications from gaming to scientific visualization.Applications and Techniques
Usage in Graphics Systems
In graphics systems, bitmaps serve as fundamental components in rendering pipelines, particularly as framebuffers within graphics processing units (GPUs). A framebuffer is a portion of GPU memory that stores a complete bitmap representing the pixels of a rendered frame, enabling efficient composition and output to displays.[49] In GPU pipelines, such as those in OpenGL, framebuffers are managed through Framebuffer Objects (FBOs), where bitmaps—often attached as textures or renderbuffers—are targeted for rendering operations like drawing primitives or applying shaders.[49] This setup allows for off-screen rendering, where bitmaps accumulate scene data before final presentation, supporting advanced techniques like post-processing effects. Blitting operations further integrate bitmaps into display workflows by copying rectangular regions of pixel data from a source framebuffer to a destination, such as the screen buffer. In OpenGL, blitting is performed viaglBlitFramebuffer, which transfers data between read and draw framebuffers while optionally applying scaling filters to handle resolution differences.[50] This process is essential for efficient screen updates in real-time applications, minimizing redundant computations by directly manipulating bitmap regions without full re-rendering.[50]
Bitmap editing software relies on layer-based manipulation to enable non-destructive raster operations on pixel data. In Adobe Photoshop, raster layers store bitmap content for pixel-level editing, allowing users to apply tools like brushes, filters, and adjustments while preserving underlying layers through stacking and opacity controls.[51] Anti-aliasing in Photoshop smooths jagged edges on bitmap selections or shapes by blending edge pixels with surrounding colors, reducing artifacts during scaling or masking.[52] Similarly, GIMP supports layer-based bitmap editing by creating new layers for isolated manipulations, such as duplicating existing ones or pasting content, which facilitates compositing and iterative refinements without altering the base image.[53]
Operating systems integrate bitmaps for user interface elements like icons and wallpapers, often requiring scaling to adapt to varying display resolutions. In Windows, icons are stored in .ico files containing multiple bitmap sizes (e.g., 16x16 to 256x256 pixels) with alpha channels for transparency, and scaling employs interpolation methods like bicubic resizing to maintain clarity on high-DPI screens.[54] Wallpapers in Windows are typically raster images in formats like BMP, scaled via system interpolation to fit desktop resolutions without distortion. In macOS, icons and wallpapers use bitmap-based representations, with the system applying interpolation for HiDPI scaling to ensure smooth rendering across Retina displays.
Programming APIs leverage bitmaps as textures for surface detailing in 3D rendering, enhanced by mipmapping to manage resolution transitions. In OpenGL, bitmaps are loaded as 2D textures and mapped to geometry using UV coordinates, where the fragment shader samples pixel colors to apply surface details.[55] Mipmapping generates a series of progressively smaller bitmap versions (e.g., halving dimensions per level), allowing OpenGL to select appropriate resolutions based on object distance, with functions like glGenerateMipmap automating the chain and filters like GL_LINEAR_MIPMAP_LINEAR blending for seamless quality.[55] DirectX similarly treats bitmaps as textures, creating mipmap chains (e.g., 256x256 down to 16x16) via CreateTexture to optimize rendering performance and reduce aliasing on distant surfaces, with sampler states controlling linear interpolation between levels.[56]