Merge branch 'main' of github.com:AcademySoftwareFoundation/OpenImageIO into 4632_rust_bindings

scott-wilson · scott-wilson · commit 232522793d55 · 2025-05-17T14:46:34.000-07:00
Signed-off-by: Scott Wilson &lt;scott@propersquid.com&gt;
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -605,12 +605,21 @@ jobs:
         include:
           - desc: Windows-2019 VS2019
             runner: windows-2019
+            nametag: windows-2019
             vsver: 2019
             generator: "Visual Studio 16 2019"
             python_ver: "3.9"
             setenvs: export OPENIMAGEIO_PYTHON_LOAD_DLLS_FROM_PATH=1
           - desc: Windows-2022 VS2022
             runner: windows-2022
+            nametag: windows-2022
+            vsver: 2022
+            generator: "Visual Studio 17 2022"
+            python_ver: "3.9"
+            setenvs: export OPENIMAGEIO_PYTHON_LOAD_DLLS_FROM_PATH=1
+          - desc: Windows-2025 VS2022
+            runner: windows-2025
+            nametag: windows-2025
             vsver: 2022
             generator: "Visual Studio 17 2022"
             python_ver: "3.9"
diff --git a/.gitignore b/.gitignore
@@ -23,6 +23,7 @@ gastest.o
 /*.exr
 /*.tif
 /*.jpg
+/*.png
 /*.jxl
 /*.tx
 /*.log
diff --git a/src/doc/figures/imagebuf-notebook-demo.png b/src/doc/figures/imagebuf-notebook-demo.png
diff --git a/src/doc/pythonbindings.rst b/src/doc/pythonbindings.rst
@@ -4260,3 +4260,39 @@ add an alpha channel that is 1 everywhere**
             out.open ("multipart.exr", specs[s], "AppendSubimage")
         bufs[s].write (out)
     out.close ()
+
+
+
+|
+
+**Running OpenImageIO in Jupyter Notebooks and displaying ImageBuf**
+
+
+Like any other Python package, OpenImageIO can be used in `Jupyter notebooks <https://jupyter.org/install>`_. 
+The ImageBuf objects support getting displayed inline within notebooks.
+
+.. image:: figures/imagebuf-notebook-demo.png
+
+.. warning::
+    
+    Currently, ImageBuf objects get displayed as **uint8 PNGs** inside of notebooks.
+    ImageBuf objects that store images with higher bit depths get dithered to account for this.
+    Keep in mind that directly saving the inline image to disk will not preserve the original image within the ImageBuf.
+
+
+Running a Local Jupyter Notebook:
+
+If you want to run a local Jupyter notebook with OpenImageIO, you can do so from within the Python environment in which you have installed OpenImageIO.
+
+.. code-block:: bash
+
+    pip install jupyterlab
+    jupyter lab
+
+Alternatively, if you prefer using `uv <https://github.com/astral-sh/uv>`_, you can run the following command:
+
+.. code-block:: bash
+
+    uv run --with jupyter jupyter lab
+
+
diff --git a/src/include/OpenImageIO/typedesc.h b/src/include/OpenImageIO/typedesc.h
@@ -616,6 +616,9 @@ struct formatter<OIIO::TypeDesc> {
     {
         // Get the presentation type, if any. Required to be 's'.
         auto it = ctx.begin(), end = ctx.end();
+        // Skip any width specifier. Remember that this is only for old
+        // versions of fmt, so just don't sweat it.
+        while (it != end && isdigit(*it)) ++it;
         if (it != end && (*it == 's')) ++it;
         // Check if reached the end of the range:
         if (it != end && *it != '}')
diff --git a/src/iv/imageviewer.cpp b/src/iv/imageviewer.cpp
@@ -854,14 +854,11 @@ ImageViewer::open()
         if (filename.empty())
             continue;
         add_image(filename);
-        //        int n = m_images.size()-1;
-        //        IvImage *newimage = m_images[n];
-        //        newimage->read_iv (0, false, image_progress_callback, this);
     }
+
     if (old_lastimage >= 0) {
         // Otherwise, add_image already did this for us.
         current_image(old_lastimage + 1);
-        fitWindowToImage(true, true);
     }
 }
 
@@ -887,7 +884,6 @@ ImageViewer::openRecentFile()
         if (m_images.size() > 1) {
             // Otherwise, add_image already did this for us.
             current_image(m_images.size() - 1);
-            fitWindowToImage(true, true);
         }
     }
 }
@@ -2009,67 +2005,59 @@ ImageViewer::print()
 }
 
 
-
 void
-ImageViewer::zoomIn()
+ImageViewer::zoomIn(bool smooth)
 {
     IvImage* img = cur();
     if (!img)
         return;
-    if (zoom() >= 64)
+
+    float current_zoom = zoom();
+    if (current_zoom >= 64)
         return;
-    float oldzoom = zoom();
-    float newzoom = ceil2f(oldzoom);
 
-    float xc, yc;  // Center view position
-    glwin->get_center(xc, yc);
-    int xm, ym;  // Mouse position
-    glwin->get_focus_image_pixel(xm, ym);
-    float xoffset      = xc - xm;
-    float yoffset      = yc - ym;
-    float maxzoomratio = std::max(oldzoom / newzoom, newzoom / oldzoom);
-    int nsteps         = (int)OIIO::clamp(20 * (maxzoomratio - 1), 2.0f, 10.0f);
-    for (int i = 1; i <= nsteps; ++i) {
-        float a         = (float)i / (float)nsteps;  // Interpolation amount
-        float z         = OIIO::lerp(oldzoom, newzoom, a);
-        float zoomratio = z / oldzoom;
-        view(xm + xoffset / zoomratio, ym + yoffset / zoomratio, z, false);
-        if (i != nsteps) {
-            QApplication::processEvents();
-            Sysutil::usleep(1000000 / 4 / nsteps);
-        }
-    }
+    float newzoom = ceil2f(current_zoom);
 
-    fitImageToWindowAct->setChecked(false);
+    this->zoomToCursor(newzoom, smooth);
 }
 
 
-
 void
-ImageViewer::zoomOut()
+ImageViewer::zoomOut(bool smooth)
 {
     IvImage* img = cur();
     if (!img)
         return;
-    if (zoom() <= 1.0f / 64)
+
+    float current_zoom = zoom();
+    if (current_zoom <= 1.0f / 64)
         return;
+
+    float newzoom = floor2f(current_zoom);
+
+    this->zoomToCursor(newzoom, smooth);
+}
+
+
+void
+ImageViewer::zoomToCursor(float newzoom, bool smooth)
+{
     float oldzoom = zoom();
-    float newzoom = floor2f(oldzoom);
-
-    float xcpel, ycpel;  // Center view position
-    glwin->get_center(xcpel, ycpel);
-    int xmpel, ympel;  // Mouse position
-    glwin->get_focus_image_pixel(xmpel, ympel);
-    float xoffset      = xcpel - xmpel;
-    float yoffset      = ycpel - ympel;
+    float xc, yc;  // Center view position
+    glwin->get_center(xc, yc);
+    int xm, ym;  // Mouse position
+    glwin->get_focus_image_pixel(xm, ym);
+    float xoffset = xc - xm;
+    float yoffset = yc - ym;
+
     float maxzoomratio = std::max(oldzoom / newzoom, newzoom / oldzoom);
-    int nsteps         = (int)OIIO::clamp(20 * (maxzoomratio - 1), 2.0f, 10.0f);
+    int nsteps = smooth ? (int)OIIO::clamp(20 * (maxzoomratio - 1), 2.0f, 10.0f)
+                        : 1;
     for (int i = 1; i <= nsteps; ++i) {
         float a         = (float)i / (float)nsteps;  // Interpolation amount
         float z         = OIIO::lerp(oldzoom, newzoom, a);
         float zoomratio = z / oldzoom;
-        view(xmpel + xoffset / zoomratio, ympel + yoffset / zoomratio, z,
-             false);
+        view(xm + xoffset / zoomratio, ym + yoffset / zoomratio, z, false);
         if (i != nsteps) {
             QApplication::processEvents();
             Sysutil::usleep(1000000 / 4 / nsteps);
diff --git a/src/iv/imageviewer.h b/src/iv/imageviewer.h
@@ -265,10 +265,12 @@ private slots:
     void moveToNewWindow();     ///< Split current image off as a new window
     void print();               ///< Print current image
     void deleteCurrentImage();  ///< Deleting displayed image
-    void zoomIn();              ///< Zoom in to next power of 2
-    void zoomOut();             ///< Zoom out to next power of 2
-    void normalSize();          ///< Adjust zoom to 1:1
-    void fitImageToWindow();    ///< Adjust zoom to fit window exactly
+    void zoomIn(bool smooth = true);   ///< Zoom in to next power of 2
+    void zoomOut(bool smooth = true);  ///< Zoom out to next power of 2
+    void zoomToCursor(float newzoom,
+                      bool smooth = true);  ///< Zoom to a specific level
+    void normalSize();                      ///< Adjust zoom to 1:1
+    void fitImageToWindow();  ///< Adjust zoom to fit window exactly
     /// Resize window to fit image exactly.  If zoomok is false, do not
     /// change the zoom, even to fit on screen. If minsize is true, do not
     /// resize smaller than default_width x default_height.
diff --git a/src/iv/ivgl.cpp b/src/iv/ivgl.cpp
@@ -690,7 +690,9 @@ IvGL::shadowed_text(float x, float y, float /*z*/, const std::string& s,
      * Paint on intermediate QImage, AA text on QOpenGLWidget based
      * QPaintDevice requires MSAA
      */
