You can detect color cast in product photos objectively by converting each studio frame into float32 CIE $L^*a^*b^*$ color space, isolating the high-lightness outer sweep border, and measuring how far the border chroma vector $C^*_{ab} = \sqrt{\mu_a^2 + \mu_b^2}$ drifts from the neutral origin. Pairing that border measurement with the global $a^*/b^*$ chromaticity spread lets a batch script flag warm tungsten spill, cool window daylight, or green LED spikes without false alarms on saturated merchandise.

AI helped draft this tutorial, while every Python snippet and console table below comes from running the script locally on a five-frame test batch. This Hashnode blog is run by Virse, whose reference photo color transfer tool appears once in the correction section below.

Why should you detect color cast in product photos using CIE Lab instead of RGB histograms?

You should detect color cast in product photos in CIE $L^*a^*b^*$ rather than sRGB because sRGB couples brightness and color across all three channels, whereas CIE $L^*a^*b^*$ separates lightness ($L^*$) from two opponent chromaticity axes: $a^*$ (green to red) and $b^*$ (blue to yellow). When a studio strobe dims by a third of a stop between frames, all three R, G, and B channel means drop together even if the white balance stays neutral. In CIE $L^*a^*b^*$, that exposure drop lowers $L^*$ while leaving $a^*$ and $b^*$ anchored near zero.

Under the CIELAB color space specification standardized by the International Commission on Illumination, an achromatic gray or white surface under a D65 standard illuminant sits at $a^* = 0.0$ and $b^* = 0.0$, regardless of whether its lightness $L^*$ is $96.0$ (bright white seamless paper) or $50.0$ (a mid-gray reference card). Any systematic shift away from $(a^*=0, b^*=0)$ on a known neutral surface measures the direction and magnitude of the color cast directly:

• Positive $b^*$ ($+2.2$ or higher): Yellow or warm amber drift, typical when a 3200K modeling lamp stays on or warm floor bounce contaminates a 5600K flash setup.
• Negative $b^*$ ($-2.2$ or lower): Cool blue drift, common when north-facing window daylight leaks into an afternoon tabletop shoot as clouds roll in.
• Negative $a^*$ ($-2.0$ or lower): Green spike, frequently caused by commercial warehouse LED tubes or aged fluorescent ballasts with a low color rendering index.
• Positive $a^*$ ($+2.0$ or higher): Magenta tint, often introduced by aggressive tint compensation in raw converters or tinted acrylic diffusers.

If you use OpenCV for the conversion, watch out for one silent pitfall documented in the OpenCV color conversions reference. Passing an 8-bit unsigned integer array (uint8) to cv2.cvtColor(img, cv2.COLOR_BGR2Lab) scales $L^*$ to $[0, 255]$ and adds $+128$ to both $a^*$ and $b^*$ so values fit into unsigned bytes. Forgetting to subtract $128$ makes every neutral pixel look like it has a huge red-yellow cast. Converting the image to float32 in $[0.0, 1.0]$ before calling cv2.cvtColor bypasses byte quantization and returns true floating-point CIE $L^* \in [0, 100]$ and $a^*, b^* \in [-127, 127]$, matching skimage.color.rgb2lab from scikit-image.

How do you sample the neutral studio border without catching product pixels?

Sampling the outer 8 percent perimeter of the frame and filtering for pixels with lightness $L^* \ge 75.0$ isolates the studio sweep paper while ignoring the merchandise in the center. Whole-image chromaticity averages fail on catalog photography because the product itself dominates the pixel count.

Suppose you shoot a burnt-orange leather messenger bag centered on a clean white sweep. Even under calibrated strobes, the orange leather pixels push the whole-frame mean $a^*$ above $+15$ and mean $b^*$ above $+25$. A global gray-world average will flag the clean orange bag photo as having a warm cast while passing a blue shirt shot under warm tungsten bulbs because the blue fabric and yellow light cancel out.

AI-generated illustration: isolating the outer seamless sweep border and a neutral reference card away from the central product.

