{ "created": "2026-07-04T14:07:30Z", "hierarchy": [ { "name": "ROOT", "type": "folder", "uri": "/ROOT" }, { "name": "Photography Notes", "type": "article", "uri": "Photography_Notes" } ], "html": "Photography Notes – Nikhil's Personal Wiki

Photography Notes

Assorted notes from me trying to teach myself Photography.

\n

The Triangle

\n

It’s a balance between Aperture, Shutter Speed, and ISO.

\n

Metering

\n

Your camera will try and advise you. People used to use light meters for this. It will say its a good exposure if it is “18% Gray” which is what light meters were historically calibrated to (the caps on Kodak film and the insides of dedicated camera bags are this gray too.)

\n

The Histogram

\n
    \n
  • Luminance value on x-axis and pixel count on y-axis.
    • \n
  • Leftmost edge is Luminance of zero, Rightmost is Luminance of one. Any pixels touching these edges are lost information, they’re just crushed out of existence. You can use Zebra stripes to tell you which parts of your image are/will be “blown out” in either direction.
    • \n
  • You section it into, say, five equal portions. From L-R, you are looking at blacks, shadows, midtones, highlights, and whites.
    • \n
\n

Usually you want a histogram that looks like a mountain or is kinda balanced out but depends on what you’re trying to do, the look you’re going for.

\n

On Aperture

\n

Measured by f-stop. “f/2” means you take the focal length and divide it by two.

\n

“f/8 and Be There..” Like be there. Your camera primarily exists to take pictures of things and events.

\n

On ISO

\n

See this video. TLDR: This is tricky so let the camera figure it out.

\n

Tripods

\n
    \n
  • Cheap, Stable, Light —- pick two. But don’t be cheap. You’ll change cameras before tripods.
    • \n
  • Read this thoroughly.
    • \n
  • Components are: Legs, Head, Plate, Bag\n
      \n
    • Each component may be purchased separately.
      • \n
    • Buying a head doesn’t necessarily include a plate.
      • \n
    \n
    • \n
\n

Lenses

\n

There are Prime lenses (fixed focal length) and Zoom lenses (can be wide, normal, and/or telephoto lenses).

\n

Prime lenses teach you a lot about photography because they make your lazy ass move and explore a scene: distances and angles.

\n

Presets and LUTs

\n\n

Hald CLUTs

\n

These are great!. This gives you a bunch of PNGs that you can “infer LUTs” from. Quick Python script that will do this is at the end of this page.

\n

Now the LUT grid size with the PNGs is 144 x 144 x 144 = 2,985,984 which makes the sizes of the .cube files explode. That script will downsample to 32 x 32 x 32.

\n

I’ve saved the generated .cube files here.

\n

Other

\n\n

Infer LUT from PNG Script

\n
#!/usr/bin/env python3\n"""Infer a 3D color LUT from images and export as .cube file.\n\nModes:\n  hald   — Extract LUT from a processed Hald CLUT image.\n  pair   — Approximate LUT from a before/after image pair.\n  generate-hald — Generate a neutral Hald CLUT image to use as a reference.\n\nUsage:\n  python infer_lut.py hald processed_hald.png -o my.cube\n  python infer_lut.py pair original.png graded.png -o my.cube\n  python infer_lut.py generate-hald -s 8 -o identity_hald.png\n"""\n\nimport argparse\nimport numpy as np\nfrom pathlib import Path\nfrom PIL import Image\n\n\n# ---------------------------------------------------------------------------\n# Hald CLUT helpers\n# ---------------------------------------------------------------------------\n\n\ndef hald_level_from_image(img: Image.Image) -> int:\n    """Determine the Hald level from image dimensions.\n\n    A Hald CLUT of level N has dimensions (N^3) x (N^3).\n    The resulting 3D LUT has N^2 entries per axis.\n    Common levels: 4 → 64x64 image, 16-entry LUT\n                   8 → 512x512 image, 64-entry LUT\n                  12 → 1728x1728 image, 144-entry LUT\n    """\n    w, h = img.size\n    if w != h:\n        raise ValueError(f"Hald CLUT must be square, got {w}x{h}")\n    # w = level^3\n    level = round(w ** (1 / 3))\n    if level**3 != w:\n        raise ValueError(\n            f"Image size {w}x{h} is not a valid Hald CLUT dimension (need N^3 x N^3)"\n        )\n    return level\n\n\ndef generate_hald(level: int) -> Image.Image:\n    """Generate a neutral (identity) Hald CLUT image."""\n    lut_size = level * level  # entries per axis in the 3D LUT\n    dim = level**3  # pixel width/height of the Hald image\n    pixels = np.zeros((dim * dim, 3), dtype=np.uint8)\n\n    for i in range(dim * dim):\n        r = i % lut_size\n        g = (i // lut_size) % lut_size\n        b = i // (lut_size * lut_size)\n        pixels[i] = [\n            round(r / (lut_size - 1) * 255),\n            round(g / (lut_size - 1) * 255),\n            round(b / (lut_size - 1) * 255),\n        ]\n\n    return Image.fromarray(pixels.reshape(dim, dim, 3))\n\n\ndef lut_from_hald(img: Image.Image) -> tuple[int, np.ndarray]:\n    """Extract a 3D LUT from a processed Hald CLUT image.\n\n    Returns (lut_size, lut) where lut has shape (lut_size, lut_size, lut_size, 3)\n    with float values in [0, 1].\n    """\n    level = hald_level_from_image(img)\n    lut_size = level * level\n    dim = level**3\n\n    pixels = np.array(img.convert("RGB"), dtype=np.float64).reshape(-1, 3) / 255.0\n    expected = dim * dim\n    if len(pixels) != expected:\n        raise ValueError(f"Expected {expected} pixels, got {len(pixels)}")\n\n    lut = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n    for i in range(expected):\n        r = i % lut_size\n        g = (i // lut_size) % lut_size\n        b = i // (lut_size * lut_size)\n        lut[b, g, r] = pixels[i]\n\n    return lut_size, lut\n\n\ndef resample_lut(lut: np.ndarray, src_size: int, dst_size: int) -> np.ndarray:\n    """Resample a 3D LUT to a different grid size via trilinear interpolation."""\n    from scipy.interpolate import RegularGridInterpolator\n\n    axis = np.linspace(0, 1, src_size)\n    channels = []\n    for ch in range(3):\n        interp = RegularGridInterpolator(\n            (axis, axis, axis), lut[:, :, :, ch], method="linear"\n        )\n        dst_axis = np.linspace(0, 1, dst_size)\n        grid = np.meshgrid(dst_axis, dst_axis, dst_axis, indexing="ij")\n        pts = np.stack(grid, axis=-1).reshape(-1, 3)\n        channels.append(interp(pts).reshape(dst_size, dst_size, dst_size))\n\n    return np.clip(np.stack(channels, axis=-1), 0, 1)\n\n\n# ---------------------------------------------------------------------------\n# Before/after pair → LUT approximation\n# ---------------------------------------------------------------------------\n\n\ndef lut_from_pair(\n    original: Image.Image,\n    graded: Image.Image,\n    lut_size: int = 33,\n) -> tuple[int, np.ndarray]:\n    """Approximate a 3D LUT by comparing original ↔ graded pixel pairs.\n\n    Bins every pixel by its original RGB value into a 3D grid, averages the\n    corresponding graded values per bin. Fills empty bins via nearest-neighbor\n    interpolation.\n    """\n    if original.size != graded.size:\n        # resize graded to match original\n        graded = graded.resize(original.size, Image.LANCZOS)\n\n    orig_px = np.array(original.convert("RGB"), dtype=np.float64).reshape(-1, 3)\n    grad_px = np.array(graded.convert("RGB"), dtype=np.float64).reshape(-1, 3)\n\n    # Quantize original pixels into LUT bins\n    bin_indices = np.clip(\n        (orig_px / 255.0 * (lut_size - 1) + 0.5).astype(int), 0, lut_size - 1\n    )\n\n    # Accumulate\n    lut_sum = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n    lut_count = np.zeros((lut_size, lut_size, lut_size), dtype=np.float64)\n\n    for idx in range(len(orig_px)):\n        r, g, b = bin_indices[idx]\n        lut_sum[b, g, r] += grad_px[idx]\n        lut_count[b, g, r] += 1\n\n    # Average filled bins\n    mask = lut_count > 0\n    lut = np.zeros_like(lut_sum)\n    lut[mask] = lut_sum[mask] / lut_count[mask, np.newaxis] / 255.0\n\n    # Fill empty bins via nearest-neighbor from filled bins\n    empty = ~mask\n    n_empty = empty.sum()\n    if n_empty > 0:\n        from scipy.ndimage import distance_transform_edt\n\n        # distance_transform_edt returns distances and indices of nearest filled cell\n        _, nearest_idx = distance_transform_edt(\n            empty, return_distances=True, return_indices=True\n        )\n        for b_i in range(lut_size):\n            for g_i in range(lut_size):\n                for r_i in range(lut_size):\n                    if empty[b_i, g_i, r_i]:\n                        nb, ng, nr = nearest_idx[:, b_i, g_i, r_i]\n                        lut[b_i, g_i, r_i] = lut[nb, ng, nr]\n\n    return lut_size, lut\n\n\n# ---------------------------------------------------------------------------\n# .cube export\n# ---------------------------------------------------------------------------\n\n\ndef write_cube(path: str, lut_size: int, lut: np.ndarray, title: str = "Inferred LUT"):\n    """Write a 3D LUT in Adobe .cube format.\n\n    lut shape: (lut_size, lut_size, lut_size, 3) with values in [0, 1].\n    Iteration order: R fastest, then G, then B (standard .cube convention).\n    """\n    with open(path, "w") as f:\n        f.write(f'TITLE "{title}"\\n')\n        f.write(f"LUT_3D_SIZE {lut_size}\\n")\n        f.write(f"DOMAIN_MIN 0.0 0.0 0.0\\n")\n        f.write(f"DOMAIN_MAX 1.0 1.0 1.0\\n\\n")\n\n        for b in range(lut_size):\n            for g in range(lut_size):\n                for r in range(lut_size):\n                    rv, gv, bv = lut[b, g, r]\n                    f.write(f"{rv:.6f} {gv:.6f} {bv:.6f}\\n")\n\n\n# ---------------------------------------------------------------------------\n# CLI\n# ---------------------------------------------------------------------------\n\n\ndef main():\n    parser = argparse.ArgumentParser(\n        description="Infer a 3D color LUT from images.",\n        formatter_class=argparse.RawDescriptionHelpFormatter,\n        epilog=__doc__,\n    )\n    sub = parser.add_subparsers(dest="command", required=True)\n\n    # -- hald --\n    p_hald = sub.add_parser("hald", help="Extract LUT from a processed Hald CLUT image")\n    p_hald.add_argument("image", help="Processed Hald CLUT image (PNG, TIFF, etc.)")\n    p_hald.add_argument(\n        "-o", "--output", default="output.cube", help="Output .cube file"\n    )\n    p_hald.add_argument(\n        "-s",\n        "--size",\n        type=int,\n        default=35,\n        help="Output LUT grid size per axis (default 35)",\n    )\n\n    # -- pair --\n    p_pair = sub.add_parser("pair", help="Approximate LUT from original + graded pair")\n    p_pair.add_argument("original", help="Original (ungraded) image")\n    p_pair.add_argument("graded", help="Graded image")\n    p_pair.add_argument(\n        "-o", "--output", default="output.cube", help="Output .cube file"\n    )\n    p_pair.add_argument(\n        "-s",\n        "--size",\n        type=int,\n        default=33,\n        help="LUT grid size per axis (default 33, industry standard)",\n    )\n\n    # -- generate-hald --\n    p_gen = sub.add_parser("generate-hald", help="Generate a neutral Hald CLUT image")\n    p_gen.add_argument(\n        "-s",\n        "--level",\n        type=int,\n        default=8,\n        help="Hald level (default 8 → 512x512 image, 64-entry LUT)",\n    )\n    p_gen.add_argument(\n        "-o", "--output", default="identity_hald.png", help="Output image path"\n    )\n\n    args = parser.parse_args()\n\n    if args.command == "generate-hald":\n        print(f"Generating identity Hald CLUT (level {args.level})...")\n        img = generate_hald(args.level)\n        img.save(args.output)\n        lut_size = args.level**2\n        print(f"Saved {img.size[0]}x{img.size[1]} image → {args.output}")\n        print(\n            f"Resulting LUT will have {lut_size} entries per axis ({lut_size}^3 = {lut_size**3} total)"\n        )\n\n    elif args.command == "hald":\n        print(f"Reading Hald CLUT: {args.image}")\n        img = Image.open(args.image)\n        lut_size, lut = lut_from_hald(img)\n        if args.size != lut_size:\n            print(f"Resampling {lut_size}³ → {args.size}³...")\n            lut = resample_lut(lut, lut_size, args.size)\n            lut_size = args.size\n        write_cube(\n            args.output,\n            lut_size,\n            lut,\n            title=f"Hald-inferred from {Path(args.image).name}",\n        )\n        print(f"Extracted {lut_size}x{lut_size}x{lut_size} LUT → {args.output}")\n\n    elif args.command == "pair":\n        print(f"Original: {args.original}")\n        print(f"Graded:   {args.graded}")\n        orig = Image.open(args.original)\n        grad = Image.open(args.graded)\n        lut_size, lut = lut_from_pair(orig, grad, args.size)\n        write_cube(\n            args.output,\n            lut_size,\n            lut,\n            title=f"Pair-inferred from {Path(args.original).name} → {Path(args.graded).name}",\n        )\n        print(f"Approximated {lut_size}x{lut_size}x{lut_size} LUT → {args.output}")\n\n    print("Done.")\n\n\nif __name__ == "__main__":\n    main()\n

Random

\n
    \n
  • “Dragging your shutter” means using a low shutter speed for things like movement.
    • \n
\n
", "id": "48933311-d0e7-5add-8598-f3b2af75a62c", "modified": "2026-09-18T21:11:04Z", "revisions": [ { "authorEmail": "anand.nikhil@gmail.com", "authorName": "afreeorange", "date": "2026-09-18T21:11:04Z", "id": "78c6e6008b89129c6969832fea88266d04da0ec7", "shortId": "78c6e600", "subject": "Random note\n", "content": "Assorted notes from me trying to teach myself Photography.\n\n## The Triangle\n\nIt's a balance between Aperture, Shutter Speed, and ISO.\n\n## Metering\n\nYour camera will try and advise you. People used to use light meters for this. It will say its a good exposure if it is \"18% Gray\" which is what light meters were historically calibrated to (the caps on Kodak film and the insides of dedicated camera bags are this gray too.)\n\n## The Histogram\n\n- Luminance value on x-axis and pixel count on y-axis.\n- Leftmost edge is Luminance of zero, Rightmost is Luminance of one. Any pixels touching these edges are lost information, they're just crushed out of existence. You can use Zebra stripes to tell you which parts of your image are/will be \"blown out\" in either direction.\n- You section it into, say, five equal portions. From L-R, you are looking at _blacks_, _shadows_, _midtones_, _highlights_, and _whites_.\n\nUsually you want a histogram that looks like a mountain or is kinda balanced out but depends on what you're trying to do, the look you're going for.\n\n## On Aperture\n\nMeasured by f-stop. \"f/2\" means you take the focal length and divide it by two.\n\n\"[f/8 and Be There.](https://www.youtube.com/watch?v=DQcFQ-2dtB0).\" Like _be there_. Your camera primarily exists to take pictures of things and events.\n\n## On ISO\n\n[See this video](https://www.youtube.com/watch?v=ZWSvHBG7X0w). TLDR: This is tricky so let the camera figure it out.\n\n## Tripods\n\n- Cheap, Stable, Light —- pick two. But don't be cheap. You'll change cameras before tripods.\n- [Read this](/assets/tripods-bythom.html) thoroughly.\n- Components are: Legs, Head, Plate, Bag\n - Each component may be purchased separately.\n - Buying a head doesn't necessarily include a plate.\n\n## Lenses\n\nThere are Prime lenses (fixed focal length) and Zoom lenses (can be wide, normal, and/or telephoto lenses).\n\nPrime lenses teach you a lot about photography because they make your lazy ass _move_ and _explore_ a scene: distances and angles.\n\n## Presets and LUTs\n\n- [Presetmator](https://presetmator.com/) -- Photomator/Pixelmator\n- [Bodega Supply](https://bodega.supply/collection/photo-presets) -- Photomator/Pixelmator\n- [FujifilmCameraProfiles](https://github.com/abpy/FujifilmCameraProfiles)\n- [Export LUT](https://johnrellis.com/lightroom/exportlut.htm) Utility\n\n### Hald CLUTs\n\n[These are great](https://github.com/cedeber/hald-clut)!. This gives you a bunch of PNGs that you can \"infer LUTs\" from. Quick Python script that will do this is at the end of this page.\n\nNow the LUT grid size with the PNGs is 144 x 144 x 144 = 2,985,984 which makes the sizes of the `.cube` files explode. That script will downsample to 32 x 32 x 32.\n\n[I've saved the generated `.cube` files here](https://public.nikhil.io/hald-clut-cubes.tgz).\n\n## Other\n\n- [What This NYT/Getty/AP Photojournalist Has Learned After More Than 25 Years in the Field](https://www.youtube.com/watch?v=Ky78k8j2-zc)\n- [How Metering Works](https://www.youtube.com/watch?v=qYGc7QPU3tI) -- A must-watch\n\n### Infer LUT from PNG Script\n\n```python\n#!/usr/bin/env python3\n\"\"\"Infer a 3D color LUT from images and export as .cube file.\n\nModes:\n hald — Extract LUT from a processed Hald CLUT image.\n pair — Approximate LUT from a before/after image pair.\n generate-hald — Generate a neutral Hald CLUT image to use as a reference.\n\nUsage:\n python infer_lut.py hald processed_hald.png -o my.cube\n python infer_lut.py pair original.png graded.png -o my.cube\n python infer_lut.py generate-hald -s 8 -o identity_hald.png\n\"\"\"\n\nimport argparse\nimport numpy as np\nfrom pathlib import Path\nfrom PIL import Image\n\n\n# ---------------------------------------------------------------------------\n# Hald CLUT helpers\n# ---------------------------------------------------------------------------\n\n\ndef hald_level_from_image(img: Image.Image) -> int:\n \"\"\"Determine the Hald level from image dimensions.\n\n A Hald CLUT of level N has dimensions (N^3) x (N^3).\n The resulting 3D LUT has N^2 entries per axis.\n Common levels: 4 → 64x64 image, 16-entry LUT\n 8 → 512x512 image, 64-entry LUT\n 12 → 1728x1728 image, 144-entry LUT\n \"\"\"\n w, h = img.size\n if w != h:\n raise ValueError(f\"Hald CLUT must be square, got {w}x{h}\")\n # w = level^3\n level = round(w ** (1 / 3))\n if level**3 != w:\n raise ValueError(\n f\"Image size {w}x{h} is not a valid Hald CLUT dimension (need N^3 x N^3)\"\n )\n return level\n\n\ndef generate_hald(level: int) -> Image.Image:\n \"\"\"Generate a neutral (identity) Hald CLUT image.\"\"\"\n lut_size = level * level # entries per axis in the 3D LUT\n dim = level**3 # pixel width/height of the Hald image\n pixels = np.zeros((dim * dim, 3), dtype=np.uint8)\n\n for i in range(dim * dim):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n pixels[i] = [\n round(r / (lut_size - 1) * 255),\n round(g / (lut_size - 1) * 255),\n round(b / (lut_size - 1) * 255),\n ]\n\n return Image.fromarray(pixels.reshape(dim, dim, 3))\n\n\ndef lut_from_hald(img: Image.Image) -> tuple[int, np.ndarray]:\n \"\"\"Extract a 3D LUT from a processed Hald CLUT image.\n\n Returns (lut_size, lut) where lut has shape (lut_size, lut_size, lut_size, 3)\n with float values in [0, 1].\n \"\"\"\n level = hald_level_from_image(img)\n lut_size = level * level\n dim = level**3\n\n pixels = np.array(img.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3) / 255.0\n expected = dim * dim\n if len(pixels) != expected:\n raise ValueError(f\"Expected {expected} pixels, got {len(pixels)}\")\n\n lut = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n for i in range(expected):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n lut[b, g, r] = pixels[i]\n\n return lut_size, lut\n\n\ndef resample_lut(lut: np.ndarray, src_size: int, dst_size: int) -> np.ndarray:\n \"\"\"Resample a 3D LUT to a different grid size via trilinear interpolation.\"\"\"\n from scipy.interpolate import RegularGridInterpolator\n\n axis = np.linspace(0, 1, src_size)\n channels = []\n for ch in range(3):\n interp = RegularGridInterpolator(\n (axis, axis, axis), lut[:, :, :, ch], method=\"linear\"\n )\n dst_axis = np.linspace(0, 1, dst_size)\n grid = np.meshgrid(dst_axis, dst_axis, dst_axis, indexing=\"ij\")\n pts = np.stack(grid, axis=-1).reshape(-1, 3)\n channels.append(interp(pts).reshape(dst_size, dst_size, dst_size))\n\n return np.clip(np.stack(channels, axis=-1), 0, 1)\n\n\n# ---------------------------------------------------------------------------\n# Before/after pair → LUT approximation\n# ---------------------------------------------------------------------------\n\n\ndef lut_from_pair(\n original: Image.Image,\n graded: Image.Image,\n lut_size: int = 33,\n) -> tuple[int, np.ndarray]:\n \"\"\"Approximate a 3D LUT by comparing original ↔ graded pixel pairs.\n\n Bins every pixel by its original RGB value into a 3D grid, averages the\n corresponding graded values per bin. Fills empty bins via nearest-neighbor\n interpolation.\n \"\"\"\n if original.size != graded.size:\n # resize graded to match original\n graded = graded.resize(original.size, Image.LANCZOS)\n\n orig_px = np.array(original.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n grad_px = np.array(graded.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n\n # Quantize original pixels into LUT bins\n bin_indices = np.clip(\n (orig_px / 255.0 * (lut_size - 1) + 0.5).astype(int), 0, lut_size - 1\n )\n\n # Accumulate\n lut_sum = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n lut_count = np.zeros((lut_size, lut_size, lut_size), dtype=np.float64)\n\n for idx in range(len(orig_px)):\n r, g, b = bin_indices[idx]\n lut_sum[b, g, r] += grad_px[idx]\n lut_count[b, g, r] += 1\n\n # Average filled bins\n mask = lut_count > 0\n lut = np.zeros_like(lut_sum)\n lut[mask] = lut_sum[mask] / lut_count[mask, np.newaxis] / 255.0\n\n # Fill empty bins via nearest-neighbor from filled bins\n empty = ~mask\n n_empty = empty.sum()\n if n_empty > 0:\n from scipy.ndimage import distance_transform_edt\n\n # distance_transform_edt returns distances and indices of nearest filled cell\n _, nearest_idx = distance_transform_edt(\n empty, return_distances=True, return_indices=True\n )\n for b_i in range(lut_size):\n for g_i in range(lut_size):\n for r_i in range(lut_size):\n if empty[b_i, g_i, r_i]:\n nb, ng, nr = nearest_idx[:, b_i, g_i, r_i]\n lut[b_i, g_i, r_i] = lut[nb, ng, nr]\n\n return lut_size, lut\n\n\n# ---------------------------------------------------------------------------\n# .cube export\n# ---------------------------------------------------------------------------\n\n\ndef write_cube(path: str, lut_size: int, lut: np.ndarray, title: str = \"Inferred LUT\"):\n \"\"\"Write a 3D LUT in Adobe .cube format.\n\n lut shape: (lut_size, lut_size, lut_size, 3) with values in [0, 1].\n Iteration order: R fastest, then G, then B (standard .cube convention).\n \"\"\"\n with open(path, \"w\") as f:\n f.write(f'TITLE \"{title}\"\\n')\n f.write(f\"LUT_3D_SIZE {lut_size}\\n\")\n f.write(f\"DOMAIN_MIN 0.0 0.0 0.0\\n\")\n f.write(f\"DOMAIN_MAX 1.0 1.0 1.0\\n\\n\")\n\n for b in range(lut_size):\n for g in range(lut_size):\n for r in range(lut_size):\n rv, gv, bv = lut[b, g, r]\n f.write(f\"{rv:.6f} {gv:.6f} {bv:.6f}\\n\")\n\n\n# ---------------------------------------------------------------------------\n# CLI\n# ---------------------------------------------------------------------------\n\n\ndef main():\n parser = argparse.ArgumentParser(\n description=\"Infer a 3D color LUT from images.\",\n formatter_class=argparse.RawDescriptionHelpFormatter,\n epilog=__doc__,\n )\n sub = parser.add_subparsers(dest=\"command\", required=True)\n\n # -- hald --\n p_hald = sub.add_parser(\"hald\", help=\"Extract LUT from a processed Hald CLUT image\")\n p_hald.add_argument(\"image\", help=\"Processed Hald CLUT image (PNG, TIFF, etc.)\")\n p_hald.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_hald.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=35,\n help=\"Output LUT grid size per axis (default 35)\",\n )\n\n # -- pair --\n p_pair = sub.add_parser(\"pair\", help=\"Approximate LUT from original + graded pair\")\n p_pair.add_argument(\"original\", help=\"Original (ungraded) image\")\n p_pair.add_argument(\"graded\", help=\"Graded image\")\n p_pair.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_pair.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=33,\n help=\"LUT grid size per axis (default 33, industry standard)\",\n )\n\n # -- generate-hald --\n p_gen = sub.add_parser(\"generate-hald\", help=\"Generate a neutral Hald CLUT image\")\n p_gen.add_argument(\n \"-s\",\n \"--level\",\n type=int,\n default=8,\n help=\"Hald level (default 8 → 512x512 image, 64-entry LUT)\",\n )\n p_gen.add_argument(\n \"-o\", \"--output\", default=\"identity_hald.png\", help=\"Output image path\"\n )\n\n args = parser.parse_args()\n\n if args.command == \"generate-hald\":\n print(f\"Generating identity Hald CLUT (level {args.level})...\")\n img = generate_hald(args.level)\n img.save(args.output)\n lut_size = args.level**2\n print(f\"Saved {img.size[0]}x{img.size[1]} image → {args.output}\")\n print(\n f\"Resulting LUT will have {lut_size} entries per axis ({lut_size}^3 = {lut_size**3} total)\"\n )\n\n elif args.command == \"hald\":\n print(f\"Reading Hald CLUT: {args.image}\")\n img = Image.open(args.image)\n lut_size, lut = lut_from_hald(img)\n if args.size != lut_size:\n print(f\"Resampling {lut_size}³ → {args.size}³...\")\n lut = resample_lut(lut, lut_size, args.size)\n lut_size = args.size\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Hald-inferred from {Path(args.image).name}\",\n )\n print(f\"Extracted {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n elif args.command == \"pair\":\n print(f\"Original: {args.original}\")\n print(f\"Graded: {args.graded}\")\n orig = Image.open(args.original)\n grad = Image.open(args.graded)\n lut_size, lut = lut_from_pair(orig, grad, args.size)\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Pair-inferred from {Path(args.original).name} → {Path(args.graded).name}\",\n )\n print(f\"Approximated {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n print(\"Done.\")\n\n\nif __name__ == \"__main__\":\n main()\n```\n\n### Random\n\n- \"Dragging your shutter\" means using a low shutter speed for things like movement.\n" }, { "authorEmail": "anand.nikhil@gmail.com", "authorName": "afreeorange", "date": "2026-08-04T20:51:16Z", "id": "3466f38a62ebe0c63fafb2bb05b981a59689d40c", "shortId": "3466f38a", "subject": "Add link to cube files\n", "content": "Assorted notes from me trying to teach myself Photography.\n\n## The Triangle\n\nIt's a balance between Aperture, Shutter Speed, and ISO.\n\n## Metering\n\nYour camera will try and advise you. People used to use light meters for this. It will say its a good exposure if it is \"18% Gray\" which is what light meters were historically calibrated to (the caps on Kodak film and the insides of dedicated camera bags are this gray too.)\n\n## The Histogram\n\n- Luminance value on x-axis and pixel count on y-axis.\n- Leftmost edge is Luminance of zero, Rightmost is Luminance of one. Any pixels touching these edges are lost information, they're just crushed out of existence. You can use Zebra stripes to tell you which parts of your image are/will be \"blown out\" in either direction.\n- You section it into, say, five equal portions. From L-R, you are looking at _blacks_, _shadows_, _midtones_, _highlights_, and _whites_.\n\nUsually you want a histogram that looks like a mountain or is kinda balanced out but depends on what you're trying to do, the look you're going for.\n\n## On Aperture\n\nMeasured by f-stop. \"f/2\" means you take the focal length and divide it by two.\n\n\"[f/8 and Be There.](https://www.youtube.com/watch?v=DQcFQ-2dtB0).\" Like _be there_. Your camera primarily exists to take pictures of things and events.\n\n## On ISO\n\n[See this video](https://www.youtube.com/watch?v=ZWSvHBG7X0w). TLDR: This is tricky so let the camera figure it out.\n\n## Tripods\n\n- Cheap, Stable, Light —- pick two. But don't be cheap. You'll change cameras before tripods.\n- [Read this](/assets/tripods-bythom.html) thoroughly.\n- Components are: Legs, Head, Plate, Bag\n - Each component may be purchased separately.\n - Buying a head doesn't necessarily include a plate.\n\n## Lenses\n\nThere are Prime lenses (fixed focal length) and Zoom lenses (can be wide, normal, and/or telephoto lenses).\n\nPrime lenses teach you a lot about photography because they make your lazy ass _move_ and _explore_ a scene: distances and angles.\n\n## Presets and LUTs\n\n- [Presetmator](https://presetmator.com/) -- Photomator/Pixelmator\n- [Bodega Supply](https://bodega.supply/collection/photo-presets) -- Photomator/Pixelmator\n- [FujifilmCameraProfiles](https://github.com/abpy/FujifilmCameraProfiles)\n- [Export LUT](https://johnrellis.com/lightroom/exportlut.htm) Utility\n\n### Hald CLUTs\n\n[These are great](https://github.com/cedeber/hald-clut)!. This gives you a bunch of PNGs that you can \"infer LUTs\" from. Quick Python script that will do this is at the end of this page.\n\nNow the LUT grid size with the PNGs is 144 x 144 x 144 = 2,985,984 which makes the sizes of the `.cube` files explode. That script will downsample to 32 x 32 x 32.\n\n[I've saved the generated `.cube` files here](https://public.nikhil.io/hald-clut-cubes.tgz).\n\n## Other\n\n- [What This NYT/Getty/AP Photojournalist Has Learned After More Than 25 Years in the Field](https://www.youtube.com/watch?v=Ky78k8j2-zc)\n- [How Metering Works](https://www.youtube.com/watch?v=qYGc7QPU3tI) -- A must-watch\n\n### Infer LUT from PNG Script\n\n```python\n#!/usr/bin/env python3\n\"\"\"Infer a 3D color LUT from images and export as .cube file.\n\nModes:\n hald — Extract LUT from a processed Hald CLUT image.\n pair — Approximate LUT from a before/after image pair.\n generate-hald — Generate a neutral Hald CLUT image to use as a reference.\n\nUsage:\n python infer_lut.py hald processed_hald.png -o my.cube\n python infer_lut.py pair original.png graded.png -o my.cube\n python infer_lut.py generate-hald -s 8 -o identity_hald.png\n\"\"\"\n\nimport argparse\nimport numpy as np\nfrom pathlib import Path\nfrom PIL import Image\n\n\n# ---------------------------------------------------------------------------\n# Hald CLUT helpers\n# ---------------------------------------------------------------------------\n\n\ndef hald_level_from_image(img: Image.Image) -> int:\n \"\"\"Determine the Hald level from image dimensions.\n\n A Hald CLUT of level N has dimensions (N^3) x (N^3).\n The resulting 3D LUT has N^2 entries per axis.\n Common levels: 4 → 64x64 image, 16-entry LUT\n 8 → 512x512 image, 64-entry LUT\n 12 → 1728x1728 image, 144-entry LUT\n \"\"\"\n w, h = img.size\n if w != h:\n raise ValueError(f\"Hald CLUT must be square, got {w}x{h}\")\n # w = level^3\n level = round(w ** (1 / 3))\n if level**3 != w:\n raise ValueError(\n f\"Image size {w}x{h} is not a valid Hald CLUT dimension (need N^3 x N^3)\"\n )\n return level\n\n\ndef generate_hald(level: int) -> Image.Image:\n \"\"\"Generate a neutral (identity) Hald CLUT image.\"\"\"\n lut_size = level * level # entries per axis in the 3D LUT\n dim = level**3 # pixel width/height of the Hald image\n pixels = np.zeros((dim * dim, 3), dtype=np.uint8)\n\n for i in range(dim * dim):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n pixels[i] = [\n round(r / (lut_size - 1) * 255),\n round(g / (lut_size - 1) * 255),\n round(b / (lut_size - 1) * 255),\n ]\n\n return Image.fromarray(pixels.reshape(dim, dim, 3))\n\n\ndef lut_from_hald(img: Image.Image) -> tuple[int, np.ndarray]:\n \"\"\"Extract a 3D LUT from a processed Hald CLUT image.\n\n Returns (lut_size, lut) where lut has shape (lut_size, lut_size, lut_size, 3)\n with float values in [0, 1].\n \"\"\"\n level = hald_level_from_image(img)\n lut_size = level * level\n dim = level**3\n\n pixels = np.array(img.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3) / 255.0\n expected = dim * dim\n if len(pixels) != expected:\n raise ValueError(f\"Expected {expected} pixels, got {len(pixels)}\")\n\n lut = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n for i in range(expected):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n lut[b, g, r] = pixels[i]\n\n return lut_size, lut\n\n\ndef resample_lut(lut: np.ndarray, src_size: int, dst_size: int) -> np.ndarray:\n \"\"\"Resample a 3D LUT to a different grid size via trilinear interpolation.\"\"\"\n from scipy.interpolate import RegularGridInterpolator\n\n axis = np.linspace(0, 1, src_size)\n channels = []\n for ch in range(3):\n interp = RegularGridInterpolator(\n (axis, axis, axis), lut[:, :, :, ch], method=\"linear\"\n )\n dst_axis = np.linspace(0, 1, dst_size)\n grid = np.meshgrid(dst_axis, dst_axis, dst_axis, indexing=\"ij\")\n pts = np.stack(grid, axis=-1).reshape(-1, 3)\n channels.append(interp(pts).reshape(dst_size, dst_size, dst_size))\n\n return np.clip(np.stack(channels, axis=-1), 0, 1)\n\n\n# ---------------------------------------------------------------------------\n# Before/after pair → LUT approximation\n# ---------------------------------------------------------------------------\n\n\ndef lut_from_pair(\n original: Image.Image,\n graded: Image.Image,\n lut_size: int = 33,\n) -> tuple[int, np.ndarray]:\n \"\"\"Approximate a 3D LUT by comparing original ↔ graded pixel pairs.\n\n Bins every pixel by its original RGB value into a 3D grid, averages the\n corresponding graded values per bin. Fills empty bins via nearest-neighbor\n interpolation.\n \"\"\"\n if original.size != graded.size:\n # resize graded to match original\n graded = graded.resize(original.size, Image.LANCZOS)\n\n orig_px = np.array(original.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n grad_px = np.array(graded.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n\n # Quantize original pixels into LUT bins\n bin_indices = np.clip(\n (orig_px / 255.0 * (lut_size - 1) + 0.5).astype(int), 0, lut_size - 1\n )\n\n # Accumulate\n lut_sum = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n lut_count = np.zeros((lut_size, lut_size, lut_size), dtype=np.float64)\n\n for idx in range(len(orig_px)):\n r, g, b = bin_indices[idx]\n lut_sum[b, g, r] += grad_px[idx]\n lut_count[b, g, r] += 1\n\n # Average filled bins\n mask = lut_count > 0\n lut = np.zeros_like(lut_sum)\n lut[mask] = lut_sum[mask] / lut_count[mask, np.newaxis] / 255.0\n\n # Fill empty bins via nearest-neighbor from filled bins\n empty = ~mask\n n_empty = empty.sum()\n if n_empty > 0:\n from scipy.ndimage import distance_transform_edt\n\n # distance_transform_edt returns distances and indices of nearest filled cell\n _, nearest_idx = distance_transform_edt(\n empty, return_distances=True, return_indices=True\n )\n for b_i in range(lut_size):\n for g_i in range(lut_size):\n for r_i in range(lut_size):\n if empty[b_i, g_i, r_i]:\n nb, ng, nr = nearest_idx[:, b_i, g_i, r_i]\n lut[b_i, g_i, r_i] = lut[nb, ng, nr]\n\n return lut_size, lut\n\n\n# ---------------------------------------------------------------------------\n# .cube export\n# ---------------------------------------------------------------------------\n\n\ndef write_cube(path: str, lut_size: int, lut: np.ndarray, title: str = \"Inferred LUT\"):\n \"\"\"Write a 3D LUT in Adobe .cube format.\n\n lut shape: (lut_size, lut_size, lut_size, 3) with values in [0, 1].\n Iteration order: R fastest, then G, then B (standard .cube convention).\n \"\"\"\n with open(path, \"w\") as f:\n f.write(f'TITLE \"{title}\"\\n')\n f.write(f\"LUT_3D_SIZE {lut_size}\\n\")\n f.write(f\"DOMAIN_MIN 0.0 0.0 0.0\\n\")\n f.write(f\"DOMAIN_MAX 1.0 1.0 1.0\\n\\n\")\n\n for b in range(lut_size):\n for g in range(lut_size):\n for r in range(lut_size):\n rv, gv, bv = lut[b, g, r]\n f.write(f\"{rv:.6f} {gv:.6f} {bv:.6f}\\n\")\n\n\n# ---------------------------------------------------------------------------\n# CLI\n# ---------------------------------------------------------------------------\n\n\ndef main():\n parser = argparse.ArgumentParser(\n description=\"Infer a 3D color LUT from images.\",\n formatter_class=argparse.RawDescriptionHelpFormatter,\n epilog=__doc__,\n )\n sub = parser.add_subparsers(dest=\"command\", required=True)\n\n # -- hald --\n p_hald = sub.add_parser(\"hald\", help=\"Extract LUT from a processed Hald CLUT image\")\n p_hald.add_argument(\"image\", help=\"Processed Hald CLUT image (PNG, TIFF, etc.)\")\n p_hald.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_hald.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=35,\n help=\"Output LUT grid size per axis (default 35)\",\n )\n\n # -- pair --\n p_pair = sub.add_parser(\"pair\", help=\"Approximate LUT from original + graded pair\")\n p_pair.add_argument(\"original\", help=\"Original (ungraded) image\")\n p_pair.add_argument(\"graded\", help=\"Graded image\")\n p_pair.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_pair.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=33,\n help=\"LUT grid size per axis (default 33, industry standard)\",\n )\n\n # -- generate-hald --\n p_gen = sub.add_parser(\"generate-hald\", help=\"Generate a neutral Hald CLUT image\")\n p_gen.add_argument(\n \"-s\",\n \"--level\",\n type=int,\n default=8,\n help=\"Hald level (default 8 → 512x512 image, 64-entry LUT)\",\n )\n p_gen.add_argument(\n \"-o\", \"--output\", default=\"identity_hald.png\", help=\"Output image path\"\n )\n\n args = parser.parse_args()\n\n if args.command == \"generate-hald\":\n print(f\"Generating identity Hald CLUT (level {args.level})...\")\n img = generate_hald(args.level)\n img.save(args.output)\n lut_size = args.level**2\n print(f\"Saved {img.size[0]}x{img.size[1]} image → {args.output}\")\n print(\n f\"Resulting LUT will have {lut_size} entries per axis ({lut_size}^3 = {lut_size**3} total)\"\n )\n\n elif args.command == \"hald\":\n print(f\"Reading Hald CLUT: {args.image}\")\n img = Image.open(args.image)\n lut_size, lut = lut_from_hald(img)\n if args.size != lut_size:\n print(f\"Resampling {lut_size}³ → {args.size}³...\")\n lut = resample_lut(lut, lut_size, args.size)\n lut_size = args.size\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Hald-inferred from {Path(args.image).name}\",\n )\n print(f\"Extracted {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n elif args.command == \"pair\":\n print(f\"Original: {args.original}\")\n print(f\"Graded: {args.graded}\")\n orig = Image.open(args.original)\n grad = Image.open(args.graded)\n lut_size, lut = lut_from_pair(orig, grad, args.size)\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Pair-inferred from {Path(args.original).name} → {Path(args.graded).name}\",\n )\n print(f\"Approximated {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n print(\"Done.\")\n\n\nif __name__ == \"__main__\":\n main()\n```\n\n" }, { "authorEmail": "anand.nikhil@gmail.com", "authorName": "afreeorange", "date": "2026-08-04T20:39:12Z", "id": "42b3b55afcca1d933b32b84144fb8c9abd2fd8a7", "shortId": "42b3b55a", "subject": "Hald CLUTs + reorg\n", "content": "Assorted notes from me trying to teach myself Photography.\n\n## The Triangle\n\nIt's a balance between Aperture, Shutter Speed, and ISO.\n\n## Metering\n\nYour camera will try and advise you. People used to use light meters for this. It will say its a good exposure if it is \"18% Gray\" which is what light meters were historically calibrated to (the caps on Kodak film and the insides of dedicated camera bags are this gray too.)\n\n## The Histogram\n\n- Luminance value on x-axis and pixel count on y-axis.\n- Leftmost edge is Luminance of zero, Rightmost is Luminance of one. Any pixels touching these edges are lost information, they're just crushed out of existence. You can use Zebra stripes to tell you which parts of your image are/will be \"blown out\" in either direction.\n- You section it into, say, five equal portions. From L-R, you are looking at _blacks_, _shadows_, _midtones_, _highlights_, and _whites_.\n\nUsually you want a histogram that looks like a mountain or is kinda balanced out but depends on what you're trying to do, the look you're going for.\n\n## On Aperture\n\nMeasured by f-stop. \"f/2\" means you take the focal length and divide it by two.\n\n\"[f/8 and Be There.](https://www.youtube.com/watch?v=DQcFQ-2dtB0).\" Like _be there_. Your camera primarily exists to take pictures of things and events.\n\n## On ISO\n\n[See this video](https://www.youtube.com/watch?v=ZWSvHBG7X0w). TLDR: This is tricky so let the camera figure it out.\n\n## Tripods\n\n- Cheap, Stable, Light —- pick two. But don't be cheap. You'll change cameras before tripods.\n- [Read this](/assets/tripods-bythom.html) thoroughly.\n- Components are: Legs, Head, Plate, Bag\n - Each component may be purchased separately.\n - Buying a head doesn't necessarily include a plate.\n\n## Lenses\n\nThere are Prime lenses (fixed focal length) and Zoom lenses (can be wide, normal, and/or telephoto lenses).\n\nPrime lenses teach you a lot about photography because they make your lazy ass _move_ and _explore_ a scene: distances and angles.\n\n## Presets and LUTs\n\n- [Presetmator](https://presetmator.com/) -- Photomator/Pixelmator\n- [Bodega Supply](https://bodega.supply/collection/photo-presets) -- Photomator/Pixelmator\n- [FujifilmCameraProfiles](https://github.com/abpy/FujifilmCameraProfiles)\n- [Export LUT](https://johnrellis.com/lightroom/exportlut.htm) Utility\n\n### Hald CLUTs\n\n[These are great](https://github.com/cedeber/hald-clut)!. This gives you a bunch of PNGs that you can \"infer LUTs\" from. Quick Python script that will do this is at the end of this page.\n\nNow the LUT grid size with the PNGs is 144 x 144 x 144 = 2,985,984 which makes the sizes of the `.cube` files explode. That script will downsample to 32 x 32 x 32.\n\n## Other\n\n- [What This NYT/Getty/AP Photojournalist Has Learned After More Than 25 Years in the Field](https://www.youtube.com/watch?v=Ky78k8j2-zc)\n- [How Metering Works](https://www.youtube.com/watch?v=qYGc7QPU3tI) -- A must-watch\n\n### Infer LUT from PNG Script\n\n```python\n#!/usr/bin/env python3\n\"\"\"Infer a 3D color LUT from images and export as .cube file.\n\nModes:\n hald — Extract LUT from a processed Hald CLUT image.\n pair — Approximate LUT from a before/after image pair.\n generate-hald — Generate a neutral Hald CLUT image to use as a reference.\n\nUsage:\n python infer_lut.py hald processed_hald.png -o my.cube\n python infer_lut.py pair original.png graded.png -o my.cube\n python infer_lut.py generate-hald -s 8 -o identity_hald.png\n\"\"\"\n\nimport argparse\nimport numpy as np\nfrom pathlib import Path\nfrom PIL import Image\n\n\n# ---------------------------------------------------------------------------\n# Hald CLUT helpers\n# ---------------------------------------------------------------------------\n\n\ndef hald_level_from_image(img: Image.Image) -> int:\n \"\"\"Determine the Hald level from image dimensions.\n\n A Hald CLUT of level N has dimensions (N^3) x (N^3).\n The resulting 3D LUT has N^2 entries per axis.\n Common levels: 4 → 64x64 image, 16-entry LUT\n 8 → 512x512 image, 64-entry LUT\n 12 → 1728x1728 image, 144-entry LUT\n \"\"\"\n w, h = img.size\n if w != h:\n raise ValueError(f\"Hald CLUT must be square, got {w}x{h}\")\n # w = level^3\n level = round(w ** (1 / 3))\n if level**3 != w:\n raise ValueError(\n f\"Image size {w}x{h} is not a valid Hald CLUT dimension (need N^3 x N^3)\"\n )\n return level\n\n\ndef generate_hald(level: int) -> Image.Image:\n \"\"\"Generate a neutral (identity) Hald CLUT image.\"\"\"\n lut_size = level * level # entries per axis in the 3D LUT\n dim = level**3 # pixel width/height of the Hald image\n pixels = np.zeros((dim * dim, 3), dtype=np.uint8)\n\n for i in range(dim * dim):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n pixels[i] = [\n round(r / (lut_size - 1) * 255),\n round(g / (lut_size - 1) * 255),\n round(b / (lut_size - 1) * 255),\n ]\n\n return Image.fromarray(pixels.reshape(dim, dim, 3))\n\n\ndef lut_from_hald(img: Image.Image) -> tuple[int, np.ndarray]:\n \"\"\"Extract a 3D LUT from a processed Hald CLUT image.\n\n Returns (lut_size, lut) where lut has shape (lut_size, lut_size, lut_size, 3)\n with float values in [0, 1].\n \"\"\"\n level = hald_level_from_image(img)\n lut_size = level * level\n dim = level**3\n\n pixels = np.array(img.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3) / 255.0\n expected = dim * dim\n if len(pixels) != expected:\n raise ValueError(f\"Expected {expected} pixels, got {len(pixels)}\")\n\n lut = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n for i in range(expected):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n lut[b, g, r] = pixels[i]\n\n return lut_size, lut\n\n\ndef resample_lut(lut: np.ndarray, src_size: int, dst_size: int) -> np.ndarray:\n \"\"\"Resample a 3D LUT to a different grid size via trilinear interpolation.\"\"\"\n from scipy.interpolate import RegularGridInterpolator\n\n axis = np.linspace(0, 1, src_size)\n channels = []\n for ch in range(3):\n interp = RegularGridInterpolator(\n (axis, axis, axis), lut[:, :, :, ch], method=\"linear\"\n )\n dst_axis = np.linspace(0, 1, dst_size)\n grid = np.meshgrid(dst_axis, dst_axis, dst_axis, indexing=\"ij\")\n pts = np.stack(grid, axis=-1).reshape(-1, 3)\n channels.append(interp(pts).reshape(dst_size, dst_size, dst_size))\n\n return np.clip(np.stack(channels, axis=-1), 0, 1)\n\n\n# ---------------------------------------------------------------------------\n# Before/after pair → LUT approximation\n# ---------------------------------------------------------------------------\n\n\ndef lut_from_pair(\n original: Image.Image,\n graded: Image.Image,\n lut_size: int = 33,\n) -> tuple[int, np.ndarray]:\n \"\"\"Approximate a 3D LUT by comparing original ↔ graded pixel pairs.\n\n Bins every pixel by its original RGB value into a 3D grid, averages the\n corresponding graded values per bin. Fills empty bins via nearest-neighbor\n interpolation.\n \"\"\"\n if original.size != graded.size:\n # resize graded to match original\n graded = graded.resize(original.size, Image.LANCZOS)\n\n orig_px = np.array(original.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n grad_px = np.array(graded.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n\n # Quantize original pixels into LUT bins\n bin_indices = np.clip(\n (orig_px / 255.0 * (lut_size - 1) + 0.5).astype(int), 0, lut_size - 1\n )\n\n # Accumulate\n lut_sum = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n lut_count = np.zeros((lut_size, lut_size, lut_size), dtype=np.float64)\n\n for idx in range(len(orig_px)):\n r, g, b = bin_indices[idx]\n lut_sum[b, g, r] += grad_px[idx]\n lut_count[b, g, r] += 1\n\n # Average filled bins\n mask = lut_count > 0\n lut = np.zeros_like(lut_sum)\n lut[mask] = lut_sum[mask] / lut_count[mask, np.newaxis] / 255.0\n\n # Fill empty bins via nearest-neighbor from filled bins\n empty = ~mask\n n_empty = empty.sum()\n if n_empty > 0:\n from scipy.ndimage import distance_transform_edt\n\n # distance_transform_edt returns distances and indices of nearest filled cell\n _, nearest_idx = distance_transform_edt(\n empty, return_distances=True, return_indices=True\n )\n for b_i in range(lut_size):\n for g_i in range(lut_size):\n for r_i in range(lut_size):\n if empty[b_i, g_i, r_i]:\n nb, ng, nr = nearest_idx[:, b_i, g_i, r_i]\n lut[b_i, g_i, r_i] = lut[nb, ng, nr]\n\n return lut_size, lut\n\n\n# ---------------------------------------------------------------------------\n# .cube export\n# ---------------------------------------------------------------------------\n\n\ndef write_cube(path: str, lut_size: int, lut: np.ndarray, title: str = \"Inferred LUT\"):\n \"\"\"Write a 3D LUT in Adobe .cube format.\n\n lut shape: (lut_size, lut_size, lut_size, 3) with values in [0, 1].\n Iteration order: R fastest, then G, then B (standard .cube convention).\n \"\"\"\n with open(path, \"w\") as f:\n f.write(f'TITLE \"{title}\"\\n')\n f.write(f\"LUT_3D_SIZE {lut_size}\\n\")\n f.write(f\"DOMAIN_MIN 0.0 0.0 0.0\\n\")\n f.write(f\"DOMAIN_MAX 1.0 1.0 1.0\\n\\n\")\n\n for b in range(lut_size):\n for g in range(lut_size):\n for r in range(lut_size):\n rv, gv, bv = lut[b, g, r]\n f.write(f\"{rv:.6f} {gv:.6f} {bv:.6f}\\n\")\n\n\n# ---------------------------------------------------------------------------\n# CLI\n# ---------------------------------------------------------------------------\n\n\ndef main():\n parser = argparse.ArgumentParser(\n description=\"Infer a 3D color LUT from images.\",\n formatter_class=argparse.RawDescriptionHelpFormatter,\n epilog=__doc__,\n )\n sub = parser.add_subparsers(dest=\"command\", required=True)\n\n # -- hald --\n p_hald = sub.add_parser(\"hald\", help=\"Extract LUT from a processed Hald CLUT image\")\n p_hald.add_argument(\"image\", help=\"Processed Hald CLUT image (PNG, TIFF, etc.)\")\n p_hald.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_hald.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=35,\n help=\"Output LUT grid size per axis (default 35)\",\n )\n\n # -- pair --\n p_pair = sub.add_parser(\"pair\", help=\"Approximate LUT from original + graded pair\")\n p_pair.add_argument(\"original\", help=\"Original (ungraded) image\")\n p_pair.add_argument(\"graded\", help=\"Graded image\")\n p_pair.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_pair.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=33,\n help=\"LUT grid size per axis (default 33, industry standard)\",\n )\n\n # -- generate-hald --\n p_gen = sub.add_parser(\"generate-hald\", help=\"Generate a neutral Hald CLUT image\")\n p_gen.add_argument(\n \"-s\",\n \"--level\",\n type=int,\n default=8,\n help=\"Hald level (default 8 → 512x512 image, 64-entry LUT)\",\n )\n p_gen.add_argument(\n \"-o\", \"--output\", default=\"identity_hald.png\", help=\"Output image path\"\n )\n\n args = parser.parse_args()\n\n if args.command == \"generate-hald\":\n print(f\"Generating identity Hald CLUT (level {args.level})...\")\n img = generate_hald(args.level)\n img.save(args.output)\n lut_size = args.level**2\n print(f\"Saved {img.size[0]}x{img.size[1]} image → {args.output}\")\n print(\n f\"Resulting LUT will have {lut_size} entries per axis ({lut_size}^3 = {lut_size**3} total)\"\n )\n\n elif args.command == \"hald\":\n print(f\"Reading Hald CLUT: {args.image}\")\n img = Image.open(args.image)\n lut_size, lut = lut_from_hald(img)\n if args.size != lut_size:\n print(f\"Resampling {lut_size}³ → {args.size}³...\")\n lut = resample_lut(lut, lut_size, args.size)\n lut_size = args.size\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Hald-inferred from {Path(args.image).name}\",\n )\n print(f\"Extracted {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n elif args.command == \"pair\":\n print(f\"Original: {args.original}\")\n print(f\"Graded: {args.graded}\")\n orig = Image.open(args.original)\n grad = Image.open(args.graded)\n lut_size, lut = lut_from_pair(orig, grad, args.size)\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Pair-inferred from {Path(args.original).name} → {Path(args.graded).name}\",\n )\n print(f\"Approximated {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n print(\"Done.\")\n\n\nif __name__ == \"__main__\":\n main()\n```\n\n" }, { "authorEmail": "anand.nikhil@gmail.com", "authorName": "afreeorange", "date": "2026-07-26T23:46:03Z", "id": "68a4c4b0d884962bd9068eabb592c7a25df259aa", "shortId": "68a4c4b0", "subject": "Clarify histo regions\n", "content": "Assorted notes from me trying to teach myself Photography.\n\n## The Triangle\n\nIt's a balance between Aperture, Shutter Speed, and ISO.\n\n## Metering\n\nYour camera will try and advise you. People used to use light meters for this. It will say its a good exposure if it is \"18% Gray\" which is what light meters were historically calibrated to (the caps on Kodak film and the insides of dedicated camera bags are this gray too.)\n\n## The Histogram\n\n- Luminance value on x-axis and pixel count on y-axis.\n- Leftmost edge is Luminance of zero, Rightmost is Luminance of one. Any pixels touching these edges are lost information, they're just crushed out of existence. You can use Zebra stripes to tell you which parts of your image are/will be \"blown out\" in either direction.\n- You section it into, say, five equal portions. From L-R, you are looking at _blacks_, _shadows_, _midtones_, _highlights_, and _whites_.\n\nUsually you want a histogram that looks like a mountain or is kinda balanced out but depends on what you're trying to do, the look you're going for.\n\n## On Aperture\n\nMeasured by f-stop. \"f/2\" means you take the focal length and divide it by two.\n\n\"[f/8 and Be There.](https://www.youtube.com/watch?v=DQcFQ-2dtB0).\" Like _be there_. Your camera primarily exists to take pictures of things and events.\n\n## On ISO\n\n[See this video](https://www.youtube.com/watch?v=ZWSvHBG7X0w). TLDR: This is tricky so let the camera figure it out.\n\n## Tripods\n\n- Cheap, Stable, Light —- pick two. But don't be cheap. You'll change cameras before tripods.\n- [Read this](/assets/tripods-bythom.html) thoroughly.\n- Components are: Legs, Head, Plate, Bag\n - Each component may be purchased separately.\n - Buying a head doesn't necessarily include a plate.\n\n## Presets and LUTs\n\nFor Photomator/Pixelmator\n\n- [Presetmator](https://presetmator.com/)\n- [Bodega Supply](https://bodega.supply/collection/photo-presets)\n\nOther\n\n- [FujifilmCameraProfiles](https://github.com/abpy/FujifilmCameraProfiles)\n- [Export LUT](https://johnrellis.com/lightroom/exportlut.htm) Utility\n- [How Metering Works](https://www.youtube.com/watch?v=qYGc7QPU3tI) -- A must-watch\n\n## Lenses\n\nThere are Prime lenses (fixed focal length) and Zoom lenses (can be wide, normal, and/or telephoto lenses).\n\nPrime lenses teach you a lot about photography because they make your lazy ass _move_ and _explore_ a scene: distances and angles.\n\n## Other\n\n- [What This NYT/Getty/AP Photojournalist Has Learned After More Than 25 Years in the Field](https://www.youtube.com/watch?v=Ky78k8j2-zc)\n" }, { "authorEmail": "anand.nikhil@gmail.com", "authorName": "afreeorange", "date": "2026-07-26T22:18:09Z", "id": "89789ad57e3a3147a95887f7daee276f55790483", "shortId": "89789ad5", "subject": "New incomplete sections\n", "content": "Assorted notes from me trying to teach myself Photography.\n\n## The Triangle\n\nIt's a balance between Aperture, Shutter Speed, and ISO.\n\n## Metering\n\nYour camera will try and advise you. People used to use light meters for this. It will say its a good exposure if it is \"18% Gray\" which is what light meters were historically calibrated to (the caps on Kodak film and the insides of dedicated camera bags are this gray too.)\n\n## The Histogram\n\n## On Aperture\n\nMeasured by f-stop. \"f/2\" means you take the focal length and divide it by two.\n\n\"[f/8 and Be There.](https://www.youtube.com/watch?v=DQcFQ-2dtB0).\" Like _be there_. Your camera primarily exists to take pictures of things and events.\n\n## On ISO\n\n[See this video](https://www.youtube.com/watch?v=ZWSvHBG7X0w). TLDR: This is tricky so let the camera figure it out.\n\n## Tripods\n\n- Cheap, Stable, Light —- pick two. But don't be cheap. You'll change cameras before tripods.\n- [Read this](/assets/tripods-bythom.html) thoroughly.\n- Components are: Legs, Head, Plate, Bag\n - Each component may be purchased separately.\n - Buying a head doesn't necessarily include a plate.\n\n## Presets and LUTs\n\nFor Photomator/Pixelmator\n\n- [Presetmator](https://presetmator.com/)\n- [Bodega Supply](https://bodega.supply/collection/photo-presets)\n\nOther\n\n- [FujifilmCameraProfiles](https://github.com/abpy/FujifilmCameraProfiles)\n- [Export LUT](https://johnrellis.com/lightroom/exportlut.htm) Utility\n- [How Metering Works](https://www.youtube.com/watch?v=qYGc7QPU3tI) -- A must-watch\n\n## Lenses\n\nThere are Prime lenses (fixed focal length) and Zoom lenses (can be wide, normal, and/or telephoto lenses).\n\nPrime lenses teach you a lot about photography because they make your lazy ass _move_ and _explore_ a scene: distances and angles.\n\n## Other\n\n- [What This NYT/Getty/AP Photojournalist Has Learned After More Than 25 Years in the Field](https://www.youtube.com/watch?v=Ky78k8j2-zc)\n" }, { "authorEmail": "mail@nikhil.io", "authorName": "Nikhil Anand", "date": "2026-07-04T14:07:30Z", "id": "b9ab94ea8b06b7ec3e3662f309aa5171e3701c00", "shortId": "b9ab94ea", "subject": "Initial commit\n", "content": "Assorted notes from me trying to teach myself Photography.\n\n## On ISO\n\n[See this video](https://www.youtube.com/watch?v=ZWSvHBG7X0w). TLDR: This is tricky so let the camera figure it out.\n\n## Tripods\n\n- Cheap, Stable, Light — pick two. But don't be cheap. You'll change cameras before tripods.\n- [Read this](/assets/tripods-bythom.html) thoroughly.\n- Components are: Legs, Head, Plate, Bag\n - Each component may be purchased separately.\n - Buying a head doesn't necessarily include a plate.\n" } ], "sizeInBytes": 13330, "source": "Assorted notes from me trying to teach myself Photography.\n\n## The Triangle\n\nIt's a balance between Aperture, Shutter Speed, and ISO.\n\n## Metering\n\nYour camera will try and advise you. People used to use light meters for this. It will say its a good exposure if it is \"18% Gray\" which is what light meters were historically calibrated to (the caps on Kodak film and the insides of dedicated camera bags are this gray too.)\n\n## The Histogram\n\n- Luminance value on x-axis and pixel count on y-axis.\n- Leftmost edge is Luminance of zero, Rightmost is Luminance of one. Any pixels touching these edges are lost information, they're just crushed out of existence. You can use Zebra stripes to tell you which parts of your image are/will be \"blown out\" in either direction.\n- You section it into, say, five equal portions. From L-R, you are looking at _blacks_, _shadows_, _midtones_, _highlights_, and _whites_.\n\nUsually you want a histogram that looks like a mountain or is kinda balanced out but depends on what you're trying to do, the look you're going for.\n\n## On Aperture\n\nMeasured by f-stop. \"f/2\" means you take the focal length and divide it by two.\n\n\"[f/8 and Be There.](https://www.youtube.com/watch?v=DQcFQ-2dtB0).\" Like _be there_. Your camera primarily exists to take pictures of things and events.\n\n## On ISO\n\n[See this video](https://www.youtube.com/watch?v=ZWSvHBG7X0w). TLDR: This is tricky so let the camera figure it out.\n\n## Tripods\n\n- Cheap, Stable, Light —- pick two. But don't be cheap. You'll change cameras before tripods.\n- [Read this](/assets/tripods-bythom.html) thoroughly.\n- Components are: Legs, Head, Plate, Bag\n - Each component may be purchased separately.\n - Buying a head doesn't necessarily include a plate.\n\n## Lenses\n\nThere are Prime lenses (fixed focal length) and Zoom lenses (can be wide, normal, and/or telephoto lenses).\n\nPrime lenses teach you a lot about photography because they make your lazy ass _move_ and _explore_ a scene: distances and angles.\n\n## Presets and LUTs\n\n- [Presetmator](https://presetmator.com/) -- Photomator/Pixelmator\n- [Bodega Supply](https://bodega.supply/collection/photo-presets) -- Photomator/Pixelmator\n- [FujifilmCameraProfiles](https://github.com/abpy/FujifilmCameraProfiles)\n- [Export LUT](https://johnrellis.com/lightroom/exportlut.htm) Utility\n\n### Hald CLUTs\n\n[These are great](https://github.com/cedeber/hald-clut)!. This gives you a bunch of PNGs that you can \"infer LUTs\" from. Quick Python script that will do this is at the end of this page.\n\nNow the LUT grid size with the PNGs is 144 x 144 x 144 = 2,985,984 which makes the sizes of the `.cube` files explode. That script will downsample to 32 x 32 x 32.\n\n[I've saved the generated `.cube` files here](https://public.nikhil.io/hald-clut-cubes.tgz).\n\n## Other\n\n- [What This NYT/Getty/AP Photojournalist Has Learned After More Than 25 Years in the Field](https://www.youtube.com/watch?v=Ky78k8j2-zc)\n- [How Metering Works](https://www.youtube.com/watch?v=qYGc7QPU3tI) -- A must-watch\n\n### Infer LUT from PNG Script\n\n```python\n#!/usr/bin/env python3\n\"\"\"Infer a 3D color LUT from images and export as .cube file.\n\nModes:\n hald — Extract LUT from a processed Hald CLUT image.\n pair — Approximate LUT from a before/after image pair.\n generate-hald — Generate a neutral Hald CLUT image to use as a reference.\n\nUsage:\n python infer_lut.py hald processed_hald.png -o my.cube\n python infer_lut.py pair original.png graded.png -o my.cube\n python infer_lut.py generate-hald -s 8 -o identity_hald.png\n\"\"\"\n\nimport argparse\nimport numpy as np\nfrom pathlib import Path\nfrom PIL import Image\n\n\n# ---------------------------------------------------------------------------\n# Hald CLUT helpers\n# ---------------------------------------------------------------------------\n\n\ndef hald_level_from_image(img: Image.Image) -> int:\n \"\"\"Determine the Hald level from image dimensions.\n\n A Hald CLUT of level N has dimensions (N^3) x (N^3).\n The resulting 3D LUT has N^2 entries per axis.\n Common levels: 4 → 64x64 image, 16-entry LUT\n 8 → 512x512 image, 64-entry LUT\n 12 → 1728x1728 image, 144-entry LUT\n \"\"\"\n w, h = img.size\n if w != h:\n raise ValueError(f\"Hald CLUT must be square, got {w}x{h}\")\n # w = level^3\n level = round(w ** (1 / 3))\n if level**3 != w:\n raise ValueError(\n f\"Image size {w}x{h} is not a valid Hald CLUT dimension (need N^3 x N^3)\"\n )\n return level\n\n\ndef generate_hald(level: int) -> Image.Image:\n \"\"\"Generate a neutral (identity) Hald CLUT image.\"\"\"\n lut_size = level * level # entries per axis in the 3D LUT\n dim = level**3 # pixel width/height of the Hald image\n pixels = np.zeros((dim * dim, 3), dtype=np.uint8)\n\n for i in range(dim * dim):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n pixels[i] = [\n round(r / (lut_size - 1) * 255),\n round(g / (lut_size - 1) * 255),\n round(b / (lut_size - 1) * 255),\n ]\n\n return Image.fromarray(pixels.reshape(dim, dim, 3))\n\n\ndef lut_from_hald(img: Image.Image) -> tuple[int, np.ndarray]:\n \"\"\"Extract a 3D LUT from a processed Hald CLUT image.\n\n Returns (lut_size, lut) where lut has shape (lut_size, lut_size, lut_size, 3)\n with float values in [0, 1].\n \"\"\"\n level = hald_level_from_image(img)\n lut_size = level * level\n dim = level**3\n\n pixels = np.array(img.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3) / 255.0\n expected = dim * dim\n if len(pixels) != expected:\n raise ValueError(f\"Expected {expected} pixels, got {len(pixels)}\")\n\n lut = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n for i in range(expected):\n r = i % lut_size\n g = (i // lut_size) % lut_size\n b = i // (lut_size * lut_size)\n lut[b, g, r] = pixels[i]\n\n return lut_size, lut\n\n\ndef resample_lut(lut: np.ndarray, src_size: int, dst_size: int) -> np.ndarray:\n \"\"\"Resample a 3D LUT to a different grid size via trilinear interpolation.\"\"\"\n from scipy.interpolate import RegularGridInterpolator\n\n axis = np.linspace(0, 1, src_size)\n channels = []\n for ch in range(3):\n interp = RegularGridInterpolator(\n (axis, axis, axis), lut[:, :, :, ch], method=\"linear\"\n )\n dst_axis = np.linspace(0, 1, dst_size)\n grid = np.meshgrid(dst_axis, dst_axis, dst_axis, indexing=\"ij\")\n pts = np.stack(grid, axis=-1).reshape(-1, 3)\n channels.append(interp(pts).reshape(dst_size, dst_size, dst_size))\n\n return np.clip(np.stack(channels, axis=-1), 0, 1)\n\n\n# ---------------------------------------------------------------------------\n# Before/after pair → LUT approximation\n# ---------------------------------------------------------------------------\n\n\ndef lut_from_pair(\n original: Image.Image,\n graded: Image.Image,\n lut_size: int = 33,\n) -> tuple[int, np.ndarray]:\n \"\"\"Approximate a 3D LUT by comparing original ↔ graded pixel pairs.\n\n Bins every pixel by its original RGB value into a 3D grid, averages the\n corresponding graded values per bin. Fills empty bins via nearest-neighbor\n interpolation.\n \"\"\"\n if original.size != graded.size:\n # resize graded to match original\n graded = graded.resize(original.size, Image.LANCZOS)\n\n orig_px = np.array(original.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n grad_px = np.array(graded.convert(\"RGB\"), dtype=np.float64).reshape(-1, 3)\n\n # Quantize original pixels into LUT bins\n bin_indices = np.clip(\n (orig_px / 255.0 * (lut_size - 1) + 0.5).astype(int), 0, lut_size - 1\n )\n\n # Accumulate\n lut_sum = np.zeros((lut_size, lut_size, lut_size, 3), dtype=np.float64)\n lut_count = np.zeros((lut_size, lut_size, lut_size), dtype=np.float64)\n\n for idx in range(len(orig_px)):\n r, g, b = bin_indices[idx]\n lut_sum[b, g, r] += grad_px[idx]\n lut_count[b, g, r] += 1\n\n # Average filled bins\n mask = lut_count > 0\n lut = np.zeros_like(lut_sum)\n lut[mask] = lut_sum[mask] / lut_count[mask, np.newaxis] / 255.0\n\n # Fill empty bins via nearest-neighbor from filled bins\n empty = ~mask\n n_empty = empty.sum()\n if n_empty > 0:\n from scipy.ndimage import distance_transform_edt\n\n # distance_transform_edt returns distances and indices of nearest filled cell\n _, nearest_idx = distance_transform_edt(\n empty, return_distances=True, return_indices=True\n )\n for b_i in range(lut_size):\n for g_i in range(lut_size):\n for r_i in range(lut_size):\n if empty[b_i, g_i, r_i]:\n nb, ng, nr = nearest_idx[:, b_i, g_i, r_i]\n lut[b_i, g_i, r_i] = lut[nb, ng, nr]\n\n return lut_size, lut\n\n\n# ---------------------------------------------------------------------------\n# .cube export\n# ---------------------------------------------------------------------------\n\n\ndef write_cube(path: str, lut_size: int, lut: np.ndarray, title: str = \"Inferred LUT\"):\n \"\"\"Write a 3D LUT in Adobe .cube format.\n\n lut shape: (lut_size, lut_size, lut_size, 3) with values in [0, 1].\n Iteration order: R fastest, then G, then B (standard .cube convention).\n \"\"\"\n with open(path, \"w\") as f:\n f.write(f'TITLE \"{title}\"\\n')\n f.write(f\"LUT_3D_SIZE {lut_size}\\n\")\n f.write(f\"DOMAIN_MIN 0.0 0.0 0.0\\n\")\n f.write(f\"DOMAIN_MAX 1.0 1.0 1.0\\n\\n\")\n\n for b in range(lut_size):\n for g in range(lut_size):\n for r in range(lut_size):\n rv, gv, bv = lut[b, g, r]\n f.write(f\"{rv:.6f} {gv:.6f} {bv:.6f}\\n\")\n\n\n# ---------------------------------------------------------------------------\n# CLI\n# ---------------------------------------------------------------------------\n\n\ndef main():\n parser = argparse.ArgumentParser(\n description=\"Infer a 3D color LUT from images.\",\n formatter_class=argparse.RawDescriptionHelpFormatter,\n epilog=__doc__,\n )\n sub = parser.add_subparsers(dest=\"command\", required=True)\n\n # -- hald --\n p_hald = sub.add_parser(\"hald\", help=\"Extract LUT from a processed Hald CLUT image\")\n p_hald.add_argument(\"image\", help=\"Processed Hald CLUT image (PNG, TIFF, etc.)\")\n p_hald.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_hald.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=35,\n help=\"Output LUT grid size per axis (default 35)\",\n )\n\n # -- pair --\n p_pair = sub.add_parser(\"pair\", help=\"Approximate LUT from original + graded pair\")\n p_pair.add_argument(\"original\", help=\"Original (ungraded) image\")\n p_pair.add_argument(\"graded\", help=\"Graded image\")\n p_pair.add_argument(\n \"-o\", \"--output\", default=\"output.cube\", help=\"Output .cube file\"\n )\n p_pair.add_argument(\n \"-s\",\n \"--size\",\n type=int,\n default=33,\n help=\"LUT grid size per axis (default 33, industry standard)\",\n )\n\n # -- generate-hald --\n p_gen = sub.add_parser(\"generate-hald\", help=\"Generate a neutral Hald CLUT image\")\n p_gen.add_argument(\n \"-s\",\n \"--level\",\n type=int,\n default=8,\n help=\"Hald level (default 8 → 512x512 image, 64-entry LUT)\",\n )\n p_gen.add_argument(\n \"-o\", \"--output\", default=\"identity_hald.png\", help=\"Output image path\"\n )\n\n args = parser.parse_args()\n\n if args.command == \"generate-hald\":\n print(f\"Generating identity Hald CLUT (level {args.level})...\")\n img = generate_hald(args.level)\n img.save(args.output)\n lut_size = args.level**2\n print(f\"Saved {img.size[0]}x{img.size[1]} image → {args.output}\")\n print(\n f\"Resulting LUT will have {lut_size} entries per axis ({lut_size}^3 = {lut_size**3} total)\"\n )\n\n elif args.command == \"hald\":\n print(f\"Reading Hald CLUT: {args.image}\")\n img = Image.open(args.image)\n lut_size, lut = lut_from_hald(img)\n if args.size != lut_size:\n print(f\"Resampling {lut_size}³ → {args.size}³...\")\n lut = resample_lut(lut, lut_size, args.size)\n lut_size = args.size\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Hald-inferred from {Path(args.image).name}\",\n )\n print(f\"Extracted {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n elif args.command == \"pair\":\n print(f\"Original: {args.original}\")\n print(f\"Graded: {args.graded}\")\n orig = Image.open(args.original)\n grad = Image.open(args.graded)\n lut_size, lut = lut_from_pair(orig, grad, args.size)\n write_cube(\n args.output,\n lut_size,\n lut,\n title=f\"Pair-inferred from {Path(args.original).name} → {Path(args.graded).name}\",\n )\n print(f\"Approximated {lut_size}x{lut_size}x{lut_size} LUT → {args.output}\")\n\n print(\"Done.\")\n\n\nif __name__ == \"__main__\":\n main()\n```\n\n### Random\n\n- \"Dragging your shutter\" means using a low shutter speed for things like movement.\n", "title": "Photography Notes", "untracked": false, "uri": "/Photography_Notes", "relativePath": "Photography Notes.md" }