IES profile as Light emitter?

[crz06-CK]

Hi,
Is it possible to use an IES profile as light emitter, as the docs don't mention it?

For some context, I'll be using a powerled (COB or SMD) with an erea of 1x1cm , placed up close to a computationally derived lens (<10cm distance) to cast a caustic projection.

If IES profiles are not supperted, any suggestions what type of emitter would be preferable to use

[njroussel]

Hi @crz06-CK

We indeed do not natively support this, and do not plan to support it either.

I'm not very familiar with IES profiles, maybe the projector plugin? I feel like you'd be better off writing your own custom Emitter plugin for this.

[njroussel]

Example implementation by @arpit15 🎉 over here: #809 (comment)

[crz06-CK]

Hi @njroussel , thanks for letting me know. I'm trying to follow along with the tutorial 'Inverse rendering tutorials > Caustics optimization' with the aim of making a small lamp out of a milled and polished piece of acrylic and a powerLED as light source.

Since this emiiter in my particulr cause is a light torch with a powerLED diode of 1x1cm (big!) and the distance to the optimized lens geometry quit short (<10cm), i'm not quite sure which emitter type would be best used. it could be either a Spot Light or a Area Light with rectangle as shape.

What do you recon would give the best result? I expect the milling and polishing will take up some hours, so I'd rather not try both option

[njroussel]

My personal intuition would be the area light. But I honestly can't tell how well it will transfer to a physical setup. My recommendation would be to optimize the lens and then simply do normal forward renderings with slightly wrong lighting setups to see how "robust" the optimized geometry is to different setups.

[njroussel]

By the way, if you actually get this to work @crz06-CK, I'd love to see some pictures/videos of the final effect 😄

[gioarma]

Hello, also for my applications it would be great to create an emitter starting from a .IES file. Is there any chance this could be a new feature in future versions? .IES files are the standard format for specifying light emission profiles, and it would be great to have this capability!

[njroussel]

Hi, there are no short short or long term plans to implement such a feature currently.

[arpit15]

Hey @gioarma I implemented IES python plugin for my use-case here . Checkout if it is useful for you.

[crz06-CK]

Hi @arpit15 , oh, wow. thanks for letting us know.

I am currently looking into the capabilities of Mitsuba and am excited to see what's possible. However, I must admit that my Python skills are not at the level required to fully understand what is going on. I came across this notebook on caustics optimization: example. I was wondering if you could guide me on how to implement your plugin with this particular notebook. Any help or guidance would be greatly appreciated!

[crz06-CK]

It's been a while ;) Anyway I've been trying to get real-world IES light into the demo inverse rendering example. But, still quit unfamiliar with all that Mitsuba has to offer and my Python skills are below par (not a programmer). That being said:.

My aim is to create a self-contained, differentiable set-up that:

• Loads an IES profile via a custom Python emitter.
• Co-optimises a lens‐surface normal map and the lamp's pose.
• Keeps gradients numerically stable.
• Can run on either llvm_ad_rgb for debugging or cuda_ad_rgb for production.

I've put together the following files based on the documentation, but not sure if any of this actuually makes sense .

I am hoping some of you with more experience could skim through my approach. I would be incredibly grateful for any feedback on potential pitfalls, wrong assumptions, or obvious performance traps I might have missed.

Below are the three files for the setup. Any thoughts or suggestions would be fantastic.

Thanks in advance!

---

downlight.ies