In ecommerce and lookbook tabletop shoots, the outer margin of the frame almost always shows the studio sweep, cyclorama wall, or tabletop surface. Combining a geometric perimeter mask with a lightness gate solves two problems at once:

1. The 8 percent perimeter strip (border_frac = 0.08) grabs the top, bottom, left, and right edges where the product rarely extends, unless it is an edge-cropped detail shot.
2. The lightness gate ($L^* \ge 75.0$) drops deep contact shadows, dark props, or mannequin stands that cross the bottom edge of the frame, keeping only lit background pixels.
3. The fallback check verifies that at least 50 pixels survive the $L^* \ge 75.0$ filter; if the background is a mid-gray stone slab rather than white paper, the function falls back to the full perimeter strip so the script never divides by zero.

Alongside the border mean $(\mu_a, \mu_b)$, it helps to record the global chromaticity spread $\sigma_{ab} = \sqrt{\sigma_a^2 + \sigma_b^2}$ across the full frame. When a monochrome ceramic mug sits on a white sweep, $\sigma_{ab}$ stays tiny (around $2.0$ to $3.0$). When a multi-colored floral garment or an orange leather bag sits on that same sweep, $\sigma_{ab}$ jumps above $20.0$ while the border chroma $C^*_{\text{bdr}}$ stays below $1.0$. Comparing $C^*_{\text{bdr}}$ against $\sigma_{ab}$ tells you immediately whether chroma energy lives in the product or in the ambient lighting.

What does a runnable Python script for batch color cast detection look like?

The script below uses numpy and opencv-python (cv2) to convert each image into unshifted float32 CIE $L^*a^*b^*$, compute the border chroma $C^*_{\text{bdr}}$, measure the global chromaticity spread, and calculate the chromaticity drift $\Delta C_{ab}$ relative to a designated reference frame (sku_01_ref_mug.png). To make the output 100 percent reproducible without external downloads, make_synthetic_catalog_batch() builds a five-frame $600 \times 600$ studio batch with controlled sensor noise and realistic lighting shifts.

#!/usr/bin/env python3
"""Detect color cast in product photos using CIE Lab border & global chroma statistics."""
import numpy as np
import cv2


def srgb_to_cie_lab(bgr_uint8: np.ndarray) -> np.ndarray:
    """Convert 8-bit BGR image to float32 CIE L*a*b* (L in [0,100], a,b in [-128,127])."""
    bgr_f32 = bgr_uint8.astype(np.float32) / 255.0
    return cv2.cvtColor(bgr_f32, cv2.COLOR_BGR2Lab)


def analyze_product_frame(bgr_uint8: np.ndarray, border_frac: float = 0.08) -> dict:
    """Measure neutral-border chroma drift and global a*/b* spread in CIE Lab."""
    lab = srgb_to_cie_lab(bgr_uint8)
    h, w, _ = lab.shape
    bh = max(4, int(round(h * border_frac)))
    bw = max(4, int(round(w * border_frac)))

    border_mask = np.zeros((h, w), dtype=bool)
    border_mask[:bh, :] = True
    border_mask[-bh:, :] = True
    border_mask[:, :bw] = True
    border_mask[:, -bw:] = True

    L, a, b = lab[:, :, 0], lab[:, :, 1], lab[:, :, 2]
    # Keep high-lightness border pixels (studio sweep paper, L* >= 75)
    sweep_mask = border_mask & (L >= 75.0)
    if np.count_nonzero(sweep_mask) < 50:
        sweep_mask = border_mask

    mu_L = float(np.mean(L[sweep_mask]))
    mu_a = float(np.mean(a[sweep_mask]))
    mu_b = float(np.mean(b[sweep_mask]))
    border_chroma = float(np.hypot(mu_a, mu_b))

    # Global chromaticity spread (2D standard deviation in a*/b* plane)
    sigma_a = float(np.std(a))
    sigma_b = float(np.std(b))
    spread = float(np.hypot(sigma_a, sigma_b))
    # Equivalent chroma factor D_c = border_chroma - spread
    d_factor = border_chroma - spread

    if border_chroma < 2.2:
        verdict = "PASS (neutral)"
    elif mu_b >= 2.2 and abs(mu_a) < mu_b:
        verdict = "WARN (warm/yellow cast)"
    elif mu_b <= -2.2 and abs(mu_a) < abs(mu_b):
        verdict = "WARN (cool/blue cast)"
    elif mu_a <= -2.0:
        verdict = "WARN (green fluorescent cast)"
    else:
        verdict = "WARN (magenta/mixed tint)"

    return {
        "mu_L": round(mu_L, 2),
        "mu_a": round(mu_a, 2),
        "mu_b": round(mu_b, 2),
        "border_C": round(border_chroma, 2),
        "spread_sigma": round(spread, 2),
        "D_c": round(d_factor, 2),
        "verdict": verdict,
    }


