ParticleWriter.cpp

//////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2007-2010, Image Engine Design Inc. All rights reserved.
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are
//  met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//
//     * Neither the name of Image Engine Design nor the names of any
//       other contributors to this software may be used to endorse or
//       promote products derived from this software without specific prior
//       written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
//  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
//  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
//  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
//  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
//  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////

#include "IECoreScene/ParticleWriter.h"

#include "IECoreScene/PointsPrimitive.h"

#include "IECore/CompoundParameter.h"
#include "IECore/DespatchTypedData.h"
#include "IECore/Exception.h"
#include "IECore/FileNameParameter.h"
#include "IECore/MessageHandler.h"
#include "IECore/TestTypedData.h"
#include "IECore/TypedParameter.h"

using namespace std;
using namespace IECore;
using namespace IECoreScene;
using namespace boost;

IE_CORE_DEFINERUNTIMETYPED( ParticleWriter )

ParticleWriter::ParticleWriter( const std::string &description )
	:	Writer( description, PointsPrimitive::staticTypeId() )
{
	m_attributesParameter = new StringVectorParameter(
		"attributes",
		"A list of attributes to write. If the list is empty then all attributes are written."
	);
	parameters()->addParameter( m_attributesParameter );
}

bool ParticleWriter::canWrite( ConstObjectPtr object, const std::string &fileName )
{
	return runTimeCast<const PointsPrimitive>( object ).get();
}

const PointsPrimitive * ParticleWriter::particleObject()
{
	/// \todo this cast is no longer ok - once we've adjusted the input object Parameter we can use the validation
	/// on there to do our work for us.
	return static_cast<const PointsPrimitive *>( object() );
}

size_t ParticleWriter::particleCount()
{
	return particleObject()->getNumPoints();
}

void ParticleWriter::particleAttributes( std::vector<std::string> &names )
{
	// find all attributes of the particle object with appropriate amounts of data
	size_t numParticles = particleCount();
	vector<string> allNames;
	ConstPointsPrimitivePtr cd = particleObject();
	for( PrimitiveVariableMap::const_iterator it=cd->variables.begin(); it!=cd->variables.end(); it++ )
	{
		if ( testTypedData<TypeTraits::IsVectorTypedData>( it->second.data.get() ) )
		{
			size_t s = despatchTypedData< TypedDataSize, TypeTraits::IsVectorTypedData >( it->second.data.get() );
			if( s==numParticles )
			{
				allNames.push_back( it->first );
			}
			else
			{
				msg( Msg::Warning, "ParticleWriter::particleAttributes", "Ignoring attribute \"{}\" due to insufficient elements (expected {} but found {}).", it->first, numParticles, s );
			}
		}
		else if ( testTypedData<TypeTraits::IsSimpleTypedData>( it->second.data.get() ) )
		{
			// it's not data of a vector type but it could be of a simple type
			// in which case it's suitable for saving as a constant particle attribute

			despatchTypedData< TypedDataAddress, TypeTraits::IsSimpleTypedData >( it->second.data.get() );
			allNames.push_back( it->first );
		}
	}

	const StringVectorData *d = static_cast<const StringVectorData *>( parameters()->parameter<StringVectorParameter>( "attributes" )->getValue() );
	if( !d->readable().size() )
	{
		names = allNames;
		return;
	}

	names.clear();
	for( vector<string>::const_iterator it = d->readable().begin(); it!=d->readable().end(); it++ )
	{
		if( find( allNames.begin(), allNames.end(), *it )!=allNames.end() )
		{
			names.push_back( *it );
		}
		else
		{
			msg( Msg::Warning, "ParticleWriter::particleAttributes", "Attribute \"{}\" requested via parameters but is not available.", *it );
		}
	}
}