Merge pull request #287 from danieldresser/shwPerpendicular

Added conversions to SHW reader and writer

Author: andrewkaufman

include/IECore/DeepPixel.h

@@ -46,6 +46,7 @@ namespace IECore
 IE_CORE_FORWARDDECLARE( DeepPixel )
 
 /// A DeepPixel represents arbitrary channel data stored at varying depths in space.
+/// By convention, depth is measured as distance from the eye plane
 /// \ingroup deepCompositingGroup
 class DeepPixel : public RefCounted
 {

include/IECoreRI/SHWDeepImageReader.h

@@ -89,6 +89,7 @@ class SHWDeepImageReader : public IECore::DeepImageReader
 		Imath::Box2i m_dataWindow;
 		Imath::M44f m_worldToCamera;
 		Imath::M44f m_worldToNDC;
+		Imath::M44f &m_NDCToCamera();
 		std::string m_inputFileName;
 		std::string m_channelNames;
 

include/IECoreRI/SHWDeepImageWriter.h

@@ -79,7 +79,8 @@ class SHWDeepImageWriter : public IECore::DeepImageWriter
 		DtexCache *m_dtexCache;
 		DtexImage *m_dtexImage;
 		DtexPixel *m_dtexPixel;
-		
+
+		Imath::M44f &m_NDCToCamera();
 		std::string m_outputFileName;
 		int m_alphaOffset;
 

src/IECoreRI/SHWDeepImageReader.cpp

@@ -43,6 +43,16 @@
 using namespace IECore;
 using namespace IECoreRI;
 
+#include "IECore/ClassData.h"
+
+static IECore::ClassData< SHWDeepImageReader, Imath::M44f > g_ndcClassData;
+
+Imath::M44f &SHWDeepImageReader::m_NDCToCamera()
+{
+	return g_ndcClassData[ this ];
+}
+
+
 IE_CORE_DEFINERUNTIMETYPED( SHWDeepImageReader );
 
 const Reader::ReaderDescription<SHWDeepImageReader> SHWDeepImageReader::g_readerDescription( "shw" );
@@ -52,6 +62,7 @@ SHWDeepImageReader::SHWDeepImageReader()
 		m_inputFile( 0 ), m_dtexCache( 0 ), m_dtexImage( 0 ), m_dtexPixel( 0 ),
 		m_dataWindow( Imath::V2i( 0 ), Imath::V2i( 0 ) )
 {
+	g_ndcClassData.create( this, Imath::M44f() );
 }
 
 SHWDeepImageReader::SHWDeepImageReader( const std::string &fileName )
@@ -60,11 +71,13 @@ SHWDeepImageReader::SHWDeepImageReader( const std::string &fileName )
 		m_dataWindow( Imath::V2i( 0 ), Imath::V2i( 0 ) )
 {
 	m_fileNameParameter->setTypedValue( fileName );
+	g_ndcClassData.create( this, Imath::M44f() );
 }
 
 SHWDeepImageReader::~SHWDeepImageReader()
 {
 	clean();
+	g_ndcClassData.erase( this );
 }
 
 bool SHWDeepImageReader::canRead( const std::string &fileName )
@@ -153,10 +166,22 @@ DeepPixelPtr SHWDeepImageReader::doReadPixel( int x, int y )
 	{
 		previous[j] = 0.0;
 	}
-	
+
+	float nearClip = m_NDCToCamera()[3][2] / m_NDCToCamera()[3][3];
+	float correction = 1;
+	if( m_NDCToCamera()[3][2] != 0 && m_NDCToCamera()[2][3] != 0 )
+	{
+		// Compute a correction factor that converts from spherical distance to perpendicular distance,
+		// by comparing the closest distance to the near clip with the distance to the near clip at the current pixel position
+		correction = nearClip / ( Imath::V3f(((x+0.5f)/(m_dataWindow.max.x+1) * 2 - 1), -((y+0.5)/(m_dataWindow.max.y+1) * 2 - 1),0) * m_NDCToCamera() ).length();
+	}
+
 	for ( int i=0; i < numSamples; ++i )
 	{
 		DtexPixelGetPoint( m_dtexPixel, i, &depth, channelData );
+
+		// Convert from "3delight distance" ( spherical distance from near clip ) to Z ( distance from eye plane )
+		depth = depth * correction + nearClip;
 
 		for ( unsigned j=0; j < numRealChannels; ++j )
 		{
@@ -190,6 +215,7 @@ bool SHWDeepImageReader::open( bool throwOnFailure )
 	m_dataWindow.max.y = 0;
 	m_worldToCamera = Imath::M44f();
 	m_worldToNDC = Imath::M44f();
+	m_NDCToCamera() = Imath::M44f();
 
 	clean();
 
@@ -214,6 +240,7 @@ bool SHWDeepImageReader::open( bool throwOnFailure )
 
 		DtexNl( m_dtexImage, m_worldToCamera.getValue() );
 		DtexNP( m_dtexImage, m_worldToNDC.getValue() );
+		m_NDCToCamera() = m_worldToNDC.inverse() * m_worldToCamera;
 	}
 	else
 	{

src/IECoreRI/SHWDeepImageWriter.cpp

@@ -43,6 +43,16 @@
 using namespace IECore;
 using namespace IECoreRI;
 
+#include "IECore/ClassData.h"
+
+static IECore::ClassData< SHWDeepImageWriter, Imath::M44f > g_ndcClassData;
+
+Imath::M44f &SHWDeepImageWriter::m_NDCToCamera()
+{
+	return g_ndcClassData[ this ];
+}
+
+
 IE_CORE_DEFINERUNTIMETYPED( SHWDeepImageWriter );
 
 const DeepImageWriter::DeepImageWriterDescription<SHWDeepImageWriter> SHWDeepImageWriter::g_writerDescription( "shw" );
@@ -56,6 +66,9 @@ SHWDeepImageWriter::SHWDeepImageWriter()
 
 	m_tileSizeParameter = new V2iParameter( "tileSize", "The tile size for the image cache. Must be equal or less than resolution.", new V2iData( Imath::V2i( 32, 32 ) ) );
 	parameters()->addParameter( m_tileSizeParameter );
+
+	g_ndcClassData.create( this, Imath::M44f() );
+
 }
 
 SHWDeepImageWriter::SHWDeepImageWriter( const std::string &fileName )
@@ -69,11 +82,15 @@ SHWDeepImageWriter::SHWDeepImageWriter( const std::string &fileName )
 
 	m_tileSizeParameter = new V2iParameter( "tileSize", "The tile size for the image cache. Must be equal or less than resolution.", new V2iData( Imath::V2i( 32, 32 ) ) );
 	parameters()->addParameter( m_tileSizeParameter );
+
+	g_ndcClassData.create( this, Imath::M44f() );
 }
 
 SHWDeepImageWriter::~SHWDeepImageWriter()
 {
 	clean();
+	g_ndcClassData.erase( this );
+
 }
 
 bool SHWDeepImageWriter::canWrite( const std::string &fileName )
@@ -108,6 +125,17 @@ void SHWDeepImageWriter::doWritePixel( int x, int y, const DeepPixel *pixel )
 
 	float previous = 0.0;
 	unsigned numSamples = pixel->numSamples();
+
+	const Imath::V2i &resolution = m_resolutionParameter->getTypedValue();
+	float nearClip = m_NDCToCamera()[3][2] / m_NDCToCamera()[3][3];
+	float correction = 1;
+	if( m_NDCToCamera()[3][2] != 0 && m_NDCToCamera()[2][3] != 0 )
+	{
+		// Compute a correction factor that converts from perpendicular distance to spherical distance,
+		// by comparing the closest distance to the near clip with the distance to the near clip at the current pixel position
+		correction = ( Imath::V3f(((x+0.5f)/resolution.x * 2 - 1), -((y+0.5)/resolution.y * 2 - 1),0) * m_NDCToCamera() ).length() / nearClip;
+	}
+
 	for ( unsigned i=0; i < numSamples; ++i )
 	{
 		// SHW files require composited values, accumulated over depth, but we have uncomposited values
@@ -124,8 +152,13 @@ void SHWDeepImageWriter::doWritePixel( int x, int y, const DeepPixel *pixel )
 		{
 			adjustedData[c] = value;
 		}
-		
-		DtexAppendPixel( m_dtexPixel, pixel->getDepth( i ), numChannels, adjustedData, 0 );
+	
+		float depth = pixel->getDepth( i );	
+
+		// Convert from Z ( distance from eye plane ) to "3delight distance" ( spherical distance from near clip )
+		depth = ( depth - nearClip ) * correction;
+
+		DtexAppendPixel( m_dtexPixel, depth, numChannels, adjustedData, 0 );
 	}
 
 	DtexFinishPixel( m_dtexPixel );
@@ -183,13 +216,16 @@ void SHWDeepImageWriter::open()
 
 	float *NL = worldToCameraParameter()->getTypedValue().getValue();
 	float *NP = worldToNDCParameter()->getTypedValue().getValue();
+
+	m_NDCToCamera() = worldToNDCParameter()->getTypedValue().inverse() * worldToCameraParameter()->getTypedValue();
 
 	/// \todo: does image name mean anything for this format?
 	int status = DtexAddImage(
 		m_outputFile, "", numChannels,
 		resolution.x, resolution.y, tileSize.x, tileSize.y,
 		NP, NL, DTEX_COMPRESSION_NONE, DTEX_TYPE_FLOAT, &m_dtexImage
 	);
+
 
 	if ( status != DTEX_NOERR )
 	{
@@ -198,7 +234,7 @@ void SHWDeepImageWriter::open()
 		clean();
 		throw IOException( std::string( "Failed to create the main sub-image in \"" ) + fileName() + "\" for writing." );
 	}
-	
+
 	m_dtexPixel = DtexMakePixel( numChannels );
 }
 

