C:\Program\ Files\ \(x86\)\Hugin\bin\nona -g  -r hdr -m EXR_m -o derp_hdr_ -i 1 C:\Users\Janne\AppData\Local\Temp\hug7841.tmp
nona: using graphics card: NVIDIA Corporation GeForce 8800 GT/PCI/SSE2
destStart=[104, 83]
destEnd=[3784, 2554]
destSize=[(3680, 2471)]
srcSize=[(3896, 2608)]
srcBuffer=05CA0020
srcAlphaBuffer=0D9A0020
destBuffer=10040020
destAlphaBuffer=0D0F0020
destGLInternalFormat=GL_RGBA32F_ARB
destGLFormat=GL_RGB
destGLType=GL_FLOAT
srcGLInternalFormat=GL_RGBA32F_ARB
srcGLFormat=GL_RGB
srcGLType=GL_FLOAT
srcAlphaGLType=GL_UNSIGNED_BYTE
destAlphaGLType=GL_UNSIGNED_BYTE
warparound=0
needsAtanWorkaround=0
maxTextureSize=8192
Source chunks:
    [(0, 0) to (3896, 2608) = (3896x2608)]
Dest chunks:
    [(0, 0) to (1840, 1236) = (1840x1236)]
    [(1840, 0) to (3680, 1236) = (1840x1236)]
    [(0, 1236) to (1840, 2471) = (1840x1235)]
    [(1840, 1236) to (3680, 2471) = (1840x1235)]
Total GPU memory used: 415196992
Interpolator chunks:
    [(0, 0) to (4, 4) = (4x4)]
    [(4, 0) to (8, 4) = (4x4)]
    [(0, 4) to (4, 8) = (4x4)]
    [(4, 4) to (8, 8) = (4x4)]
#version 110
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect SrcTexture;
float sinh(in float x) { return (exp(x) - exp(-x)) / 2.0; }
float cosh(in float x) { return (exp(x) + exp(-x)) / 2.0; }
float atan2_xge0(const in float y, const in float x) {
    return atan(y, x);
}
float atan2_safe(const in float y, const in float x) {
    return atan(y, x);
}
float atan_safe(const in float yx) {
    return atan(yx);
}
void main(void)
{
    float discardA = 1.0;
    float discardB = 0.0;
    vec2 src = gl_TexCoord[0].st;
    src -= vec2(1949.0000000000000000, 1315.0000000000000000);

    // erect_rect(1949.0000000000002000)
    src.t = 1949.0000000000002000 * atan2_xge0(src.t, length(vec2(1949.0000000000002000, src.s)));
    src.s = 1949.0000000000002000 * atan2_safe(src.s, 1949.0000000000002000);

    // rotate_erect(6122.9640818465077000, -0.28699763343168316000)
    {
        src.s += -0.28699763343168316000;
        float w = (abs(src.s) > 6122.9640818465077000) ? 1.0 : 0.0;
        float n = (src.s < 0.0) ? 0.5 : -0.5;
        src.s += w * -12245.928163693015000 * ceil(src.s / 12245.928163693015000 + n);
    }

    // sphere_tp_erect(1949.0000000000002000)
    {
        float phi = src.s / 1949.0000000000002000;
        float theta = -src.t / 1949.0000000000002000 + 1.5707963267948966000;
        if (theta < 0.0) {
            theta = -theta;
            phi += 3.1415926535897931000;
        }
        if (theta > 3.1415926535897931000) {
            theta = 3.1415926535897931000 - (theta - 3.1415926535897931000);
            phi += 3.1415926535897931000;
        }
        float s = sin(theta);
        vec2 v = vec2(s * sin(phi), cos(theta));
        float r = length(v);
        theta = 1949.0000000000002000 * atan2_safe(r, s * cos(phi));
        src = v * (theta / r);
    }

    // persp_sphere(1949.0000000000002000)
    {
        mat3 m = mat3(0.99999998806951285000, -0.00015446997705442357000, -2.1057016848147338000e-008,
                      0.00015446997848964731000, 0.99999997877823343000, 0.00013631785802532579000,
                      0.00000000000000000000, -0.00013631785965166426000, 0.99999999070872048000);
        float r = length(src);
        float theta = r / 1949.0000000000002000;
        float s = 0.0;
        if (r != 0.0) s = sin(theta) / r;
        vec3 v = vec3(s * src.s, s * src.t, cos(theta));
        vec3 u = v * m;
        r = length(u.st);
        theta = 0.0;
        if (r != 0.0) theta = 1949.0000000000002000 * atan2_safe(r, u.p) / r;
        src = theta * u.st;
    }

    // rect_sphere_tp(1949.0000000000002000)
    {
        float r = length(src);
        float theta = r / 1949.0000000000002000;
        float rho = 0.0;
        if (theta >= 1.5707963267948966000) rho = 1.6e16;
        else if (theta == 0.0) rho = 1.0;
        else rho = tan(theta) / theta;
        src *= rho;
    }

    // resize(1.0000422717545789000, 1.0000422717545789000)
    src *= vec2(1.0000422717545789000, 1.0000422717545789000);

    src += vec2(1945.5000000000000000, 1303.5000000000000000);

    src = src * discardA + vec2(-1000.0, -1000.0) * discardB;
    gl_FragColor = vec4(src.s, 0.0, 0.0, src.t);
}
#version 110
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect CoordTexture;
uniform sampler2DRect SrcTexture;
uniform sampler2DRect AccumTexture;
uniform vec2 SrcUL;
uniform vec2 SrcLR;
uniform vec2 KernelUL;
uniform vec2 KernelWH;
float w(const in float i, const in float f) {
    return (i > 3.0) ? (i > 5.0) ? (i == 7.0) ? (((  1.0/41.0 * f -   45.0/2911.0) * f -   26.0/2911.0) * f)
                                              : (((- 6.0/41.0 * f +  270.0/2911.0) * f +  156.0/2911.0) * f)
                                 : (i == 5.0) ? ((( 24.0/41.0 * f - 1080.0/2911.0) * f -  624.0/2911.0) * f)
                                              : (((-49.0/41.0 * f + 4050.0/2911.0) * f + 2340.0/2911.0) * f)
                     : (i > 1.0) ? (i == 3.0) ? ((( 49.0/41.0 * f - 6387.0/2911.0) * f -    3.0/2911.0) * f + 1.0)
                                              : (((-24.0/41.0 * f + 4032.0/2911.0) * f - 2328.0/2911.0) * f)
                                 : (i == 1.0) ? (((  6.0/41.0 * f - 1008.0/2911.0) * f +  582.0/2911.0) * f)
                                              : (((- 1.0/41.0 * f +  168.0/2911.0) * f -   97.0/2911.0) * f);
}
void main(void)
{
    vec2 src = texture2DRect(CoordTexture, gl_TexCoord[0].st).sq;
    vec4 accum = texture2DRect(AccumTexture, gl_TexCoord[0].st);

    src -= SrcUL;
    vec2 t = floor(src) + -2.5000000000000000000;
    vec2 f = fract(src);
    vec2 k = vec2(0.0, 0.0);

    for (float ky = 0.0; ky < 4.0000000000000000000; ky += 1.0) {
        k.t = ky + KernelUL.t;
        float wy = w(k.t, f.t);
        for (float kx = 0.0; kx < 4.0000000000000000000; kx += 1.0) {
            k.s = kx + KernelUL.s;
            float wx = w(k.s, f.s);
            vec2 ix = t + k;
            vec4 sp = texture2DRect(SrcTexture, ix);
            float weight = wx * wy * sp.a;
            accum += sp * weight;
        }
    }

    gl_FragColor = accum;
}

