예제 #1
0
typename TypedData< std::vector< U > >::Ptr vectorLookup( Lookup<T,U> &lookup, typename TypedData< std::vector< T > >::Ptr x )
{
	typename TypedData< std::vector< U > >::Ptr res = new TypedData< std::vector< U > >;
	res->writable().resize( x->readable().size() );
	typename std::vector< T >::const_iterator xIt = x->readable().begin();
	typename std::vector< U >::iterator yIt = res->writable().begin();

	for ( ; xIt != x->readable().end(); xIt++, yIt++ )
	{
		*yIt = lookup( *xIt );
	}
	return res;
}
void ToMayaImageConverter::writeChannel( MImage &image, typename TypedData< std::vector<T> >::Ptr channelData, unsigned channelOffset, unsigned numChannels ) const
{
	assert( channelOffset < numChannels );

	ConstImagePrimitivePtr toConvert = runTimeCast<const ImagePrimitive>( srcParameter()->getValidatedValue() );
	assert( toConvert );

	unsigned width, height;
	image.getSize( width, height );

	const Imath::Box2i &dataWindow = toConvert->getDataWindow();
	const Imath::Box2i &displayWindow = toConvert->getDisplayWindow();

	unsigned int dataWidth = dataWindow.size().x + 1;
	unsigned int dataHeight = dataWindow.size().y + 1;

	Imath::V2i dataOffset = dataWindow.min - displayWindow.min ;

	boost::multi_array_ref< const T, 2 > src( &channelData->readable()[0], boost::extents[dataHeight][dataWidth] );
	boost::multi_array_ref< T, 3 > dst( MImageAccessor<T>::getPixels( image ), boost::extents[ height ][ width ][ numChannels ] );

	for ( unsigned x = 0; x < dataWidth; x++ )
	{
		for ( unsigned y = 0; y < dataHeight; y++ )
		{
			/// Vertical flip, to match Maya
			dst[ ( height - 1 ) - ( y + dataOffset.y ) ][ x + dataOffset.x ][channelOffset] = src[y][x];
		}
	}
}
예제 #3
0
static void triangulate( T &t, typename TypedData<std::vector<typename T::Point> >::ConstPtr p )
{
	t.triangulate( p->readable().begin(), p->readable().end() );
}
예제 #4
0
DataPtr SGIImageReader::readTypedChannel( const std::string &name, const Box2i &dataWindow )
{
	typedef TypedData< std::vector< V > > TargetVector;

	assert( open() );

	assert( m_header );

	typename TypedData< std::vector<T > >::ConstPtr dataBuffer = assertedStaticCast< TypedData< std::vector<T > > >( m_buffer );
	assert( dataBuffer );

	const typename TypedData< std::vector<T > >::ValueType &buffer = dataBuffer->readable();

	assert( m_header->m_channelOffsets.find( name ) != m_header->m_channelOffsets.end() );
	int channelOffset = m_header->m_channelOffsets[name];

	typename TargetVector::Ptr dataContainer = new TargetVector();

	typename TargetVector::ValueType &data = dataContainer->writable();
	int area = ( dataWindow.size().x + 1 ) * ( dataWindow.size().y + 1 );
	assert( area >= 0 );
	data.resize( area );

	int dataWidth = 1 + dataWindow.size().x;

	Box2i wholeDataWindow = this->dataWindow();

	int wholeDataHeight = 1 + wholeDataWindow.size().y;
	int wholeDataWidth = 1 + wholeDataWindow.size().x;

	const int yMin = dataWindow.min.y - wholeDataWindow.min.y;
	const int yMax = dataWindow.max.y - wholeDataWindow.min.y;

	const int xMin = dataWindow.min.x - wholeDataWindow.min.x;
	const int xMax = dataWindow.max.x - wholeDataWindow.min.x;

	ScaledDataConversion<T, V> converter;

	if ( m_header->m_fileHeader.m_storageFormat >= 1 ) /// RLE
	{
		int dataY = 0;
		for ( int y = yMin ; y <= yMax ; ++y, ++dataY )
		{
			assert( yMin >= 0 );
			assert( yMin < wholeDataHeight );

			/// Images are unencoded "upside down" (flipped in Y), for our purposes
			uint32_t rowOffset = m_header->m_offsetTable[ channelOffset * wholeDataHeight + ( wholeDataHeight - 1 - y ) ];

			if ( rowOffset >= buffer.size() )
			{
				throw IOException( "SGIImageReader: Invalid RLE row offset found while reading " + fileName() );
			}

			std::vector<T> scanline( wholeDataWidth );

			uint32_t scanlineOffset = 0;
			bool done = false;

			while ( !done )
			{
				T pixel = buffer[ rowOffset ++ ];

				T count = pixel & 0x7f;

				if ( count == 0 )
				{
					done = true;
				}
				else
				{
					if ( pixel & 0x80 )
					{
						if ( scanlineOffset + count - 1 >= scanline.size() || rowOffset + count - 1 >= buffer.size() )
						{
							throw IOException( "SGIImageReader: Invalid RLE data found while reading " + fileName() );
						}

						while ( count -- )
						{
							assert( scanlineOffset < scanline.size() );
							assert( rowOffset < buffer.size() );
							scanline[ scanlineOffset++ ] = buffer[ rowOffset ++ ];
						}
					}
					else
					{
						if ( scanlineOffset + count - 1 >= scanline.size() || rowOffset - 1 >= buffer.size() )
						{
							throw IOException( "SGIImageReader: Invalid RLE data found while reading " + fileName() );
						}

						assert( rowOffset < buffer.size() );
						pixel = buffer[ rowOffset ++ ];

						while ( count -- )
						{
							assert( scanlineOffset < scanline.size() );
							scanline[ scanlineOffset++ ] = pixel;
						}
					}
				}
			}

			if ( scanlineOffset != scanline.size() )
			{
				throw IOException( "SGIImageReader: Error occurred during RLE decode while reading " + fileName() );
			}

			int dataOffset = dataY * dataWidth;

			for ( int x = xMin; x <= xMax ; ++x, ++dataOffset  )
			{
				data[dataOffset] = converter( scanline[x] );
			}
		}
	}
	else /// Not RLE
	{
		int dataY = 0;

		for ( int y = dataWindow.min.y; y <= dataWindow.max.y; ++y, ++dataY )
		{
			typename TargetVector::ValueType::size_type dataOffset = dataY * dataWidth;

			for ( int x = dataWindow.min.x; x <= dataWindow.max.x; ++x, ++dataOffset )
			{
				assert( dataOffset < data.size() );

				/// Images are unencoded "upside down" (flipped in Y), for our purposes
				data[dataOffset] = converter( buffer[ ( channelOffset * wholeDataHeight * wholeDataWidth ) + ( wholeDataHeight - 1 - y  ) * wholeDataWidth + x  ] );
			}
		}
	}

	return dataContainer;
}