-    QImage t(size(), QImage::Format_ARGB32_Premultiplied);
+    qreal dpr = devicePixelRatio();
+    QImage t(size() * dpr, QImage::Format_ARGB32_Premultiplied);
+    t.setDevicePixelRatio(dpr);
     t.fill(qRgba(0, 0, 0, 0));
     {
         QPainter painter(&t);
@@ -1218,13 +1220,13 @@ IvGL::mousePressEvent(QMouseEvent* event)
         switch (event->button()) {
         case Qt::LeftButton:
             if (mousemode == ImageViewer::MouseModeZoom && !Alt)
-                m_viewer.zoomIn();
+                m_viewer.zoomIn(true);  // Animated zoom for mouse clicks
             else
                 m_dragging = true;
             return;
         case Qt::RightButton:
             if (mousemode == ImageViewer::MouseModeZoom && !Alt)
-                m_viewer.zoomOut();
+                m_viewer.zoomOut(true);  // Animated zoom for mouse clicks
             else
                 m_dragging = true;
             return;
@@ -1328,9 +1330,11 @@ IvGL::wheelEvent(QWheelEvent* event)
     QPoint angdelta    = event->angleDelta() / 8;  // div by 8 to get degrees
     if (abs(angdelta.y()) > abs(angdelta.x())      // predominantly vertical
         && abs(angdelta.y()) > 2) {                // suppress tiny motions
-        float oldzoom = m_viewer.zoom();
-        float newzoom = (angdelta.y() > 0) ? ceil2f(oldzoom) : floor2f(oldzoom);
-        m_viewer.zoom(newzoom);
+        if (angdelta.y() > 0) {
+            m_viewer.zoomIn(false);
+        } else {
+            m_viewer.zoomOut(false);
+        }
         event->accept();
     }
     // TODO: Update this to keep the zoom centered on the event .x, .y
diff --git a/src/iv/ivmain.cpp b/src/iv/ivmain.cpp
@@ -167,8 +167,10 @@ main(int argc, char* argv[])
 
             std::vector<std::string> validImages;  // Vector to hold valid images
             for (auto& file : files) {
-                std::string extension = Filesystem::extension(file).substr(
-                    1);  // Remove the leading dot
+                std::string extension
+                    = Filesystem::extension(file,
+                                            false);  // Remove the leading dot
+                Strutil::to_lower(extension);
                 if (std::find(extensionsVector.begin(), extensionsVector.end(),
                               extension)
                     != extensionsVector.end()) {
diff --git a/src/libtexture/imagecache_pvt.h b/src/libtexture/imagecache_pvt.h
@@ -266,7 +266,7 @@ class OIIO_API ImageCacheFile final : public RefCnt {
     /// precompute.
     struct LevelInfo {
         std::unique_ptr<ImageSpec> m_spec;  ///< ImageSpec for the mip level,
-            // only specified if different from nativespec
+        // only specified if different from nativespec
         ImageSpec nativespec;  ///< Native ImageSpec for the mip level
         mutable std::unique_ptr<float[]> polecolor;  ///< Pole colors
         atomic_ll* tiles_read;  ///< Bitfield for tiles read at least once
@@ -394,10 +394,10 @@ class OIIO_API ImageCacheFile final : public RefCnt {
     std::atomic<std::shared_ptr<ImageInput>> m_input;
 #else
     std::shared_ptr<ImageInput> m_input;  ///< Open ImageInput, NULL if closed
-        // Note that m_input, the shared pointer itself, is NOT safe to
-        // access directly. ALWAYS retrieve its value with get_imageinput
-        // (it's thread-safe to use that result) and set its value with
-        // set_imageinput -- those are guaranteed thread-safe.
+    // Note that m_input, the shared pointer itself, is NOT safe to
+    // access directly. ALWAYS retrieve its value with get_imageinput
+    // (it's thread-safe to use that result) and set its value with
+    // set_imageinput -- those are guaranteed thread-safe.
 #endif
     std::vector<SubimageInfo> m_subimages;  ///< Info on each subimage
     TexFormat m_texformat;                  ///< Which texture format
diff --git a/src/python/py_imagebuf.cpp b/src/python/py_imagebuf.cpp
@@ -6,6 +6,7 @@
 
 #include <memory>
 
+#include <OpenImageIO/filesystem.h>
 #include <OpenImageIO/platform.h>
 
 
@@ -250,6 +251,35 @@ ImageBuf_set_write_format(ImageBuf& self, const py::object& py_channelformats)
 
 
 
+py::bytes
+ImageBuf_repr_png(const ImageBuf& self)
+{
+    ImageSpec original_spec = self.spec();
+
+    if (original_spec.width < 1 || original_spec.height < 1) {
+        return py::bytes();
+    }
+
+    // Alter the spec to make sure it dithers when outputting to 8 bit PNG
+    ImageSpec altered_spec = original_spec;
+    altered_spec.attribute("oiio:dither", 1);
+
+    std::vector<unsigned char> file_buffer;         // bytes will go here
+    Filesystem::IOVecOutput file_vec(file_buffer);  // I/O proxy object
+
+    std::unique_ptr<ImageOutput> out = ImageOutput::create("temp.png",
+                                                           &file_vec);
+    out->open("temp.png", altered_spec);
+    self.write(out.get());
+    out->close();
+
+    // Cast to const char* and return as python bytes
+    const char* char_ptr = reinterpret_cast<const char*>(file_buffer.data());
+    return py::bytes(char_ptr, file_buffer.size());
+}
+
+
+
 void
 declare_imagebuf(py::module& m)
 {
@@ -491,6 +521,7 @@ declare_imagebuf(py::module& m)
         .def(
             "deepdata", [](ImageBuf& self) { return *self.deepdata(); },
             py::return_value_policy::reference_internal)
+        .def("_repr_png_", &ImageBuf_repr_png)
 
         // FIXME -- do we want to provide pixel iterators?
         ;
diff --git a/testsuite/oiiotool-text/ref/unicode-freetype2.13.4.tif b/testsuite/oiiotool-text/ref/unicode-freetype2.13.4.tif
diff --git a/testsuite/python-imagebuf/ref/invalid_repr_png.png b/testsuite/python-imagebuf/ref/invalid_repr_png.png
diff --git a/testsuite/python-imagebuf/ref/valid_repr_png.png b/testsuite/python-imagebuf/ref/valid_repr_png.png
diff --git a/testsuite/python-imagebuf/run.py b/testsuite/python-imagebuf/run.py
@@ -12,5 +12,5 @@
 outputs = [ "out.tif", "outtuple.tif",
             "outarray.tif", "outarrayB.tif", "outarrayH.tif",
             "perchan.exr", "multipart.exr",
-            "out.txt" ]
+            "out.txt", "valid_repr_png.png", "invalid_repr_png.png" ]
 
diff --git a/testsuite/python-imagebuf/src/AllHalfValues.exr b/testsuite/python-imagebuf/src/AllHalfValues.exr
diff --git a/testsuite/python-imagebuf/src/test_imagebuf.py b/testsuite/python-imagebuf/src/test_imagebuf.py
@@ -59,6 +59,23 @@ def write (image, filename: str, format=oiio.UNKNOWN) :
 
 
 
+def test_repr_png () :
+    # Test a valid 16 bit exr
+    b = oiio.ImageBuf("src/AllHalfValues.exr")
+    png = b._repr_png_()
+
+    with open("valid_repr_png.png", "wb") as f:
+        f.write(png)
+
+    # Test an invalid image with null dimensions
+    # create ImageBuf with x dimension as 0
+    b = oiio.ImageBuf(oiio.ImageSpec(0,2,4,"float"))
+    png = b._repr_png_()
+    with open("invalid_repr_png.png", "wb") as f:
+        f.write(png)
+
+
+
 def test_perchannel_formats () :
     # Test writing per-channel formats with an ImageBuf
     b = oiio.ImageBuf(oiio.ImageSpec(2,2,4,"float"))
@@ -298,8 +315,8 @@ def test_copy_metadata() :
     test_multiimage ()
     test_uninitialized ()
     test_copy_metadata ()
+    test_repr_png ()
 
     print ("\nDone.")
 except Exception as detail:
     print ("Unknown exception:", detail)
-
diff --git a/testsuite/python-imageinput/ref/out-python3-win-2.txt b/testsuite/python-imageinput/ref/out-python3-win-2.txt

-Original file line number
+Diff line change
 /*.exr
 /*.tif
 /*.jpg
 +/*.png
 /*.jxl
 /*.tx
 /*.log