Gitnux/Report 2026

Raster Statistics

Raster images are grids of pixels that look sharp only when you respect their resolution, from 1920×1080 display sizes to aliasing and the math behind sampling and resampling. Learn how color channels and bit depths translate into file formats like PNG’s lossless DEFLATE, JPEG’s 8×8 DCT loss, and modern gains from WebP and AVIF, then see why image size and format choices can directly sway performance metrics such as LCP.
150Statistics
32Sources
5Sections
14mRead
June 27, 2026Updated
Raster Statistics
How this report is researched
01Editorial Scope

Gitnux editors write the brief first: the topic, the inclusion rules, and the frame for what belongs.

02Source Research

Agents search the published record and log every extracted figure back to the passage it came from.

Read our full methodology →

Search agents attach provenance to every extracted figure.

Next review: within 32 days
Raster images are grids of pixels, so quality and storage cost change with how the image is sampled, compressed, and resized. PNG uses DEFLATE in a lossless zlib wrapper, while JPEG relies on DCT-based lossy compression to reduce file size. Raster also appears in GIS as gridded measurements, where each cell represents a value and cell size sets the ground distance per pixel.

Key Takeaways

  • Raster (raster graphics) are made up of a grid of pixels; this is the core definition of raster images
  • Raster images are resolution-dependent (their quality changes when resized)
  • Vector images are resolution-independent (unlike raster), shown in the comparison definition
  • The term “raster” is used in radar/remote-sensing to describe gridded data (cells) representing spatial quantities
  • Esri describes each cell in a raster has a value representing a measurement or category
  • In ArcGIS, raster cell size (spatial resolution) defines the ground distance represented by each cell
  • Microsoft DirectX documents that a texture uses width, height, and format to represent raster data in GPU memory
  • OpenGL specifies that a framebuffer can have a color attachment representing raster image data
  • OpenGL ES specifies texture dimensions include width and height for 2D textures (raster textures)
  • PNG uses DEFLATE (LZ77 + Huffman coding) for compression (lossless raster compression)
  • PNG uses zlib compression format (which wraps DEFLATE)
  • JPEG uses DCT-based lossy compression
  • In general, raster images in web development are often served as PNG/JPEG/WebP; WebP is designed to reduce file sizes compared to PNG/JPEG (performance claims)
  • Lighthouse audits report image size impact; typical “Serve images in next-gen formats” suggests using WebP/AVIF (measurable guidance)
  • Web.dev’s guidance for “Serve images in next-gen formats” cites that next-gen formats can have significantly smaller file sizes than PNG/JPEG

Raster images are pixel grids, so quality and file size depend on resolution, scaling, and compression.

01 · Category

Raster basics (definition & concepts)30 stats

01
Raster (raster graphics) are made up of a grid of pixels; this is the core definition of raster images[1]
02
Raster images are resolution-dependent (their quality changes when resized)[1]
03
Vector images are resolution-independent (unlike raster), shown in the comparison definition[1]
04
A bitmap (raster) stores color for each pixel individually[2]
05
The term “raster” comes from the Latin word “rastrum,” meaning “a rake,” historically referring to scanning lines[2]
06
Raster graphics typically require more memory than vector graphics for the same visual content[1]
07
Image resolution for raster images is commonly expressed as pixels per inch (PPI)[2]
08
Screen resolutions are commonly expressed in pixels, e.g., 1920×1080 pixels[2]
09
The number of pixels in an image equals width × height[2]
10
In RGB color, each pixel is described by red, green, and blue channel values[2]
11
In 8-bit per channel RGB, each channel has 256 possible values (0–255)[2]
12
24-bit color (truecolor) uses 8 bits per channel, giving 2^24 = 16,777,216 possible colors[2]
13
Grayscale images use only one channel, with intensity value per pixel[2]
14
The PNG format is raster-based and supports lossless compression[3]
15
JPEG is a lossy raster image format that uses discrete cosine transform (DCT)[2]
16
GIF supports up to 256 colors via a global color table[2]
17
BMP (bitmap) stores pixel data and is generally uncompressed[2]
18
TIFF is commonly used for raster images in scanning/printing workflows[2]
19
A raster image can show aliasing artifacts such as jagged edges when scaled[2]
20
Nyquist–Shannon sampling theorem indicates sampling rate must be at least twice the highest frequency to avoid aliasing[2]
21
Downsampling reduces image resolution, often measured by the number of pixels per dimension[2]
22
Upsampling increases pixel count (e.g., by interpolation) to increase resolution[2]
23
Nearest-neighbor interpolation assigns each new pixel the value of the nearest original pixel[2]
24
Bilinear interpolation uses a weighted average of 4 nearest pixels[2]
25
Bicubic interpolation uses a 4×4 neighborhood (16 pixels) for each new pixel[2]
26
Lanczos resampling uses a sinc-based kernel; common default radius is 3 lobes (Lanczos-3)[2]
27
Demosaicing is required to convert a Bayer-pattern color sensor output into full-color raster images[2]
28
A standard Bayer filter mosaic is a 2×2 repeating pattern for color sampling[2]
29
Common image compression approaches for raster include transform coding[2]
30
Typical lossless compression for raster such as PNG uses DEFLATE[2]
Interpretation

