🔮 Universal Image Data Explorer Forge Pro

Converts every pixel of your image into an 8-bit binary string, producing a single, continuous stream of 0s and 1s. Each pixel is first reduced to a weighted grayscale luminance value using the ITU-R BT.601 formula Y = 0.299R + 0.587G + 0.114B, then that value (0–255) is written as eight binary digits.

Example: a pure white pixel (255) becomes 11111111; a pure black pixel (0) becomes 00000000; the mid-grey value 170 becomes 10101010.

Typical use cases: teaching binary representation, embedding images inside micro-controller firmware where each bit drives an LED or actuator, testing binary-to-image reconstruction algorithms, and generating test vectors for computer-science exams.

Output format: a single unbroken string of length width × height × 8. For a 100×100 image you will get 80,000 characters.

Produces a space-separated hex dump of the grayscale byte stream. Each pixel is written as a two-digit lowercase hexadecimal number from 00 to ff, matching the byte-level layout used by hex editors, debuggers and logic analysers.

Example: white becomes ff, black becomes 00, mid-grey 170 becomes aa.

Typical use cases: reverse-engineering proprietary image formats, comparing two images byte-by-byte, feeding data into embedded C compilers as a lookup table, and creating visualisation arrays for LED matrices.

Emits the grayscale byte stream as octal numbers (base-8), comma-separated. Octal is rarely used in modern computing but remains a favourite in Unix permissions, legacy PDP-11 systems and some assembly-language tutorials.

Example: 255 becomes 377, 128 becomes 200, 64 becomes 100.

Wraps the grayscale byte stream inside square brackets as a JavaScript-style array literal: [170,170,170,...]. Every value is a decimal integer between 0 and 255.

Use cases: pasting directly into a JavaScript console, feeding into WebGL textures, writing JSON configuration files, and testing image-processing functions in Node.js.

Emits a ready-to-use JavaScript Uint8Array constructor call: new Uint8Array([...]). This is the exact object type required by the browser's ImageData API, so you can paste the output directly into the browser console and feed it to ctx.putImageData().

Wraps the byte stream in an Int16Array literal. Some algorithms (Sobel, Gaussian blur, convolution) promote pixel values to 16-bit signed integers to prevent overflow during intermediate computations.

Wraps the byte stream in an Int32Array literal. Used when pixel values are accumulated across multiple passes (histogram equalisation, integral image) and 16-bit is not wide enough.

Emits a normalised Float32Array where every pixel value is divided by 255, producing a decimal number between 0.0 and 1.0. This is the format expected by most deep-learning frameworks (TensorFlow.js, PyTorch, ONNX Runtime) when loading image tensors.

Similar to Binary but without zero-padding — each pixel becomes its shortest binary representation. Useful for compression experiments and for teaching variable-length encoding.

Renders the image using the standard RFC 4648 Base64 alphabet (A–Z, a–z, 0–9, +, /) with padding. Base64 is the most common way to embed binary image data inside text-only channels such as JSON, XML, email or HTML attributes.

Use cases: embedding a small logo directly inside a CSS file, sending an image inside a JWT payload, uploading an image over a text-only API, storing images in localStorage.

Note: Base64 inflates size by ~33% compared to raw bytes.

Encodes the byte stream using RFC 4648 Base32 (A–Z, 2–7). Base32 is case-insensitive and avoids visually ambiguous characters, making it ideal for human transcription — for example two-factor authentication recovery codes, DNS TXT records and product licence keys.

Encodes the byte stream using the Ascii85 alphabet used by Adobe PostScript and PDF. Ascii85 is more compact than Base64 — roughly 25% overhead instead of 33%. The output is wrapped in <~ … ~> markers.

Produces a complete data:image/png;base64,... URL that can be pasted directly into the browser address bar, an <img src> attribute, or a CSS background-image rule.

Takes the Base64 representation and percent-encodes it using encodeURIComponent, producing a string safe to place inside a query-string parameter.

Interprets the grayscale byte stream as ASCII characters. Bytes outside the printable range are skipped. Occasionally useful for steganography demonstrations.

Decodes the grayscale byte stream through a UTF-8 TextDecoder. Invalid byte sequences become the Unicode replacement character. Primarily of interest to students of text encoding.

Emits a structured JSON document containing the image width, height and full grayscale array. Self-describing, so downstream tools know the geometry without external metadata.

Produces a nested 2-D array [[[r,g,b],...],...] where each inner triple represents one pixel's red, green and blue channels. The canonical raw format used by OpenCV, Pillow and scikit-image.

Same as RGB Matrix but with a fourth alpha channel: [[[r,g,b,a],...],...]. Alpha is 0 (transparent) to 255 (opaque). Essential for PNG images with transparency.

Emits a nested 2-D array of grayscale bytes — the same values used internally by every other converter.

Converts every RGB triple into HSL (Hue 0–360°, Saturation 0–100%, Lightness 0–100%). HSL separates colour from brightness, making it intuitive for designers.