test/IECoreRI/SHWDeepImageReaderTest.py

@@ -40,6 +40,10 @@
 class TestSHWDeepImageReader( unittest.TestCase ) :
 
 	__shw = "test/IECoreRI/data/shw/translucentBoxes.shw"
+	__shwConstantPlane = "test/IECoreRI/data/shw/constantPlane.shw"
+	__shwConstantPlane2 = "test/IECoreRI/data/shw/constantPlane2.shw"
+	__shwOrtho = "test/IECoreRI/data/shw/constantPlaneOrtho.shw"
+
 	__exr = "test/IECoreRI/data/shw/groundPlane.exr"
 
 	def testConstructor( self ) :
@@ -113,16 +117,16 @@ def testReadPixel( self ) :
 		p = reader.readPixel( 100, 100 )
 		self.assertEqual( p.channelNames(), ( "A", ) )
 		self.assertEqual( p.numSamples(), 1 )
-		self.assertAlmostEqual( p.getDepth( 0 ), 107.5978927, 6 )
+		self.assertAlmostEqual( p.getDepth( 0 ), 102.17636108, 6 )
 		self.assertAlmostEqual( p[0][0], 1.0, 6 )
 
 		# hits one box then ground plane
 		p2 = reader.readPixel( 256, 256 )
 		self.assertEqual( p2.channelNames(), tuple(reader.channelNames()) )
 		self.assertEqual( p2.numSamples(), 3 )