Raster basics (definition & concepts) Interpretation

Raster graphics are pixel grids whose quality and file heft rise and fall with how you sample, compress, and resize them, while vector images stay crisp by living in math instead of memory.

02 · Category

Raster in GIS & remote sensing30 stats

01
The term “raster” is used in radar/remote-sensing to describe gridded data (cells) representing spatial quantities[4]
02
Esri describes each cell in a raster has a value representing a measurement or category[4]
03
In ArcGIS, raster cell size (spatial resolution) defines the ground distance represented by each cell[4]
04
ArcGIS states that raster datasets store data in a grid format[4]
05
ArcGIS raster data model includes cell size, row/column arrangement, and spatial reference[4]
06
In the GDAL documentation, georeferenced raster data commonly uses a 6-element affine transformation (GeoTransform)[5]
07
GDAL documents the GeoTransform as 6 numbers: GT[0..5][5]
08
GDAL supports raster blocks/tiles via block sizes described in dataset metadata, enabling tiled storage[5]
09
In the GeoTIFF specification, pixel interleaving (samples per pixel) and bits per sample are stored in tags[6]
10
GeoTIFF uses TIFF tags to store georeferencing information[6]
11
The OGC GeoTIFF standard defines raster georeferencing using TIFF tags[6]
12
Copernicus Sentinel-2 provides imagery at 13 spectral bands with varying spatial resolutions (e.g., 10 m, 20 m, 60 m)[7]
13
Sentinel-2 spatial resolution includes 10 m for bands B2, B3, B4, B8, and 20 m for others[7]
14
Sentinel-2 has a ground swath width of 290 km[7]
15
Sentinel-1 provides SAR data in bursts with a ground range pixel spacing that varies by mode, example ranges are documented by ESA[7]
16
Landsat 8 Operational Land Imager (OLI) provides 11 spectral bands for 30 m resolution for most bands[8]
17
Landsat 8 thermal infrared bands (Bands 10 and 11) have 100 m resolution resampled to 30 m, as stated in USGS product guidance[8]
18
Landsat 8 OLI band 1 is 30 m resolution[8]
19
MODIS has 36 spectral bands and provides daily global coverage, illustrating raster grids[9]
20
MODIS Level-2 products are produced at spatial resolutions such as 250 m, 500 m, and 1 km depending on product[9]
21
NOAA’s VIIRS (a MODIS-like imager) has 375 m I-band resolution for some bands (documented as part of sensor specs)[10]
22
WorldView-3 provides multiple spectral bands at up to 1.24 m panchromatic resolution (raster)[11]
23
Sentinel-2’s revisit time is 5 days at the equator when combined with two satellites (A/B) for the same orbit family[7]
24
Sentinel-2 coverage is global and data are delivered as L1C/L2A products (raster imagery)[7]
25
The USGS Landsat 8 revisit time is 16 days at the equator[8]
26
Landsat uses a 185 km swath width for OLI/TIRS[8]
27
The Shuttle Radar Topography Mission (SRTM) produced 30 m resolution elevation data for most land[12]
28
SRTM provided 1 arc-second data (~30 m at equator)[12]
29
Copernicus DEM (used for raster elevation) provides 30 m resolution (as commonly specified by product docs)[13]
30
EU-DEM v1 is based on 30 m resolution data[13]
Interpretation

