Fixed misinterpretation of dtex samples in deepopacity case, updated README, comments, and ChangeLog to reflect fix.

Author: blackencino

Contrib/DtexToExr/ChangeLog

@@ -1,4 +1,13 @@
 Version 1.0.0:
 	* Initial release of this code.
 
+Version 1.0.1:
+	* Fixed misinterpretation of values read from "deepopacity" dtex files.
+	The data stored is actually transmission, or 1.0-opacity, which means
+	that "deepopacity" dtex values actually monotonically decrease from 1
+	to 0.  We have updated the comments and documentation to reflect this
+	and have fixed the PxOneChanDeepOpacity file to convert the data 
+	as it is read out of the file.
+	
+
 

Contrib/DtexToExr/PxDeepUtils.h

@@ -168,13 +168,15 @@ namespace PxDeep {
 // DEEP OPACITY
 //-*****************************************************************************
 // "Deep Opacity" refers to a depth function in which the sample at each point
-// represents the total accumulated alpha at that depth. This represents the
-// way that deep shadows would have been produced by renderman with the
-// Display Driver Line: "deepshad" "deepopacity". It is important to note
+// represents the total accumulated opacity at that depth. This represents
+// the way that deep shadows would have been produced by renderman with the
+// Display Driver Line: "deepshad" "deepopacity", except that the files actually
+// store the inverse (1.0-opacity) at each point. It is important to note
 // that for any given Dtex deepopacity sample, the value represents the
-// accumulation of alpha on the NEAR side of the sample - up to and including
-// the sample's depth, but no further in depth. Deep Opacity functions are
-// monotonically increasing in depth, and are always between 0 and 1.
+// accumulation of visibility on the NEAR side of the sample - up to and
+// including the sample's depth, but no further in depth. Deep Opacity
+// functions are monotonically decreasing in depth, and are always
+// between 0 and 1.
 //
 // A complication arises when the 0'th continuous deep opacity sample has a
 // non-zero deep opacity, because we don't have enough information to infer

Contrib/DtexToExr/PxOneChanDeepOpacity.h

@@ -138,13 +138,16 @@ void OneChanDeepOpacityContinuous<RGBA_T>::processDeepPixel( int i_numPts )
 
         z = ClampDepth( z );
 
-        double deepOpac = ClampAlpha( pts[0] );
-
         span_type& spanJ = (this->m_spans)[j];
         spanJ.clear();
         spanJ.in = z;
         spanJ.out = z;
-        spanJ.deepViz = ClampViz( 1.0 - deepOpac );
+        
+        // Data stored in dtex files for "deepopacity" is actually
+        // "deeptransmission", monotonically decreasing from an initial
+        // value of 1.0. We just convert it to viz directly.
+        // (viz == transmissivity)
+        spanJ.deepViz = ClampViz( pts[0] );
         spanJ.index = j;
     }
 
@@ -191,9 +194,10 @@ void OneChanDeepOpacityContinuous<RGBA_T>::processDeepPixel( int i_numPts )
                 {
                     // This span has an identical depth to
                     // the previous one, so we use whichever one has the
-                    // largest deep opacity.
+                    // largest deep opacity, which equates to the
+                    // smallest deep viz.
                     spanActiveBegin.deepViz =
-                        std::max( spanActiveBegin.deepViz,
+                        std::min( spanActiveBegin.deepViz,
                                   spanNext.deepViz );
                     spanNext.in = FLT_MAX;
                     spanNext.out = FLT_MAX;
@@ -349,13 +353,16 @@ void OneChanDeepOpacityDiscrete<RGBA_T>::processDeepPixel( int i_numPts )
 
         z = ClampDepth( z );
 
-        double deepOpac = ClampAlpha( pts[0] );
-
         span_type& spanJ = (this->m_spans)[j];
         spanJ.clear();
         spanJ.in = z;
         spanJ.out = z;
-        spanJ.deepViz = ClampViz( 1.0 - deepOpac );
+
+        // Data stored in dtex files for "deepopacity" is actually
+        // "deeptransmission", monotonically decreasing from an initial
+        // value of 1.0. We just convert it to viz directly.
+        // (viz == transmissivity)
+        spanJ.deepViz = ClampViz( pts[0] );
         spanJ.index = j;
     }
 
@@ -400,9 +407,10 @@ void OneChanDeepOpacityDiscrete<RGBA_T>::processDeepPixel( int i_numPts )
                 {
                     // This span has an identical depth to
                     // the previous one, so we use whichever one has the
-                    // largest deep opacity.
+                    // largest deep opacity, which equates to the
+                    // smallest deep viz.
                     spanActiveBegin.deepViz =
-                        std::max( spanActiveBegin.deepViz,
+                        std::min( spanActiveBegin.deepViz,
                                   spanNext.deepViz );
                     spanNext.in = FLT_MAX;
                     spanNext.out = FLT_MAX;

Contrib/DtexToExr/README

@@ -53,17 +53,18 @@ out-of-order samples, precision issues, compression artifacts, and the
 differences between the "deepopacity" vs "deepalpha" interpretations.
 
 With "deepopacity" (the pre-prman 16 usage), opacity values stored in
-dtex files were accumulated, so they were bounded between 0 and 1, and
-monotonically increased from fully transparent to fully opaque. This
-representation is ideal for meaningful error minimization during 
-compression, and also for usage as a shadow map by a renderer, because
-the extinction at a particular depth, at a particular pixel, can be 
-evaluated with a single look-up. However, this representation is 
-poor for deep compositing, because each of the samples includes 
-data from smaller depth samples, and recombination is difficult. With
-these types of files, when using volumetric (continuous) interpretation,
-the samples represent the accumulated alpha at the NEAR SIDE of a
-depth span, and our code paths take this into account.
+dtex files were accumulated, so they were bounded between 0 and 1. The
+values stored are actually not opacities, but rather transmissivities
+(1-opacity), and monotonically decreased from fully transparent (1)
+to fully opaque (0). This representation is ideal for meaningful error 
+minimization during  compression, and also for usage as a shadow map 
+by a renderer, because the extinction at a particular depth, at a 
+particular pixel, can be evaluated with a single look-up. However, 
+this representation is poor for deep compositing, because each of the 
+samples includes data from smaller depth samples, and recombination is 
+difficult. With these types of files, when using volumetric (continuous) 
+interpretation, the samples represent the accumulated transmissivity at 
+the NEAR SIDE of a depth span, and our code paths take this into account.
 
 With all other usages - "a" and "rgba", the values represent filtered
 samples of the given field at that point in space. The alpha values