-		self.assertAlmostEqual( p2.getDepth( 0 ), 71.7940826, 6 )
-		self.assertAlmostEqual( p2.getDepth( 1 ), 76.9240646, 6 )
-		self.assertAlmostEqual( p2.getDepth( 2 ), 84.8475646, 6 )
+		self.assertAlmostEqual( p2.getDepth( 0 ), 72.6087493, 6 )
+		self.assertAlmostEqual( p2.getDepth( 1 ), 77.7387313, 6 )
+		self.assertAlmostEqual( p2.getDepth( 2 ), 85.6622314, 6 )
 
 		expected = ( 0.5, 0.5, 1.0 )
 		for i in range( 0, len(expected) ) :
@@ -132,11 +136,11 @@ def testReadPixel( self ) :
 		p3 = reader.readPixel( 195, 225 )
 		self.assertEqual( p3.channelNames(), tuple(reader.channelNames()) )
 		self.assertEqual( p3.numSamples(), 5 )
-		self.assertAlmostEqual( p3.getDepth( 0 ), 68.2118148, 6 )
-		self.assertAlmostEqual( p3.getDepth( 1 ), 74.9367370, 6 )
-		self.assertAlmostEqual( p3.getDepth( 2 ), 77.0554046, 6 )
-		self.assertAlmostEqual( p3.getDepth( 3 ), 79.7311859, 6 )
-		self.assertAlmostEqual( p3.getDepth( 4 ), 88.5616073, 6 )
+		self.assertAlmostEqual( p3.getDepth( 0 ), 68.6177368, 6 )
+		self.assertAlmostEqual( p3.getDepth( 1 ), 75.3023605, 6 )
+		self.assertAlmostEqual( p3.getDepth( 2 ), 77.4083328, 6 )
+		self.assertAlmostEqual( p3.getDepth( 3 ), 80.0680771, 6 )
+		self.assertAlmostEqual( p3.getDepth( 4 ), 88.8455811, 6 )
 
 		expected = ( 0.5, 0.75, 0.5, 0.5, 1.0 )
 		for i in range( 0, len(expected) ) :
@@ -170,5 +174,31 @@ def testComposite( self ) :
 			for i in range( imageData.size() ) :
 				self.assertAlmostEqual( imageData[i], realImageData[i], 6 )
 
+	def __testDepthConversionWithFile( self, filename, tolerance ) :
+
+		reader = IECore.DeepImageReader.create( filename )
+		dataWindow = reader.dataWindow()
+
+		for y in range( dataWindow.min.y, dataWindow.max.y + 1 ) :
+			for x in range( dataWindow.min.x, dataWindow.max.x + 1 ) :
+				p = reader.readPixel( x, y )
+				s = p.numSamples()
+				avgDepth = 0
+				for i in range( s ):
+					avgDepth += p.getDepth( i ) / s
+				self.assertAlmostEqual( avgDepth, 10, tolerance )
+
+	def testDepthConversion( self ) :
+
+		# The first constant plane test is rendered with a single sample, and no jittering, so the depth should match to 6 significant digits
+		self.__testDepthConversionWithFile( TestSHWDeepImageReader.__shwConstantPlane, 4 )
+
+		# The second constant plane was rendered with a small number of jittered samples, and because of the low resolution, there is quite a bit
+		# of variation in the correction factor across the pixel, so it won't be a perfect match, but it should still be close
+		self.__testDepthConversionWithFile( TestSHWDeepImageReader.__shwConstantPlane2, 2 )
+
+		# Test out an ortho render as well
+		self.__testDepthConversionWithFile( TestSHWDeepImageReader.__shwOrtho, 2 )
+
 if __name__ == "__main__":
     unittest.main()