BoxVectorData : Add buffer protocol support

Author: ericmehl

Changes

@@ -1,7 +1,10 @@
 10.6.x.x (relative to 10.6.2.1)
 ========
 
+API
+---
 
+- IECorePython : Added `Buffer` object and associated `asReadOnlyBuffer()` and `asReadWriteBuffer()` methods for numeric-based `*VectorData` types. This adds support for Python's buffer protocol which allows direct access to the vector.
 
 10.6.2.1 (relative to 10.6.2.0)
 ========

src/IECorePython/ImathBoxVectorBinding.cpp

@@ -48,14 +48,22 @@ IECOREPYTHON_DEFINEVECTORDATASTRSPECIALISATION( Box3i )
 IECOREPYTHON_DEFINEVECTORDATASTRSPECIALISATION( Box3f )
 IECOREPYTHON_DEFINEVECTORDATASTRSPECIALISATION( Box3d )
 
+#define BIND_BOX_VECTOR_TYPEDDATA(T, Tname)		\
+		{										\
+			BASIC_VECTOR_BINDING(IECore::TypedData< std::vector< T > >, Tname)																	\
+				.def("__cmp__", &ThisBinder::invalidOperator, "Raises an exception. This vector type does not support comparison operators.")	\
+				BIND_BUFFER_PROTOCOL_METHODS	\
+			;	\
+		}
+
 void bindImathBoxVectorTypedData()
 {
-	BIND_VECTOR_TYPEDDATA ( Box< V2i >, "Box2i")
-	BIND_VECTOR_TYPEDDATA ( Box< V2f >, "Box2f")
-	BIND_VECTOR_TYPEDDATA ( Box< V2d >, "Box2d")
-	BIND_VECTOR_TYPEDDATA ( Box< V3i >, "Box3i")
-	BIND_VECTOR_TYPEDDATA ( Box< V3f >, "Box3f")
-	BIND_VECTOR_TYPEDDATA ( Box< V3d >, "Box3d")
+	BIND_BOX_VECTOR_TYPEDDATA ( Box< V2i >, "Box2i")
+	BIND_BOX_VECTOR_TYPEDDATA ( Box< V2f >, "Box2f")
+	BIND_BOX_VECTOR_TYPEDDATA ( Box< V2d >, "Box2d")
+	BIND_BOX_VECTOR_TYPEDDATA ( Box< V3i >, "Box3i")
+	BIND_BOX_VECTOR_TYPEDDATA ( Box< V3f >, "Box3f")
+	BIND_BOX_VECTOR_TYPEDDATA ( Box< V3d >, "Box3d")
 }
 
 } // namespace IECorePython

src/IECorePython/VectorTypedDataBinding.cpp

@@ -102,6 +102,11 @@ constexpr std::pair<const char *, Py_ssize_t> typeInfo()
 	{
 		return { PythonType<typename T::BaseType>::value(), sizeof( T::BaseType ) };
 	}
+	else if constexpr( IECore::TypeTraits::IsBox<T>::value )
+	{
+		using ElementType = decltype( T::min );
+		return { PythonType<typename ElementType::BaseType>::value(), sizeof( ElementType::BaseType ) };
+	}
 	else
 	{
 		return { PythonType<T>::value(), sizeof( T ) };
@@ -293,6 +298,19 @@ int Buffer::getBuffer( PyObject *object, Py_buffer *view, int flags )
 							strides = new Py_ssize_t[2]{ ElementType::dimensions() * itemSize, itemSize };
 						}
 					}
+					else if constexpr( IECore::TypeTraits::IsBox<ElementType>::value )
+					{
+						ndim = 3;
+						using ElementType = decltype( ElementType::min );
+						if( ( flags & PyBUF_ND ) == PyBUF_ND )
+						{
+							shape = new Py_ssize_t[3]{ (Py_ssize_t)bufferData->readable().size(), 2, ElementType::dimensions() };
+						}
+						if( ( flags & PyBUF_STRIDES ) == PyBUF_STRIDES )
+						{
+							strides = new Py_ssize_t[3]{ 2 * ElementType::dimensions() * itemSize, ElementType::dimensions() * itemSize, itemSize };
+						}
+					}
 					else
 					{
 						shape = new Py_ssize_t{ (Py_ssize_t)bufferData->readable().size() };

test/IECore/VectorData.py

@@ -1498,6 +1498,46 @@ def testTwoDimensionalBuffers( self ) :
 
 				self.__assertMemoryBufferProperties( m, b, elementFormat, 2, ( len( v ), dimensions ), ( dimensions * m.itemsize, m.itemsize ) )
 
+	def testBoxTypes( self ) :
+
+		for elementType, vectorType, elementFormat, componentType in [
+			( imath.Box2i, IECore.Box2iVectorData, "i", imath.V2i ),
+			( imath.Box2f, IECore.Box2fVectorData, "f", imath.V2f ),
+			( imath.Box2d, IECore.Box2dVectorData, "d", imath.V2d ),
+			( imath.Box3i, IECore.Box3iVectorData, "i", imath.V3i ),
+			( imath.Box3f, IECore.Box3fVectorData, "f", imath.V3f ),
+			( imath.Box3d, IECore.Box3dVectorData, "d", imath.V3d )
+		] :
+			with self.subTest( elementType = elementType, vectorType = vectorType ) :
+				v = vectorType(
+					[
+						elementType(
+							componentType( *list( range( i, i + componentType.dimensions() ) ) ),
+							componentType( *list( range( i + 10, i + 10 + componentType.dimensions() ) ) )
+						) for i in range( 0, 3 )
+					]
+				)
+
+				b = v.asReadOnlyBuffer()
+				m = memoryview( b )
+
+				self.assertIsNotNone( m )
+				for i in range( 0, len( v ) ) :
+					for j in range( 0, 2 ) :
+						for k in range( 0, componentType.dimensions() ) :
+							if j == 0 :
+								self.assertEqual( m.tolist()[i][j][k], v[i].min()[k] )
+							else :
+								self.assertEqual( m.tolist()[i][j][k], v[i].max()[k] )
+
+				self.__assertMemoryBufferProperties(
+					m,
+					b,
+					elementFormat,
+					3,
+					( len( v ), 2, componentType.dimensions() ),
+					( 2 * componentType.dimensions() * m.itemsize, componentType.dimensions() * m.itemsize, m.itemsize )
+				)
 
 	def testReadOnlyBuffer( self ) :