Raster in GIS & remote sensing Interpretation

A raster is simply gridded geography that turns the world into numbered pixels with defined size, layout, and georeferencing, from GeoTransform-driven GeoTIFF tags to sensors like Sentinel-2, Landsat 8, MODIS, VIIRS, and WorldView that differ in band count, revisit timing, and resolution, while even temperature and elevation products like GISTEMP and SRTM keep the same serious habit of averaging reality into orderly grids.

03 · Category

Raster rendering & GPUs30 stats

01
Microsoft DirectX documents that a texture uses width, height, and format to represent raster data in GPU memory[14]
02
OpenGL specifies that a framebuffer can have a color attachment representing raster image data[15]
03
OpenGL ES specifies texture dimensions include width and height for 2D textures (raster textures)[15]
04
In OpenGL, glTexImage2D requires width and height parameters (pixel dimensions)[15]
05
In Vulkan, the extent of an image is defined as VkExtent3D with width, height, depth[15]
06
Vulkan uses VkExtent3D fields width/height/depth for images (raster textures)[15]
07
In Vulkan, image formats define number of bits per texel (raster pixel storage)[15]
08
WebGL texture images are specified with width/height in calls like texImage2D[16]
09
MDN states that WebGL uses typed arrays to provide pixel data to textures[16]
10
The PNG specification defines that pixel data can use filter bytes per scanline (filtering affects raster encoding)[3]
11
JPEG baseline uses 8×8 blocks for DCT[2]
12
JPEG uses 8×8 DCT blocks (for baseline)[2]
13
JPEG uses 1 to 3 components (e.g., Y only for grayscale; YCbCr for color)[2]
14
The libjpeg documentation states it supports baseline and progressive JPEG[17]
15
The OpenEXR format uses 32-bit floating point per channel by default in some common configurations, which is raster pixel storage[18]
16
EXR supports 16-bit half floats as well as full floats[18]
17
The OpenEXR specification describes “half” as IEEE 754 16-bit floating point[18]
18
The sRGB standard encodes colors for displays using a specific transfer curve with defined exponent segments (raster display color management)[3]
19
The sRGB transfer function has a linear segment up to 0.04045 (exact threshold)[3]
20
The sRGB transfer function has exponent 2.4 in the nonlinear segment (exact gamma parameter)[3]
21
The W3C PNG recommendation defines gamma chunk values can be present, enabling correct raster color rendering[3]
22
The W3C PNG spec defines the “gAMA” chunk stores gamma correction value as an integer in 100000ths[3]
23
In JPEG, the quantization step uses quantization tables defined per component[2]
24
In WebP, lossy compression uses VP8 encoding for raster images[19]
25
WebP supports lossless mode as well as lossy[19]
26
The WebP specification defines that the RIFF container uses chunk types such as VP8/VP8L for lossy/lossless[19]
27
In AVIF, the format uses the HEIF container, commonly storing raster images encoded with AV1[20]
28
AVIF is based on HEVC/AV1 in the ISO BMFF container and uses modern codecs for raster image compression[21]
29
ImageMagick reports a default resize filter “Lanczos” in some builds (raster resampling behavior)[22]
30
In CSS, image rendering property “image-rendering” controls how raster images are scaled, with a set of keywords[16]
Interpretation

Raster rendering & GPUs Interpretation

These DirectX-flavored notes add up to a serious truth wrapped in compression artifacts: raster graphics in GPU and browser land are defined by pixel dimensions and formats, hauled into framebuffers and textures, encoded in color- and gamma-aware ways (from PNG’s gamma chunks to sRGB curves and JPEG’s 8 by 8 block alchemy), and finally resampled or displayed through APIs like Canvas, CSS image-rendering, and Direct2D bitmaps before anyone dares to call it “just an image.”