def make_synthetic_catalog_batch(seed: int = 42) -> dict:
    """Create a reproducible 5-frame studio catalog batch (600x600 BGR uint8)."""
    rng = np.random.default_rng(seed)
    h, w = 600, 600
    yy, xx = np.ogrid[:h, :w]
    center_mask = ((yy - 300) ** 2 + (xx - 300) ** 2) <= 165 ** 2

    def build_frame(bg_bgr, obj_bgr, cast_bgr=(0, 0, 0)):
        img = np.empty((h, w, 3), dtype=np.float32)
        img[:] = bg_bgr
        img[center_mask] = obj_bgr
        noise = rng.normal(0.0, 1.8, size=(h, w, 3))
        img = np.clip(img + noise + np.array(cast_bgr, dtype=np.float32), 0, 255)
        return img.astype(np.uint8)

    return {
        "sku_01_ref_mug.png": build_frame((242, 242, 242), (175, 182, 188), (0, 0, 0)),
        "sku_02_tungsten_mug.png": build_frame((242, 242, 242), (175, 182, 188), (-14, 4, 16)),
        "sku_03_window_Blue.png": build_frame((242, 242, 242), (175, 182, 188), (15, 2, -12)),
        "sku_04_led_green.png": build_frame((242, 242, 242), (175, 182, 188), (-4, 11, -8)),
        "sku_05_orange_bag_clean.png": build_frame((242, 242, 242), (38, 108, 218), (0, 0, 1)),
    }


if __name__ == "__main__":
    batch = make_synthetic_catalog_batch()
    ref_stats = analyze_product_frame(batch["sku_01_ref_mug.png"])
    print(f"{'Frame':<28} {'L*':>6} {'a*':>6} {'b*':>6} {'C*_bdr':>7} {'Spread':>7} {'Delta_C':>8}  Verdict")
    print("-" * 92)
    for name, img in batch.items():
        st = analyze_product_frame(img)
        drift = np.hypot(st["mu_a"] - ref_stats["mu_a"], st["mu_b"] - ref_stats["mu_b"])
        print(
            f"{name:<28} {st['mu_L']:>6.2f} {st['mu_a']:>6.2f} {st['mu_b']:>6.2f} "
            f"{st['border_C']:>7.2f} {st['spread_sigma']:>7.2f} {drift:>8.2f}  {st['verdict']}"
        )

Running python detect_color_cast.py prints the following console output:

Frame                            L*     a*     b*  C*_bdr  Spread  Delta_C  Verdict
--------------------------------------------------------------------------------------------
sku_01_ref_mug.png            95.17   0.01   0.00    0.01    2.47     0.00  PASS (neutral)
sku_02_tungsten_mug.png       96.88   0.36   9.81    9.82    2.80     9.82  WARN (warm/yellow cast)
sku_03_window_Blue.png        95.17  -2.34  -7.20    7.58    2.01     7.57  WARN (cool/blue cast)
sku_04_led_green.png          97.29  -8.90   5.07   10.24    2.51    10.25  WARN (green fluorescent cast)
sku_05_orange_bag_clean.png   95.24   0.35   0.12    0.37   28.99     0.36  PASS (neutral)