#version 120
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect NormTexture;
uniform sampler2DRect CoordTexture;
uniform sampler2DRect InvLutTexture;
void main(void)
{
    // Normalization
    vec4 n = texture2DRect(NormTexture, gl_TexCoord[0].st);
    vec4 p = vec4(0.0, 0.0, 0.0, 0.0);
    if (n.a >= 0.2) p = n / n.a;

    // Photometric
    // invLutSize = 1024.0000000000000000
    // pixelMax = 1.0000000000000000000
    // destLutSize = 0.00000000000000000000
    // destExposure = 1.0000000000000000000
    // srcExposure = 0.0055199376118906986000
    // whiteBalanceRed = 1.0000000000000000000
    // whiteBalanceBlue = 1.0000000000000000000
    p.rgb = p.rgb * 1023.0000000000000000;
    vec2 invR = texture2DRect(InvLutTexture, vec2(p.r, 0.0)).sq;
    vec2 invG = texture2DRect(InvLutTexture, vec2(p.g, 0.0)).sq;
    vec2 invB = texture2DRect(InvLutTexture, vec2(p.b, 0.0)).sq;
    vec3 invX = vec3(invR.x, invG.x, invB.x);
    vec3 invY = vec3(invR.y, invG.y, invB.y);
    vec3 invA = fract(p.rgb);
    p.rgb = mix(invX, invY, invA);
    // VigCorrMode=VIGCORR_RADIAL
    float vig = 1.0;
    {
        vec2 vigCorrCenter = vec2(1945.5000000000000000, 1303.5000000000000000);
        float radiusScale=0.00042689334202089947000;
        float radialVigCorrCoeff0 = 1.0000000000000000000;
        float radialVigCorrCoeff1 = 0.00000000000000000000;
        float radialVigCorrCoeff2 = 0.00000000000000000000;
        float radialVigCorrCoeff3 = 0.00000000000000000000;
        vec2 src = texture2DRect(CoordTexture, gl_TexCoord[0].st).sq;
        vec2 d = src - vigCorrCenter;
        d *= radiusScale;
        vig = radialVigCorrCoeff0;
        float r2 = dot(d, d);
        float r = r2;
        vig += radialVigCorrCoeff1 * r;
        r *= r2;
        vig += radialVigCorrCoeff2 * r;
        r *= r2;
        vig += radialVigCorrCoeff3 * r;
    }
    vec3 exposure_whitebalance = vec3(181.16146781185779000, 181.16146781185779000, 181.16146781185779000);
    p.rgb = (p.rgb * exposure_whitebalance) / vig;
    p.a = max(p.r, max(p.g, p.b));

    gl_FragColor = p;
}

gpu shader program compile time = 0.125
gpu shader texture/framebuffer setup time = 0.031
gpu dest chunk=[(0, 0) to (1840, 1236) = (1840x1236)] coord image render time = 0
gpu dest chunk=[(0, 0) to (1840, 1236) = (1840x1236)] source chunk=[(0, 0) to (3896, 2608) = (3896x2608)] src upload = 0.172
gpu dest chunk=[(0, 0) to (1840, 1236) = (1840x1236)] source chunk=[(0, 0) to (3896, 2608) = (3896x2608)] src alpha upload = 0.015
make: *** [derp_hdr_0001.exr] Error 1