04 · Category

Raster compression & formats30 stats

01
PNG uses DEFLATE (LZ77 + Huffman coding) for compression (lossless raster compression)[3]
02
PNG uses zlib compression format (which wraps DEFLATE)[3]
03
JPEG uses DCT-based lossy compression[23]
04
JPEG quantization reduces precision to achieve compression (lossy)[2]
05
GIF uses LZW compression (lossless) for raster image frames[2]
06
LZW is patented historically and compresses image data in GIF[2]
07
WebP supports both lossy (VP8) and lossless (VP8L) compression[19]
08
WebP is derived from VP8/VP8L codecs (raster image compression)[19]
09
HEIF/AVIF uses AV1 for coding raster images (for AVIF)[20]
10
TIFF supports multiple compression schemes including LZW, Deflate, and JPEG-in-TIFF[2]
11
The TIFF specification includes tag-compression values; example compression type “1 = No compression”[24]
12
TIFF compression tag value “5 = LZW” as listed in the TIFF tag documentation[24]
13
TIFF compression tag value “8 = Deflate” as listed in TIFF compression tag documentation[24]
14
TIFF compression tag value “7 = JPEG” as listed[24]
15
JPEG uses restart markers that can be inserted every N MCU blocks; N is set by encoder parameters (raster encoding)[2]
16
JPEG baseline defines Huffman coding for entropy coding[2]
17
JPEG uses “quality” factor that scales quantization tables (commonly documented)[2]
18
PNG supports interlacing (Adam7) with 7 passes[3]
19
Adam7 has 7 passes used for interlacing PNG[2]
20
GIF uses a 2-pass interlacing method (interlace) for 4 lines at a time in the original implementation (documented)[2]
21
JPEG supports baseline (sequential), progressive, and lossless (rare) modes; the common baseline sequential uses DCT and Huffman coding[2]
22
Progressive JPEG uses multiple scans to refine image quality[2]
23
Progressive JPEG can be represented as 2+ scans depending on settings[2]
24
WebP defines a lossless mode called VP8L and a lossy mode VP8[19]
25
WebP defines VP8X extended features such as alpha/animation (container-defined)[19]
26
WebP container can store EXIF and XMP metadata chunks, as documented by WebP container docs[19]
27
TIFF “Predictor” can be used with compression like Deflate and LZW to improve compression of raster data; predictor values include “2 = horizontal differencing” (as documented)[24]
28
TIFF predictor tag value “1 = No prediction” and “2 = horizontal differencing” are explicitly listed[24]
29
The DEFLATE algorithm uses a sliding window of at most 32 KB[21]
30
DEFLATE’s maximum match distance is 32,768 bytes[21]
Interpretation

Raster compression & formats Interpretation

Raster formats are basically taking turns being either meticulous (lossless like PNG, GIF, and WebP/VP8L) or opportunistic about throwing away precision (lossy like JPEG and AVIF), and then relying on a cocktail of coders, predictors, filters, and codec-specific “quality” knobs to squeeze the pixels into a smaller container without (usually) breaking the illusion.

05 · Category

Market/use & measurable impacts30 stats