Look closely at the fifth row, sku_05_orange_bag_clean.png. Its global chromaticity spread (Spread) jumps to 28.99 because the central product circle is a saturated orange leather color (BGR = (38, 108, 218)). Yet because the perimeter mask samples only the outer 8 percent border where $L^* \ge 75.0$, the border chroma C*_bdr reads 0.37 and its drift from the reference mug (Delta_C) is 0.36. The frame passes automatically without human intervention, whereas the three frames with genuine lighting shifts (sku_02, sku_03, and sku_04) register border chroma values between 7.58 and 10.24 and get routed to correction.

How do chroma thresholds and chromaticity spread separate lighting drift from saturated merchandise?

A border chroma threshold of $C^*_{\text{bdr}} = 2.2$ separates imperceptible studio variance from visible background tint on standard sRGB monitors, where one just-noticeable difference in CIE $\Delta E^*_{ab}$ sits near $1.0$ to $2.0$ units. When you run this check across a multi-day catalog shoot, you can classify every image into four operational buckets based on its border vector $(\mu_a, \mu_b)$, border chroma $C^*_{\text{bdr}}$, and global spread $\sigma_{ab}$:

AI-generated illustration: side-by-side contact proofs revealing warm paper tint drift across a multi-day studio shoot.

Why track Delta_C against a designated hero frame (sku_01_ref_mug.png) in addition to absolute distance from $(0, 0)$? Many apparel and home-goods brands intentionally shoot on warm alabaster paper ($\mu_a \approx +0.4, \mu_b \approx +3.1$) or cool architectural concrete ($\mu_a \approx -0.3, \mu_b \approx -1.8$) rather than bright white paper. Measuring the Euclidean drift $\Delta C_{ab} = \sqrt{(\mu_a - \mu_{a,\text{ref}})^2 + (\mu_b - \mu_{b,\text{ref}})^2}$ relative to the signed-off hero frame tests whether Frame 47 drifted away from Frame 1, regardless of backdrop shade.

How do you correct flagged frames with reference photo color statistics?

Once your script flags a subset of frames whose border chroma drifted away from the hero shot, you have two ways to align them: run a channel-wise CIE $L^*a^*b^*$ statistics transfer in Python following Erik Reinhard's 2001 color transfer equation, or bring the drifted photo and the approved reference frame into a visual canvas tool for interactive strength control.

In Python, Reinhard-style linear transfer shifts and scales each channel $c \in \{L^*, a^*, b^*\}$ of the source image $I_{\text{src}}$ toward the mean $\mu_{\text{ref}}$ and standard deviation $\sigma_{\text{ref}}$ of the reference image, blended by a transfer strength factor $\alpha \in [0.0, 1.0]$:

def match_lab_statistics(
    src_bgr: np.ndarray, ref_bgr: np.ndarray, strength: float = 0.65
) -> np.ndarray:
    """Align source photo CIE Lab statistics to a reference photo with blend strength."""
    src_lab = srgb_to_cie_lab(src_bgr)
    ref_lab = srgb_to_cie_lab(ref_bgr)
    out_lab = np.empty_like(src_lab)

    for ch in range(3):
        s_mean, s_std = np.mean(src_lab[:, :, ch]), max(np.std(src_lab[:, :, ch]), 1e-5)
        r_mean, r_std = np.mean(ref_lab[:, :, ch]), max(np.std(ref_lab[:, :, ch]), 1e-5)
        transferred = (src_lab[:, :, ch] - s_mean) * (r_std / s_std) + r_mean
        out_lab[:, :, ch] = (1.0 - strength) * src_lab[:, :, ch] + strength * transferred

    out_lab[:, :, 0] = np.clip(out_lab[:, :, 0], 0.0, 100.0)
    out_lab[:, :, 1:] = np.clip(out_lab[:, :, 1:], -127.0, 127.0)
    out_bgr = cv2.cvtColor(out_lab, cv2.COLOR_Lab2BGR)
    return np.clip(np.round(out_bgr * 255.0), 0, 255).astype(np.uint8)

