Refactor IBA::resample()

More cleanly separate the deep and non-deep cases.

Author: lgritz

src/libOpenImageIO/imagebufalgo_xform.cpp

@@ -501,12 +501,11 @@ static bool
 resample_ (ImageBuf &dst, const ImageBuf &src, bool interpolate,
            ROI roi, int nthreads)
 {
+    ASSERT (!src.deep() && !dst.deep());
     ImageBufAlgo::parallel_image (roi, nthreads, [&](ROI roi){
         const ImageSpec &srcspec (src.spec());
         const ImageSpec &dstspec (dst.spec());
         int nchannels = src.nchannels();
-        bool deep = src.deep();
-        ASSERT (deep == dst.deep());
 
         // Local copies of the source image window, converted to float
         float srcfx = srcspec.full_x;
@@ -535,21 +534,7 @@ resample_ (ImageBuf &dst, const ImageBuf &src, bool interpolate,
                 float s = (x-dstfx+0.5f)*dstpixelwidth;
                 float src_xf = srcfx + s * srcfw;
                 int src_x = ifloor (src_xf);
-                if (deep) {
-                    srcpel.pos (src_x, src_y, 0);
-                    int nsamps = srcpel.deep_samples();
-                    ASSERT (nsamps == out.deep_samples());
-                    if (! nsamps)
-                        continue;
-                    for (int c = 0; c < nchannels; ++c) {
-                        if (dstspec.channelformat(c) == TypeDesc::UINT32)
-                            for (int samp = 0; samp < nsamps; ++samp)
-                                out.set_deep_value (c, samp, srcpel.deep_value_uint(c, samp));
-                        else
-                            for (int samp = 0; samp < nsamps; ++samp)
-                                out.set_deep_value (c, samp, srcpel.deep_value(c, samp));
-                    }
-                } else if (interpolate) {
+                if (interpolate) {
                     // Non-deep image, bilinearly interpolate
                     src.interppixel (src_xf, src_yf, pel);
                     for (int c = roi.chbegin; c < roi.chend; ++c)
@@ -568,6 +553,75 @@ resample_ (ImageBuf &dst, const ImageBuf &src, bool interpolate,
 
 
 
+static bool
+resample_deep (ImageBuf &dst, const ImageBuf &src, bool interpolate,
+           ROI roi, int nthreads)
+{
+    ASSERT (src.deep() && dst.deep());
+
+    // If it's deep, figure out the sample allocations first, because
+    // it's not thread-safe to do that simultaneously with copying the
+    // values.
+    const ImageSpec &srcspec (src.spec());
+    const ImageSpec &dstspec (dst.spec());
+    float srcfx = srcspec.full_x;
+    float srcfy = srcspec.full_y;
+    float srcfw = srcspec.full_width;
+    float srcfh = srcspec.full_height;
+    float dstfx = dstspec.full_x;
+    float dstfy = dstspec.full_y;
+    float dstfw = dstspec.full_width;
+    float dstfh = dstspec.full_height;
+    float dstpixelwidth = 1.0f / dstfw;
+    float dstpixelheight = 1.0f / dstfh;
+    ImageBuf::ConstIterator<float> srcpel (src, roi);
+    ImageBuf::Iterator<float> dstpel (dst, roi);
+    for ( ;  !dstpel.done();  ++dstpel, ++srcpel) {
+        float s = (dstpel.x()-dstspec.full_x+0.5f)*dstpixelwidth;
+        float t = (dstpel.y()-dstspec.full_y+0.5f)*dstpixelheight;
+        int src_y = ifloor (srcfy + t * srcfh);
+        int src_x = ifloor (srcfx + s * srcfw);
+        srcpel.pos (src_x, src_y, 0);
+        dstpel.set_deep_samples (srcpel.deep_samples ());
+    }
+
+    ImageBufAlgo::parallel_image (roi, nthreads, [=,&dst,&src](ROI roi){
+        int nchannels = src.nchannels();
+        const ImageSpec &dstspec (dst.spec());
+        ImageBuf::Iterator<float> out (dst, roi);
+        ImageBuf::ConstIterator<float> srcpel (src);
+        for (int y = roi.ybegin;  y < roi.yend;  ++y) {
+            // s,t are NDC space
+            float t = (y-dstfy+0.5f)*dstpixelheight;
+            // src_xf, src_xf are image space float coordinates
+            float src_yf = srcfy + t * srcfh;
+            // src_x, src_y are image space integer coordinates of the floor
+            int src_y = ifloor (src_yf);
+            for (int x = roi.xbegin;  x < roi.xend;  ++x, ++out) {
+                float s = (x-dstfx+0.5f)*dstpixelwidth;
+                float src_xf = srcfx + s * srcfw;
+                int src_x = ifloor (src_xf);
+                srcpel.pos (src_x, src_y, 0);
+                int nsamps = srcpel.deep_samples();
+                ASSERT (nsamps == out.deep_samples());
+                if (! nsamps)
+                    continue;
+                for (int c = 0; c < nchannels; ++c) {
+                    if (dstspec.channelformat(c) == TypeDesc::UINT32)
+                        for (int samp = 0; samp < nsamps; ++samp)
+                            out.set_deep_value (c, samp, srcpel.deep_value_uint(c, samp));
+                    else
+                        for (int samp = 0; samp < nsamps; ++samp)
+                            out.set_deep_value (c, samp, srcpel.deep_value(c, samp));
+                }
+            }
+        }
+    });
+    return true;
+}
+
+
+
 bool
 ImageBufAlgo::resample (ImageBuf &dst, const ImageBuf &src,
                         bool interpolate, ROI roi, int nthreads)
@@ -579,27 +633,7 @@ ImageBufAlgo::resample (ImageBuf &dst, const ImageBuf &src,
         return false;
 
     if (dst.deep()) {
-        // If it's deep, figure out the sample allocations first, because
-        // it's not thread-safe to do that simultaneously with copying the
-        // values.
-        const ImageSpec &srcspec (src.spec());
-        const ImageSpec &dstspec (dst.spec());
-        float srcfx = srcspec.full_x;
-        float srcfy = srcspec.full_y;
-        float srcfw = srcspec.full_width;
-        float srcfh = srcspec.full_height;
-        float dstpixelwidth = 1.0f / dstspec.full_width;
-        float dstpixelheight = 1.0f / dstspec.full_height;
-        ImageBuf::ConstIterator<float> srcpel (src, roi);
-        ImageBuf::Iterator<float> dstpel (dst, roi);
-        for ( ;  !dstpel.done();  ++dstpel, ++srcpel) {
-            float s = (dstpel.x()-dstspec.full_x+0.5f)*dstpixelwidth;
-            float t = (dstpel.y()-dstspec.full_y+0.5f)*dstpixelheight;
-            int src_y = ifloor (srcfy + t * srcfh);
-            int src_x = ifloor (srcfx + s * srcfw);
-            srcpel.pos (src_x, src_y, 0);
-            dstpel.set_deep_samples (srcpel.deep_samples ());
-        }
+        return resample_deep (dst, src, interpolate, roi, nthreads);
     }
 
     bool ok;