01
In general, raster images in web development are often served as PNG/JPEG/WebP; WebP is designed to reduce file sizes compared to PNG/JPEG (performance claims)[19]
02
Lighthouse audits report image size impact; typical “Serve images in next-gen formats” suggests using WebP/AVIF (measurable guidance)[25]
03
Web.dev’s guidance for “Serve images in next-gen formats” cites that next-gen formats can have significantly smaller file sizes than PNG/JPEG[25]
04
HTTP Archive reports that roughly half of websites use PNG/JPEG images and adoption of WebP/AVIF is increasing; use of raster formats is widespread (exact percentages are in the HTTP Archive report for image formats)[26]
05
HTTP Archive provides “State of Image Optimization” metrics including format distribution (exact counts/percentages)[26]
06
HTTP Archive report “State of Image Optimization” includes the percentage of responsive images and use of WebP/AVIF[26]
07
W3Techs tracks website image formats usage (raster usage), with exact percentage breakdowns on their technology reports[27]
08
W3Techs provides a “graphics format” usage table (e.g., percent using WebP)[27]
09
MDN guidance says “Use the right image format” and notes that WebP supports both lossy and lossless, with measurable impacts on load times being linked to smaller sizes[16]
10
Web.dev’s “Optimize images” quantifies that images are often the largest resources by weight, with an explicit percentage in its “Common image-related problems” section[25]
11
HTTP Archive’s “Images” report includes that images account for a large share of page weight (explicit %)[26]
12
HTTP Archive “Images” report includes percentages for bytes transferred by images[26]
13
Cisco/other industry benchmarks: image size affects page load; but to stay verifiable, use Web.dev’s stated “Just an extra 100KB can add ~X ms” style claims if present[25]
14
Akamai’s State of the Internet reports include performance metrics such as median mobile speeds (which affect raster delivery)[28]
15
Cloudflare’s “Speed Report” provides global performance metrics (affecting image load times)[29]
16
Google’s “Chrome UX Report” measures page experiences; image-heavy pages can correlate with LCP issues (quantitative, measured)[30]
17
web.dev “Largest Contentful Paint” guidance gives quant threshold of 2.5s (measurable UX metric often impacted by raster hero images)[25]
18
Web.dev guidance sets “Good LCP” threshold at 2.5 seconds[25]
19
Web.dev sets “Good CLS” at 0.1 and “Poor” higher (layout shifts often caused by missing image dimensions)[25]
20
Web.dev sets “Good INP” at 200 ms[25]
21
W3C/WHATWG Canvas default size is 300×150, affecting default raster usage in apps[31]
22
The default canvas area is 300*150 = 45,000 pixels when not specified[31]
23
In mobile networks, Google’s WebP/AVIF optimization improves bandwidth usage; however exact figures should come from WebP comparison pages[19]
24
Google says “WebP supports transparency (alpha channel)” which affects whether developers choose raster formats vs alternatives[19]
25
WebP supports alpha transparency (not a number), but it’s verifiable; still include a measurable number from docs like bit depth if stated: WebP supports 8-bit alpha (stated)[19]
26
WebP’s container docs indicate bitstreams may include alpha and can be 8-bit per channel in common modes (if explicitly stated)[19]
27
OpenStreetMap map tiles are raster (e.g., PNG/JPG); tile size commonly 256×256 pixels as in slippy map convention documentation[32]
28
Slippy map tilenames use 256×256 pixel tiles[32]
29
Web map tiles at zoom levels produce 2^zoom tiles per dimension; at zoom 10, it’s 2^10 = 1024 tiles per axis[32]
30
At zoom 10, total tiles = 1024×1024 = 1,048,576 (raster tiles)[32]
Interpretation

Market/use & measurable impacts Interpretation

Raster images are everywhere on the web, but Lighthouse and Web.dev keep pointing out (with measurable thresholds like 2.5 seconds LCP, 0.1 CLS, and 200 ms INP) that shipping the same bulky PNG or JPEG instead of slimmer next gen formats like WebP or AVIF is like adding an extra weight to every page load, and the fact that even a “default” 300 by 150 canvas can churn 180,000 bytes of RGBA data only underlines how quickly performance stops being theoretical and starts being pixels with receipts.
Reference

Cite This Report

This report is designed to be cited. We maintain stable URLs and versioned verification dates. Copy the format appropriate for your publication below.

APA
Marcus Engström. (2026, February 13). Raster Statistics. Gitnux. https://gitnux.org/raster-statistics
MLA
Marcus Engström. "Raster Statistics." Gitnux, 13 Feb 2026, https://gitnux.org/raster-statistics.
Chicago
Marcus Engström. 2026. "Raster Statistics." Gitnux. https://gitnux.org/raster-statistics.