Running this linear equation directly on whole images works well when the source and reference frames contain the exact same object at the same crop, such as sku_02_tungsten_mug.png matched to sku_01_ref_mug.png. When a retoucher or art director needs to inspect how different blend strengths affect skin tones, ceramic glazes, or leather grain side by side before committing, they can use Lab statistics color grade transfer on Virse.

Public tool page screenshot from virse.ai/tools/color-grade-transfer showing how Color Grade Transfer matches color statistics across a source photo and tone reference without redrawing edges or textures.

The web tool takes one photo to grade and one tone reference image, and computes the palette transfer from color statistics rather than running a generative diffusion pass. Because nothing is redrawn, every edge, weave, logo, and surface texture of the original photograph stays locked down to the pixel, and running the same pair twice produces the exact same output. You can choose among three presets (Match the reference, House look, and Light tint) and three transfer strengths (Light, Standard, and Full). Clicking Transfer the grade loads your source photo and reference image into a new canvas with the tool parameters pre-filled; the transfer runs only after you press Start inside the canvas, placing the graded image right beside the original so you can compare them or swap the reference.

Two practical boundaries apply whether you run CIE $L^*a^*b^*$ statistics transfer in Python or on the Virse canvas:

1. Structure preservation is not selective masking: Matching color statistics across the whole frame keeps pixel geometry untouched, but it shifts the color of the product along with the background. Use Light or Standard strength when the product hue is color-critical, or verify product regions after neutralizing the cast.
2. Still-photo scope: Virse's Color Grade Transfer operates on still images and outputs the graded photo onto the canvas; it does not process video timelines and does not export .cube or 3D LUT files.

Which studio lighting edge cases require manual review even after automated screening?

Three studio scenarios still benefit from human inspection before batch correction:

• Split lighting with mixed color temperatures: When a 5600K strobe lights the left side and 3000K room bounce lights the right, opposite borders can cancel each other out in a single perimeter average. Split the perimeter mask into four quadrants (top, bottom, left, right) and flag any frame where quadrant-to-quadrant $\Delta b^*$ exceeds $3.0$.
• Full-bleed lifestyle frames without a neutral border: When wooden tables or props cover all four edges, place a physical 18 percent gray card in the corner of the first frame of the camera lockoff and measure its $(a^*, b^*)$ patch coordinates directly.
• Clipped studio highlights ($L^* > 98.5$): Overexposed background strobes blow paper out to pure [255, 255, 255], collapsing $a^*$ and $b^*$ to zero. Adding an upper ceiling ((L >= 75.0) & (L <= 98.5)) keeps the measurement inside unclipped paper highlights.

AI helped draft this post, and I ran and checked every code sample and number in it myself. Virse, whose line art tool appears near the end as one alternative, has a business relationship with this publication.

What does Canny edge detection actually respond to?

Canny does not know what a bottle is. It smooths the image with a Gaussian blur, computes the brightness gradient at every pixel, thins the result to one-pixel ridges (non-maximum suppression), and then applies two thresholds. Pixels whose gradient magnitude is above the high threshold become strong edges. Pixels between the two thresholds are kept only if they connect to a strong edge. Everything else is dropped.

So the only question Canny asks is "how fast does brightness change here?" On a matte object under soft light, fast brightness changes mostly happen at real boundaries, so the output looks like a drawing of the object. On a glossy object, the fastest brightness changes in the frame are often the edges of highlights and reflections, which are properties of the lighting setup and not of the object.

A test image where we know the ground truth

Real product photos make it hard to argue about which lines are "correct", so I built a synthetic image where every feature is known in advance:

• a bottle silhouette on a light backdrop, with cylinder shading that gets darker toward both sides;

• a bright vertical stripe on the left of the body, standing in for a specular highlight on glossy plastic;

• a faint 1 px seam on the right side, 12 gray levels darker than its surroundings, standing in for a mold parting line;

• a cast shadow on the surface under the bottle.