Converts to HSV (Hue, Saturation, Value). HSV is preferred in computer vision because value is independent of hue — illumination changes affect only V. Used by OpenCV's inRange colour segmentation.

Converts to the subtractive CMYK colour model used in printing (Cyan, Magenta, Yellow, Black; each 0–100%). Useful for prepress analysis.

Converts to YUV, the colour space used in PAL, SECAM and most video-codec pipelines. Y is luminance; U and V are chrominance. Uses ITU-R BT.601 weights with chroma offset by 128.

Approximates the CIE XYZ colour space, the pre-step to CIELAB. XYZ is device-independent and anchored to the D65 white point. Useful for colour-difference metrics (ΔE).

Emits three 256-bin arrays (one each for R, G, B) counting how often each intensity appears. Foundation of histogram-equalisation contrast enhancement and colour-based image retrieval.

Emits a ready-to-compile C source line: unsigned char img[N] = { ... };. Drop it into any C or Arduino sketch and draw the image on an OLED or TFT display with a single loop.

Emits a std::array<unsigned char, N> initialiser, ready for modern C++17 and later. Type-safe and constexpr-friendly.

Emits img_bytes = bytes([...]), ready to paste into a Python script. Feed it to numpy.frombuffer() or write it to disk with open("out.raw","wb").write(img_bytes).

Emits byte[] imgData = { ... };. Java bytes are signed, so values above 127 appear as negatives — use & 0xFF when reading back.

Emits img := []byte{...}, ready for image.NewGray or direct pixel rendering in Go.

Emits let img: [u8; N] = [...];. Const-usable inside const or static blocks in embedded Rust (no_std).

Emits Buffer.from([...]) for Node.js. Works in Electron and browsers via Buffer polyfill. Ideal for server-side image manipulation with sharp or jimp.

Emits a PHP double-quoted string containing the raw bytes, ready for imagecreatefromstring().

Emits Data([...]), ready to feed into UIImage(data:) on iOS or macOS.

Emits byteArrayOf(...), ready for Android's BitmapFactory.decodeByteArray.

Renders the image using 10 ASCII characters ranked by darkness (@%#*+=-:. ). Sampled every two rows to compensate for tall terminal fonts.

Uses Unicode Braille patterns (U+2800–U+28FF) to render 2×4 pixel blocks per character — 8× denser than ASCII art. Excellent for high-resolution terminal previews.

Uses Unicode block-drawing characters (▘▝▀▖▌▞▛▗▚▐▜▄▙▟█) to render 2 pixels per character — smoother than pure ASCII.

Maps each pixel to one of eight coloured emoji (⚫🔴🟠🟡🟢🔵🟣⚪) based on hue and brightness. Great for sharing playful previews on chat apps.

Emits a black-and-white grid using ⬛ and ⬜ characters, thresholded at 128. Truncated to the top-left 40×20 region for readability.

Uses shading characters (░▒▓█) to render brightness as apparent density — useful for quickly eyeballing exposure problems.

Emits [[value, count], ...] pairs, compressing consecutive identical pixels. RLE is the simplest lossless compression and was used in early PCX, BMP and TIFF formats.

Stores the first pixel as-is and every subsequent pixel as the signed difference from its predecessor. Reduces entropy for smooth-gradient images — often 2× better than raw.

Computes the 128-bit MD5 message digest of the grayscale byte stream using the Web Crypto API. Output is 32 hex characters.

Note: MD5 is cryptographically broken for adversarial use but fine for non-adversarial fingerprinting and cache keys.

Computes the 160-bit SHA-1 digest, output as 40 hex characters. Deprecated for cryptographic signatures but still used in Git object IDs.

Computes the 256-bit SHA-256 digest, output as 64 hex characters. The recommended hash for integrity checks, digital signatures and blockchain anchoring.

Computes the IEEE 802.3 CRC-32 checksum, output as 8 hex characters. Used inside ZIP, PNG and Gzip for detecting accidental corruption.

Emits np.array([...]).reshape(H, W), ready to paste into a Jupyter notebook. The reshape makes the 1-D byte stream into a 2-D matrix matching the original geometry.

Emits tf.tensor([...], [H, W, 1]), ready for TensorFlow.js or Python TensorFlow. The trailing 1 is the channel dimension (grayscale).

Emits one row per pixel in the format x,y,value. Ready to import into Excel, Google Sheets, R or pandas read_csv().

Emits a Python pd.DataFrame(...) constructor producing a long-format table with columns pixel, x, y. Ideal for exploratory data analysis.

Emits a plain 1-D array of grayscale values — the simplest feature vector for classical ML classifiers (SVM, k-NN, random forest) applied to image data.

Generates an SVG document in which every pixel becomes a 1×1 <rect>. A "raster-to-vector" trace limited to small images (≤ 2,500 pixels) because file size grows quadratically.

Emits a ready-to-paste CSS rule: background-image: url('data:image/png;base64,...');. Drop it inside a stylesheet to embed the image without a separate file request.

Emits a ctx.putImageData(...) call containing the full RGBA byte stream. Limited to images under 10,000 pixels because raw RGBA is 4× the size of grayscale.