• Image rendering bit depth

    ,

    The terms 8-bit, 16-bit, 16-bit float, and 32-bit refer to different data formats used to store and represent image information, as bits per pixel.

    https://en.wikipedia.org/wiki/Color_depth

    In color technology, color depth also known as bit depth, is either the number of bits used to indicate the color of a single pixel, OR the number of bits used for each color component of a single pixel.

    When referring to a pixel, the concept can be defined as bits per pixel (bpp).

    When referring to a color component, the concept can be defined as bits per component, bits per channel, bits per color (all three abbreviated bpc), and also bits per pixel component, bits per color channel or bits per sample (bps). Modern standards tend to use bits per component, but historical lower-depth systems used bits per pixel more often.

    Color depth is only one aspect of color representation, expressing the precision with which the amount of each primary can be expressed; the other aspect is how broad a range of colors can be expressed (the gamut). The definition of both color precision and gamut is accomplished with a color encoding specification which assigns a digital code value to a location in a color space.

     

    (more…)
  • Ross Pettit on The Agile Manager – How tech firms went for prioritizing cash flow instead of talent (and artists)

    , ,

    For years, tech firms were fighting a war for talent. Now they are waging war on talent.

    This shift has led to a weakening of the social contract between employees and employers, with culture and employee values being sidelined in favor of financial discipline and free cash flow.

    The operating environment has changed from a high tolerance for failure (where cheap capital and willing spenders accepted slipped dates and feature lag) to a very low – if not zero – tolerance for failure (fiscal discipline is in vogue again).

    While preventing and containing mistakes staves off shocks to the income statement, it doesn’t fundamentally reduce costs. Years of payroll bloat – aggressive hiring, aggressive comp packages to attract and retain people – make labor the biggest cost in tech.

    Of course, companies can reduce their labor force through natural attrition. Other labor policy changes – return to office mandates, contraction of fringe benefits, reduction of job promotions, suspension of bonuses and comp freezes – encourage more people to exit voluntarily. It’s cheaper to let somebody self-select out than it is to lay them off.

    Employees recruited in more recent years from outside the ranks of tech were given the expectation that we’ll teach you what you need to know, we want you to join because we value what you bring to the table. That is no longer applicable. Runway for individual growth is very short in zero-tolerance-for-failure operating conditions. Job preservation, at least in the short term for this cohort, comes from completing corporate training and acquiring professional certifications. Training through community or experience is not in the cards.

    The ability to perform competently in multiple roles, the extra-curriculars, the self-directed enrichment, the ex-company leadership – all these things make no matter. The calculus is what you got paid versus how you performed on objective criteria relative to your cohort. Nothing more.

    Here is where the change in the social contract is perhaps the most blatant. In the “destination employer” years, the employee invested in the community and its values, and the employer rewarded the loyalty of its employees through things like runway for growth (stretch roles and sponsored work innovation) and tolerance for error (valuing demonstrable learning over perfection in execution). No longer.

    http://www.rosspettit.com/2024/08/for-years-tech-was-fighting-war-for.html

  • Convert between light exposure and intensity

    ,
    import math,sys
    
    def Exposure2Intensity(exposure): 
        exp = float(exposure)
        result = math.pow(2,exp)
        print(result)
    
    Exposure2Intensity(0)
    
    def Intensity2Exposure(intensity):
        inarg = float(intensity)
        
        if inarg == 0:
            print("Exposure of zero intensity is undefined.")
            return
        
        if inarg < 1e-323:
            inarg = max(inarg, 1e-323)
            print("Exposure of negative intensities is undefined. Clamping to a very small value instead (1e-323)")
        
        result = math.log(inarg, 2)
        print(result)
    
    Intensity2Exposure(0.1)
    

    Why Exposure?

    Exposure is a stop value that multiplies the intensity by 2 to the power of the stop. Increasing exposure by 1 results in double the amount of light.

    Artists think in “stops.” Doubling or halving brightness is easy math and common in grading and look-dev.
    Exposure counts doublings in whole stops:

    • +1 stop = ×2 brightness
    • −1 stop = ×0.5 brightness

    This gives perceptually even controls across both bright and dark values.


    Why Intensity?

    Intensity is linear.
    It’s what render engines and compositors expect when:

    • Summing values
    • Averaging pixels
    • Multiplying or filtering pixel data

    Use intensity when you need the actual math on pixel/light data.


    Formulas (from your Python)

    • Intensity from exposure: intensity = 2**exposure
    • Exposure from intensity: exposure = log₂(intensity)

    Guardrails:

    • Intensity must be > 0 to compute exposure.
    • If intensity = 0 → exposure is undefined.
    • Clamp tiny values (e.g. 1e−323) before using log₂.

    Use Exposure (stops) when…

    • You want artist-friendly sliders (−5…+5 stops)
    • Adjusting look-dev or grading in even stops
    • Matching plates with quick ±1 stop tweaks
    • Tweening brightness changes smoothly across ranges

    Use Intensity (linear) when…

    • Storing raw pixel/light values
    • Multiplying textures or lights by a gain
    • Performing sums, averages, and filters
    • Feeding values to render engines expecting linear data

    Examples

    • +2 stops → 2**2 = 4.0 (×4)
    • +1 stop → 2**1 = 2.0 (×2)
    • 0 stop → 2**0 = 1.0 (×1)
    • −1 stop → 2**(−1) = 0.5 (×0.5)
    • −2 stops → 2**(−2) = 0.25 (×0.25)
    • Intensity 0.1 → exposure = log₂(0.1) ≈ −3.32

    Rule of thumb

    Think in stops (exposure) for controls and matching.
    Compute in linear (intensity) for rendering and math.