Only two of those are part of the object: the silhouette and the seam. The highlight and the shadow come from the lights.

import cv2
import numpy as np

H, W = 600, 400
img = np.full((H, W), 225, np.float32)          # light studio backdrop

# soft cast shadow on the surface under the bottle
shadow = np.zeros_like(img)
cv2.ellipse(shadow, (215, 548), (120, 22), 0, 0, 360, 1.0, -1)
shadow = cv2.GaussianBlur(shadow, (0, 0), 2)
img -= shadow * 70

# bottle silhouette: body, shoulder, neck
mask = np.zeros((H, W), np.uint8)
cv2.rectangle(mask, (120, 200), (280, 540), 255, -1)
cv2.ellipse(mask, (200, 200), (80, 60), 0, 180, 360, 255, -1)
cv2.rectangle(mask, (170, 90), (230, 150), 255, -1)

# cylinder shading across the body: darker toward both sides
x = np.arange(W, dtype=np.float32)
shade = 70 + 60 * np.cos((x - 200) / 80 * (np.pi / 2)).clip(0, 1)
body = np.tile(shade, (H, 1))

# glossy highlight: a sharp bright stripe left of center
body[:, 158:170] = 250

# parting line: a faint 1 px seam down the right side of the mold
body[95:540, 240] -= 12

img = np.where(mask > 0, body, img).clip(0, 255).astype(np.uint8)
cv2.imwrite("synthetic-glossy-bottle.png", img)

Sweeping the thresholds

Next, run Canny at three threshold pairs, from permissive to strict, and count the edge pixels inside three regions: the highlight stripe, the seam, and the shadow below the bottle.

regions = {
    "highlight stripe": (slice(220, 520), slice(153, 176)),
    "parting line": (slice(220, 520), slice(236, 245)),
    "cast shadow": (slice(546, 580), slice(80, 350)),
}
for lo, hi in [(20, 60), (60, 150), (150, 300)]:
    edges = cv2.Canny(img, lo, hi)
    cv2.imwrite(f"canny-{lo}-{hi}.png", edges)
    counts = {k: int((edges[r] > 0).sum()) for k, r in regions.items()}
    print(f"Canny({lo}, {hi})", counts)

With OpenCV 4.13 and NumPy 2.4 this prints:

Canny(20, 60) {'highlight stripe': 600, 'parting line': 300, 'cast shadow': 265}
Canny(60, 150) {'highlight stripe': 600, 'parting line': 0, 'cast shadow': 265}
Canny(150, 300) {'highlight stripe': 600, 'parting line': 0, 'cast shadow': 0}

Read that table row by row:

• Permissive (20, 60). The seam is found, 300 pixels, one per row of the region. So are both edges of the highlight (600 pixels, two lines of 300) and the rim of the shadow. You get everything, real or not.

• Middle (60, 150). The seam is gone. The highlight and the shadow are both still there.

• Strict (150, 300). The shadow finally drops out, and so does part of the bottle's real bottom edge where it meets the shadow (105 edge pixels in that strip, down from 172 at the permissive setting). The highlight is still drawn as two full-length lines.

There is no threshold pair in this sweep that keeps the seam and drops the highlight, and there cannot be. Canny ranks edges by gradient strength only, and the highlight is a much stronger gradient than the seam. Any threshold that removes the highlight has already removed the seam. Tuning just decides which wrong answer you get.

The two other usual fixes: automatic thresholds and more blur

Two more suggestions come up whenever someone complains about Canny on product shots. Both are worth testing on the same image, because both sound like they should help.

The first is to stop picking thresholds by hand and derive them from the image, commonly from the median brightness with a spread of about 33 percent either side:

def auto_canny(image, sigma=0.33):
    v = float(np.median(image))
    lo = int(max(0, (1.0 - sigma) * v))
    hi = int(min(255, (1.0 + sigma) * v))
    return cv2.Canny(image, lo, hi), (lo, hi)

On the test image the median is the bright backdrop, so this lands on Canny(150, 255):

