fix(texture): fix texture overblur with st-blur parameters (#5071)

Fixes #5069

This PR fixes the texture blur overstimate reported in #5069

We provide the following changes:
* Use the mathematically correct Pythagorean form to properly adjust the
ellispse footprint with st-blur parameters.
* Add a new legacy_texture_blur attribute in TextureSystem to opt into
the fix without breaking existing renders.
* Add a new --fix-texture-blur option in testtex to enable the fix.
* Add a new texture-blurfix test.

Note: This PR has been partially edited using the Claude coding
assistant.

---------

Signed-off-by: Pascal Lecocq <pascal.lecocq@gmail.com>

Author: lecocqp

src/cmake/testing.cmake

@@ -186,6 +186,7 @@ macro (oiio_add_all_tests)
                     texture-uint8
                     texture-width0blur
                     texture-wrapfill
+                    texture-blurfix
                     texture-fat texture-skinny
                     texture-stats
                     texture-threadtimes

src/libtexture/texture_pvt.h

@@ -467,6 +467,13 @@ class TextureSystemImpl {
     int m_max_tile_channels;  ///< narrow tile ID channel range when
                               ///<   the file has more channels
     int m_stochastic;
+#if OIIO_VERSION_GREATER_EQUAL(3, 2, 0)
+    bool m_legacy_texture_blur = false;  ///< Use legacy texture blur behavior?
+    // Opt OUT of the fix for 3.2 and beyond
+#else
+    bool m_legacy_texture_blur = true;  ///< Use legacy texture blur behavior?
+    // Opt IN to get the fix for 3.1
+#endif
     static EightBitConverter<float> uchar2float;
 
     enum StochasticStrategyBits {

src/libtexture/texturesys.cpp

@@ -746,10 +746,11 @@ void
 TextureSystemImpl::init()
 {
     m_Mw2c.makeIdentity();
-    m_gray_to_rgb       = false;
-    m_flip_t            = false;
-    m_max_tile_channels = 6;
-    m_stochastic        = StochasticStrategy_None;
+    m_gray_to_rgb         = false;
+    m_flip_t              = false;
+    m_max_tile_channels   = 6;
+    m_stochastic          = StochasticStrategy_None;
+    m_legacy_texture_blur = false;
     hq_filter.reset(Filter1D::create("b-spline", 4));
     m_statslevel = 0;
 
@@ -907,6 +908,10 @@ TextureSystemImpl::attribute(string_view name, TypeDesc type, const void* val)
         unit_test_texture_blur = *(const float*)val;
         return true;
     }
+    if (name == "legacy_texture_blur" && type == TypeInt) {
+        m_legacy_texture_blur = (*(const int*)val != 0);
+        return true;
+    }
 
     // Maybe it's meant for the cache?
     return m_imagecache->attribute(name, type, val);
@@ -926,6 +931,7 @@ TextureSystemImpl::getattributetype(string_view name) const
         { "flip_t", TypeInt },
         { "max_tile_channels", TypeInt },
         { "stochastic", TypeInt },
+        { "legacy_texture_blur", TypeInt },
     };
     // clang-format on
 
@@ -975,6 +981,10 @@ TextureSystemImpl::getattribute(string_view name, TypeDesc type,
         *(int*)val = m_stochastic;
         return true;
     }
+    if (name == "legacy_texture_blur" && type == TypeInt) {
+        *(int*)val = m_legacy_texture_blur;
+        return true;
+    }
 
     // If not one of these, maybe it's an attribute meant for the image cache?
     return m_imagecache->getattribute(name, type, val);
@@ -1890,7 +1900,7 @@ adjust_width(float& dsdx, float& dtdx, float& dsdy, float& dtdy, float swidth,
 // back to this and solve it better.
 inline void
 adjust_blur(float& majorlength, float& minorlength, float& theta, float sblur,
-            float tblur)
+            float tblur, bool legacy_textblur = false)
 {
     if (sblur + tblur != 0.0f /* avoid the work when blur is zero */) {
         // Carefully add blur to the right derivative components in the
@@ -1901,8 +1911,22 @@ adjust_blur(float& majorlength, float& minorlength, float& theta, float sblur,
         fast_sincos(theta, &sintheta, &costheta);
         sintheta = fabsf(sintheta);
         costheta = fabsf(costheta);
-        majorlength += sblur * costheta + tblur * sintheta;
-        minorlength += sblur * sintheta + tblur * costheta;
+
+        if (legacy_textblur) {
+            // The legacy blur code just adds the blur to the major and minor
+            // axes, which is a crude approximation that is wrong at some angles
+            // but is very simple and fast.  I'm leaving it here as an option
+            // for now, in case the new code causes any unforeseen problems.
+            majorlength += sblur * costheta + tblur * sintheta;
+            minorlength += sblur * sintheta + tblur * costheta;
+        } else {
+            const float sintheta2 = sintheta * sintheta;
+            const float costheta2 = costheta * costheta;
+            const float sblur2    = sblur * sblur;
+            const float tblur2    = tblur * tblur;
+            majorlength += sqrtf(sblur2 * costheta2 + tblur2 * sintheta2);
+            minorlength += sqrtf(sblur2 * sintheta2 + tblur2 * costheta2);
+        }
 #if 1
         if (minorlength > majorlength) {
             // Wildly uneven sblur and tblur values might swap which axis is
@@ -2273,7 +2297,8 @@ TextureSystemImpl::texture_lookup(TextureFile& texturefile,
     // or bicubic texture probes, and therefore runtime!
     ellipse_axes(dsdx, dtdx, dsdy, dtdy, majorlength, minorlength, theta);
 
-    adjust_blur(majorlength, minorlength, theta, options.sblur, options.tblur);
+    adjust_blur(majorlength, minorlength, theta, options.sblur, options.tblur,
+                m_legacy_texture_blur);
 
     float aspect, trueaspect;
     aspect = anisotropic_aspect(majorlength, minorlength, options, trueaspect);
@@ -3388,7 +3413,8 @@ TextureSystemImpl::visualize_ellipse(const std::string& name, float dsdx,
     ellipse_axes(dsdx, dtdx, dsdy, dtdy, majorlength, minorlength, theta, ABCF);
     std::cout << "  ellipse major " << majorlength << ", minor " << minorlength
               << ", theta " << theta << "\n";
-    adjust_blur(majorlength, minorlength, theta, sblur, tblur);
+    adjust_blur(majorlength, minorlength, theta, sblur, tblur,
+                m_legacy_texture_blur);
     std::cout << "  post " << sblur << ' ' << tblur << " blur: major "
               << majorlength << ", minor " << minorlength << "\n\n";
 

src/testtex/testtex.cpp

@@ -86,6 +86,7 @@ static bool test_derivs            = false;
 static bool test_statquery         = false;
 static bool invalidate_before_iter = true;
 static bool close_before_iter      = false;
+static bool legacy_texture_blur    = false;
 static bool runstats               = false;
 static bool udim_tests             = false;
 static bool do_gettextureinfo      = true;
@@ -200,6 +201,8 @@ getargs(int argc, const char* argv[])
       .help("Do not warp the image->texture mapping");
     ap.arg("--tube", &tube)
       .help("Make a tube projection");
+    ap.arg("--legacy-texture-blur", &legacy_texture_blur)
+      .help("Use mathematically correct texture blur instead of legacy overblur");
     ap.arg("--ctr", &test_construction)
       .help("Test TextureOpt construction time");
     ap.arg("--gettexels", &test_gettexels)
@@ -1831,6 +1834,10 @@ main(int argc, const char* argv[])
     texsys->attribute("gray_to_rgb", gray_to_rgb);
     texsys->attribute("flip_t", flip_t);
     texsys->attribute("stochastic", stochastic);
+    if (legacy_texture_blur)
+        texsys->attribute("legacy_texture_blur", 1);
+    else
+        texsys->attribute("legacy_texture_blur", 0);
     texcolortransform_id
         = std::max(0, texsys->get_colortransform_id(ustring(texcolorspace),
                                                     ustring("scene_linear")));