A simple IES profile for testing. More can be found at [IES Library](https://ieslibrary.com/browse).

IESNA:LM-63-2002
[TEST] Generated for Mitsuba 3 Example
[MANUFAC] Mitsuba Lighting
TILT=NONE
1 1.0 1.0 11 1 1 1.0 1.0 0.0
0 5 15 25 35 45 55 65 75 85 90
0
100 95 90 80 65 40 20 10 5 2 0

ies_emitter.py

The custom, differentiable IES emitter.

import mitsuba as mi
import drjit as dr
import numpy as np
import re

mi.register_emitter("iesemitter", lambda props: IESEmitter(props))

class IESEmitter(mi.Emitter):
    """
    Differentiable IES emitter for Mitsuba 3.

    * robust LM-63 parser
    * GPU-resident candela grid (DiscreteDistribution2D)
    * MIS-correct sample_{ray,direction}/pdf_direction
    * AD-exposed intensity & pose
    """
    # ─────────────────────────────────────────────────── parser ──
    def _parse_ies(self, filename):
        with open(filename) as f:
            lines = [l.strip() for l in f]
        tilt_i = next(i for i,l in enumerate(lines) if 'TILT=' in l)
        numbers = [float(x) for x in re.findall(r'[-+]?\d*\.?\d+', " ".join(lines[tilt_i+1:]))]

        multiplier      = numbers[2]
        n_v, n_h        = map(int, numbers[3:5])
        v_angles        = numbers[10:10+n_v]
        h_angles        = numbers[10+n_v:10+n_v+n_h]
        start           = 10 + n_v + n_h
        candela         = numbers[start:start+n_v*n_h]
        candela_grid    = np.array(candela).reshape(n_h, n_v).T   # V fastest

        return dict(v_angles=v_angles, h_angles=h_angles,
                    candela=candela_grid, multiplier=multiplier)

    # ───────────────────────────────────────────── constructor ──
    def __init__(self, props):
        super().__init__(props)
        data                = self._parse_ies(props.get('filename'))

        # store as Dr.Jit tensors on the active backend
        self._v_rad         = dr.asarray(mi.Float, np.radians(data['v_angles']))
        self._h_rad         = dr.asarray(mi.Float, np.radians(data['h_angles']))
        self._candela_tex   = dr.asarray(mi.Float, data['candela'])
        self._distr         = mi.DiscreteDistribution2D(self._candela_tex)
        self._mult          = data['multiplier']

        self.to_world       = props.get('to_world', mi.ScalarTransform4f())
        self.intensity      = mi.Color3f(props.get('intensity', 1.0))
        self.m_flags        = mi.EmitterFlags.DeltaPosition

    # ───────────────────────────── AD exposure & bookkeeping ──
    def traverse(self, cb):
        cb.put_parameter('to_world', self.to_world,
                          mi.ParamFlags.Differentiable | mi.ParamFlags.Discontinuous)
        cb.put_parameter('intensity', self.intensity,
                          mi.ParamFlags.Differentiable)

    def parameters_changed(self, keys):
        if 'to_world'  in keys: self.to_world  = self.params['to_world']
        if 'intensity' in keys: self.intensity = self.params['intensity']

    # ───────────────────────────── helpers ──
    def _dir_to_uv(self, d):
        d      = dr.normalize(d)
        v      = dr.acos(d.z)                      # 0..π
        h      = dr.atan2(d.y, d.x + 1e-9)       # 0..2π
        u      = h / (self._h_rad[-1] - self._h_rad[0])
        v      = v / (self._v_rad[-1] - self._v_rad[0])
        return mi.Point2f(u, v)

    # ───────────────────────────── primary sampling ──
    def sample_ray(self, time, wav, pos_samp, dir_samp, active=True):
        uv, pdf_dir   = self._distr.sample(dir_samp, active)

        v = dr.lerp(self._v_rad[0], self._v_rad[-1], uv.y)
        h = dr.lerp(self._h_rad[0], self._h_rad[-1], uv.x)
        sin_v, cos_v = dr.sincos(v)
        sin_h, cos_h = dr.sincos(h)
        local_dir    = mi.Vector3f(sin_v*cos_h, sin_v*sin_h, cos_v)

        o_world      = self.to_world.translation()
        d_world      = self.to_world.transform_affine(local_dir)
        ray          = mi.Ray3f(o_world, d_world, time, wav)

        inv_sin_v    = dr.select(v > 1e-5, 1.0/sin_v, 0.0)
        pdf_sa       = pdf_dir * inv_sin_v / (
                           (self._v_rad[-1]-self._v_rad[0]) *
                           (self._h_rad[-1]-self._h_rad[0]))
        candela      = self._distr.eval(uv, active)
        L            = dr.select(pdf_sa > 1e-6,
                              candela * self._mult / pdf_sa, 0.0) * self.intensity
        return ray, mi.Spectrum(L)

    # ───────────────────────────── NEE sampling ──
    def sample_direction(self, it, samp, active=True):
        dist        = dr.norm(self.to_world.translation() - it.p)
        d           = (self.to_world.translation() - it.p) / dist
        ds          = mi.DirectionSample(p=self.to_world.translation(),
                                          d=d, dist=dist, emitter=self)

        dir_local   = self.to_world.inverse().transform_affine(-d)
        uv          = self._dir_to_uv(dir_local)
        candela     = self._distr.eval(uv, active)
        spec        = candela * self._mult * self.intensity / (dist*dist)
        return ds, mi.Spectrum(spec)

    def pdf_direction(self, it, ds, active=True):  # delta-pos ⇒ 0 everywhere
        return 0.0

    def eval(self, si, active=True):              # cannot hit a point source
        return mi.Spectrum(0.0)

caustics_with_ies.py

The main optimization script. This assumes a mitsuba.png and meshes/rectangle.obj are available in the same directory. The obj can be found here: https://mitsuba.readthedocs.io/en/stable/src/inverse_rendering/caustics_optimization.html

import mitsuba as mi, drjit as dr, os, ies_emitter

# ───────── config ─────────
mi.set_variant('llvm_ad_rgb')         # swap to 'cuda_ad_rgb' later
HEIGHTMAP_RES, SPP, N_ITER = 64, 4, 50
root = os.path.dirname(os.path.abspath(__file__))
p    = lambda r: os.path.join(root, r)

# ───────── scene ──────────
scene = mi.load_dict({
    "type": "scene",
    "integrator": {"type": "ptracer", "max_bounces": 3},

    "emitter": {
        "type": "iesemitter", "id": "light",
        "filename": p("downlight.ies"),
        "to_world": mi.ScalarTransform4f.look_at([0,10,0],[0,0,0],[0,0,1]),
        "intensity": 2500.0,
    },

    "sensor": {
        "type": "perspective",
        "to_world": mi.ScalarTransform4f.look_at([0,0,12],[0,0,0],[0,1,0]),
        "sampler": {"type":"independent","sample_count":256},
        "film": {"type":"hdrfilm","width":256,"height":256,"rfilter":{"type":"box"}},
    },

    "glass": {
        "type":"obj", "filename": p("meshes/rectangle.obj"),
        "bsdf": {
            "type":"roughdielectric", "distribution":"beckmann",
            "alpha":0.0, "int_ior":"bk7", "ext_ior":"air",
            "normal_map": {
                "type":"normalmap",
                "bitmap":{"type":"bitmap","raw":True,"channel_count":1}
            }
        },
    },

    "ground": {
        "type":"obj", "filename": p("meshes/rectangle.obj"),
        "to_world": mi.ScalarTransform4f.translate([0,0,-1]),
        "bsdf":{"type":"diffuse"},
    },
})

# ───────── reference ─────
ref = mi.Bitmap(p("mitsuba.png")).convert(mi.Bitmap.PixelFormat.RGB,
      mi.Struct.Type.Float32, True).crop(scene.sensors()[0].film().size())
os.makedirs(p("out"), exist_ok=True)
mi.util.write_bitmap(p("out/ref.png"), ref)

# ───────── optimisation ──
params = mi.traverse(scene)
map_key = 'glass.bsdf.normal_map.bitmap.data'
params[map_key] = dr.full(mi.TensorXf, 0.5, [HEIGHTMAP_RES]*2); params.update()

opt = mi.ad.Adam(lr=0.02)
opt['heightmap']      = params[map_key]
opt['light.to_world'] = params['light.to_world']; params.update()

print("Optimising:", list(opt.keys()))
for it in range(N_ITER+1):
    img  = mi.render(scene, spp=SPP)
    if it % 10 == 0:
        mi.util.write_bitmap(p(f"out/iter_{it:03}.png"), img)

    loss = dr.mean(dr.sqr(img - ref)); print(f"\rIter {it}/{N_ITER}  loss={loss[0]:.3}", end="")
    dr.backward(loss)

    if dr.any(dr.isnan(dr.norm(opt['heightmap'].grad))):
        print("\nNaN gradient — aborting"); break

    opt.step()
    params[map_key]          = opt['heightmap']
    params['light.to_world'] = opt['light.to_world']
    params.update()

print("\nDone.")
mi.util.write_bitmap(p("out/final.png"), mi.render(scene, spp=256))
mi.util.write_bitmap(p("out/final_heightmap.png"), params[map_key])