auto_canny -> Canny(150, 255) {'highlight stripe': 600, 'parting line': 0, 'cast shadow': 0}

That is the strict row again. The shadow is gone, the seam is gone, and the highlight is still two full lines. Studio product photos nearly always have a light backdrop, so median-based thresholds will usually land in this strict range.

The second suggestion is to blur harder before detection, on the theory that the highlight is "noise":

for k in (5, 9):
    edges = cv2.Canny(cv2.GaussianBlur(img, (k, k), 0), 20, 60)

blur 5x5 + Canny(20, 60) {'highlight stripe': 600, 'parting line': 0}
blur 9x9 + Canny(20, 60) {'highlight stripe': 600, 'parting line': 0}

Blur works against you here. The highlight is 12 pixels wide and 120 or more gray levels brighter than the body around it, so a 9x9 kernel barely weakens it. The seam is one pixel wide and 12 levels deep, so even a 5x5 kernel spreads it out until it falls below the permissive threshold that found it before. A highlight is not noise. It is a large, strong, smooth feature, which is exactly the kind of feature blurring keeps.

Why this matters more for product images than for art

For many ControlNet uses this is fine. If you are restyling a photo and only want its composition to carry through, a few lighting lines in the control image do little harm.

Product work is different in two ways.

First, the faint lines are often the important ones. A mold parting line, a panel gap, the edge of a button or a label recess: these are real boundaries on the manufactured part, and they are usually low contrast because they are small and the same material sits on both sides. Protolabs' injection molding guidance explains that designers try to place parting lines along sharp edges precisely so the seam is camouflaged by the part's geometry. A seam that is designed to be hard to see is exactly the kind of edge a gradient threshold drops first.

Second, the strong false lines do damage downstream. If the line art feeds a re-render where the material changes from glossy white plastic to matte black, a highlight that was traced as a structural line stays in the control image. The new render then has a crease or panel edge where the old reflection used to be.

Object-read tracing as the alternative

The fix is to change the question the line source asks. Instead of "where does brightness change fast?", ask "what is the object, and where are its boundaries?" A reflection is never part of the object's boundary, so it never becomes a line, however bright it is. A seam is part of the object, so it can be kept even when its contrast is low.

That is how Virse's AI Line Art Generator works. You upload a product photo, choose one of three line styles (Detailed line art, Clean line art or Bold outline), and can add extraction notes such as "keep the side seam, drop reflections, omit the logo". The output is black lines on a white background. Notes like that only make sense for a tool that has already separated the object from its lighting; you cannot tell Canny to ignore a reflection, because to Canny the reflection and the seam are the same kind of thing with different magnitudes.

The trade-offs are real. An object-read tool needs a photo of an identifiable object, it is slower than a Canny call, and it will not invent a seam that is not visible in the source photo. Canny runs on anything in milliseconds.

A quick checklist before you trust a line source

Before you feed line art from a product photo into anything that matters, check these:

1. Find the brightest spot on the object. If there is a line running along its edge, it came from the lighting.

2. Look under the object. A closed curve on the floor is the shadow, not the product.

3. Find the seams you know exist. Check the product itself or its CAD file. If a known parting line is missing, lowering the threshold will bring it back along with more noise; it will not bring it back alone.

4. Decide what the lines are for. Composition guide for a loose restyle: Canny is fine and fast. Structure for a material swap, a spec sheet or a tech pack: use a source that knows which edges belong to the object.

5. Keep the test. The synthetic image above takes a second to generate. Run any new preprocessor or model against it, and you will know how it treats highlights and faint seams before it meets a real product.

Full script

The first two snippets above run as a single file, canny_demo.py, with only opencv-python and numpy installed. The automatic-threshold and blur tests read the synthetic-glossy-bottle.png it writes, so run them after it, with the same regions dictionary. Change the stripe brightness (250) or the seam depth (12) and rerun it to see how much contrast a seam needs before Canny keeps it at your usual thresholds. On most studio product shots, the answer will be more contrast than a well-designed seam will ever have.