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

Author: scott-wilson

CMakeLists.txt

@@ -170,6 +170,11 @@ message(STATUS "Joint namespace PROJ_NAMESPACE_V:       ${PROJ_NAMESPACE_V}")
 # defined for downstream projects using OIIO.
 add_compile_definitions (OIIO_INTERNAL=1)
 
+# If CMake variable OIIO_SITE is set, set compile symbol OIIO_SITE_sitename
+if (OIIO_SITE)
+    add_compile_definitions (OIIO_SITE_${OIIO_SITE})
+endif ()
+
 include (GNUInstallDirs)
 
 # Utilities for build instructions of the format-reading plugins
@@ -253,13 +258,6 @@ set (format_plugin_libs "")
 set (format_plugin_include_dirs "")
 set (format_plugin_definitions "")
 file (GLOB all_format_plugin_dirs src/*.imageio)
-if ("${OIIO_SITE}" STREQUAL "SPI")
-    # SPI only -- because of a workaround for a very weird linkage issue
-    # specific to our system, we need to be sure libtiff is referenced first.
-    file (GLOB tiff_format_plugin_dir src/tiff.imageio)
-    list (REMOVE_ITEM all_format_plugin_dirs ${tiff_format_plugin_dir})
-    list (INSERT all_format_plugin_dirs 0 ${tiff_format_plugin_dir})
-endif ()
 if (EMBEDPLUGINS AND NOT BUILD_OIIOUTIL_ONLY)
     foreach (plugin_dir ${all_format_plugin_dirs})
         add_subdirectory (${plugin_dir})

src/doc/imageioapi.rst

@@ -95,8 +95,8 @@ Efficient unique strings: ``ustring``
 
 .. _sec-span:
 
-Non-owning array views: ``span`` / ``cspan``
-============================================
+Non-owning contiguous array views: ``span`` / ``cspan``
+=======================================================
 
 .. doxygenclass:: OIIO::span
     :members:
@@ -111,6 +111,18 @@ Additionally, there is a convenience template:
 |
 
 
+.. _sec-span:
+
+Non-owning image array views: ``image_span``
+============================================
+
+.. doxygenclass:: OIIO::image_span
+    :members:
+
+
+|
+
+
 
  .. _sec-ROI:
 

src/include/OpenImageIO/fmath.h

@@ -757,7 +757,7 @@ scaled_conversion(const S& src, F scale, F min, F max)
 template<typename S, typename D>
 void convert_type (const S *src, D *dst, size_t n, D _min, D _max)
 {
-    if (std::is_same<S,D>::value) {
+    if constexpr (std::is_same<S,D>::value) {
         // They must be the same type.  Just memcpy.
         memcpy (dst, src, n*sizeof(D));
         return;
@@ -968,6 +968,25 @@ inline void convert_type (const S *src, D *dst, size_t n)
 
 
 
+/// Copy (type convert) consecutive values from the cspan `src` holding data
+/// of type S into the span `dst` holding the same number of elements of data
+/// of type D.
+///
+/// The conversion is not a simple cast, but correctly remaps the 0.0->1.0
+/// range from and to the full positive range of integral types. It's just a
+/// straight copy if both types are identical. Optional arguments `min` and
+/// `max` can give nonstandard quantizations.
+template<typename S, typename D>
+void convert_type (cspan<S> src, span<D> dst,
+                   D min = std::numeric_limits<D>::min(),
+                   D max = std::numeric_limits<D>::min())
+{
+    OIIO_DASSERT(src.size() == dst.size());
+    convert_type(src.data(), dst.data(), std::min(src.size(), dst.size()),
+                 min, max);
+}
+
+
 
 /// Convert a single value from the type of S to the type of D.
 /// The conversion is not a simple cast, but correctly remaps the
@@ -978,7 +997,7 @@ template<typename S, typename D>
 inline D
 convert_type (const S &src)
 {
-    if (std::is_same<S,D>::value) {
+    if constexpr (std::is_same<S,D>::value) {
         // They must be the same type.  Just return it.
         return (D)src;
     }