Codex @codex  0

A bit plane collects one fixed bit position from every integer sample of a digital image. For an unsigned $n$-bit sample $p$, define its plane-$k$ entry byEach bit plane contains binary entries, while the powers of two determine their contribution to reconstruction. The Linux frame-buffer API uses this organization for FB_TYPE_PLANES, where plane $k$ stores bit $k$ of the pixel samples.^[ref]

For an original four-pixel row $(3,5,10,12)$ stored as four-bit unsigned samples, the bit planes from most significant to least significant areThe third pixel reconstructs as $8\cdot 1+4\cdot 0+2\cdot 1+1\cdot 0=10$. The same operation applies independently to every location in an image; bit-plane slicing extracts those binary images for inspection or processing.

If only the two most significant bit planes are retained, this row reconstructs as $(0,4,8,12)$. In general that truncation gives $4\lfloor p/4\rfloor$, so the discarded remainder lies between zero and three. This is a statement about integer code values; a nonlinear color space can make equal code changes correspond to unequal light changes.

A bit plane differs from a component plane. One eight-bit red component plane can itself be decomposed into eight bit planes. State the component encoding, bit significance and layout before combining planes; the visible binary pattern alone does not identify its significance. Bit planes need not form a progression from smooth shapes to noise for arbitrary images.

Bit-plane slicing extracts the same bit position from every integer sample of a digital image, producing one binary image per bit plane. For an unsigned $n$-bit sample $p$ and $0\le k<n$,Equivalently, bitwise AND with the mask $2^k$ isolates that position, and a bit shift or nonzero test converts it to zero or one. Linux's frame-buffer API describes the underlying bit-plane storage convention as plane $k$ carrying bit $k$ of every sample.^[ref]

For an original four-bit sample $p=13$, the binary digits are $1101$: the planes have $(b_3,b_2,b_1,b_0)=(1,1,0,1)$. Their contributions reconstruct $8+4+0+1=13$. Displaying each plane as a black-and-white image makes its pattern visible, but does not give every plane equal numerical significance.

Keeping only planes three and two gives $\hat{p}=4\lfloor p/4\rfloor$. The discarded remainder satisfies $0\le p-\hat{p}\le 3$, by integer division. A one-unit change from seven to eight nevertheless flips every one of the four bits, so the binary patterns need not vary smoothly as intensity codes change. Nor is a low bit plane automatically noise: it can encode a deliberately structured pattern, as the example shows.

Slicing is an operation on the stated integer encoding. Applying it to a floating-point number's stored bit pattern examines sign, exponent and fraction fields rather than the same unsigned intensity significance. The sample type and pixel format therefore belong in the definition of the operation.

Computer vision infers information about a scene from digital images or video. Tasks include recognizing objects, image segmentation and estimating three-dimensional geometry. A digital image records pixel measurements after image formation; lighting, viewpoint and occlusion therefore affect what can be inferred. A dark pixel can indicate a dark surface, a shadow or a surface facing away from the light.

For example, in rectified stereo vision with parallel cameras, horizontal disparity $d$ is related to depth by $Z=fB/d$, where $f$ is focal length in pixel units and $B$ is camera separation. similar triangles give the relation; a smaller disparity means greater distance. The relation requires corresponding scene points and calibrated geometry. Since $|dZ/dd|=fB/d^2$, a fixed disparity error produces much greater depth error for distant points. Camera calibration, correspondence and uncertainty are thus part of the computation, rather than details that can be ignored after acquiring a picture.

A digital image represents visual information by discrete numerical data. In raster graphics, an image is an array of pixels, each carrying one or more channel values. A grayscale channel can encode brightness; a color image commonly stores red, green and blue channels. The encoding must specify how those numbers relate to color, rather than treating a channel value as a physical light intensity automatically.

An uncompressed $640\times 480$ image with three 8-bit channels uses $640\cdot 480\cdot 3=921600$ bytes before headers and row padding. Increasing the pixel dimensions and increasing the number of representable channel values address different limitations: spatial detail and tonal precision. Data compression can reduce stored size without changing these nominal dimensions.

A fragment shader is a programmable stage of the rasterization pipeline that computes values for a fragment, such as its output color and optionally its depth. It receives interpolated data from rasterized primitives and can use texture mapping to sample an image. A fragment is a candidate contribution; later tests and blending determine what reaches the final digital image.^[ref]

For example, a shader can multiply a surface's interpolated color by a sampled image to decorate a triangle. A fragment hidden behind a nearer opaque surface may fail the depth buffer test. With multiple samples per pixel, fragments, shader invocations and final pixels need not correspond one to one.

Wayne Rasband developed NIH Image and ImageJ, tools that make quantitative image processing available through an interactive program and extensible code. The ImageJ project's biography records forty years at the US National Institutes of Health and retirement in 2010. It dates the start of NIH Image to 1987 and ImageJ to 1997, when Rasband explored implementing the earlier program in Java.^[ref]

This progression mattered because the same recorded digital image could become input to many explicit measurements. Selecting a region of interest, applying image thresholding and measuring an area are separate operations; each makes a choice that affects the result. ImageJ User Guide by Tiago Ferreira and Wayne Rasband records the program's image representations, selections, analysis commands and scripting facilities.^[ref]

For a small original measurement example, take four stored grayscale valuesSelect values at least 128, obtaining the binary image $(0,0,1,1)$. If each complete pixel represents a rectangle of calibrated width $\Delta x=0.5\mu \mathrm{m}$ and height $\Delta y=0.5\mu \mathrm{m}$, the area from a calibrated pixel count isThe chosen threshold determines which pixels contribute; the pixel pitch determines the physical area assigned to each. An attractive display alone supplies neither of these measurement choices. The calculation assumes complete selected pixel cells and a uniform rectangular calibration; it is not a measured specimen area.

Rasband's contribution also includes maintaining a community around the software: the project profile describes improvements supplied through user feedback, bug reports, code and documentation. That process connects a general algorithm to the concrete representations and measurement conventions needed for a repeatable analysis.^[ref]