IECoreMaya : Added Path/MDagPath conversion utility to LiveScene.

Author: bradleyhenke

include/IECoreMaya/LiveScene.h

@@ -192,6 +192,12 @@ class IECOREMAYA_API LiveScene : public IECoreScene::SceneInterface
 		/// Returns the MDagPath object to the scene node
 		MDagPath dagPath() const;
 
+		/// Returns the scene path corresponding to the maya dag path
+		static void dagPathToPath( MDagPath dagPath, IECoreScene::SceneInterface::Path &path );
+
+		/// Returns the maya dag path corresponding to the scene path
+		static void pathToDagPath( const IECoreScene::SceneInterface::Path &path, MDagPath &dagPath );
+
 		/// Translates cortex attribute name to maya attribute name
 		/// Returns an empty string if there are no valid mappings
 		static Name toMayaAttributeName( const Name &name );

src/IECoreMaya/LiveScene.cpp

@@ -1122,6 +1122,66 @@ void LiveScene::hash( HashType hashType, double time, MurmurHash &h ) const
 	throw Exception( "Hashes currently not supported in IECoreMaya::LiveScene objects." );
 }
 
+void LiveScene::dagPathToPath( MDagPath dagPath, IECoreScene::SceneInterface::Path &path )
+{
+	tbb::recursive_mutex::scoped_lock l( g_mutex );
+	path.clear();
+
+	if( dagPath.isValid() )
+	{
+		// Only transforms can be part of the path
+		if( !dagPath.hasFn( MFn::kTransform ) )
+		{
+			dagPath.pop();
+		}
+
+		const std::string pathStr( dagPath.fullPathName().asChar() );
+		const boost::tokenizer< boost::char_separator<char> > tokens( pathStr, boost::char_separator<char>( "|" ) );
+		for ( const auto &token : tokens )
+		{
+			path.push_back( token );
+		}
+
+		return;
+	}
+
+	throw Exception( "IECoreMaya::LiveScene::dagPathToPath invalid dag path." );
+}
+
+void LiveScene::pathToDagPath( const IECoreScene::SceneInterface::Path &path, MDagPath &dagPath )
+{
+	tbb::recursive_mutex::scoped_lock l( g_mutex );
+
+	if( path.empty() )
+	{
+		MItDag itDag;
+		itDag.getPath( dagPath );
+		return;
+	}
+
+	std::string dagPathStr;
+	for( const auto &name : path )
+	{
+		dagPathStr += "|";
+		dagPathStr += name;
+	}
+
+	MSelectionList sel;
+	if( sel.add( dagPathStr.c_str() ) && sel.getDagPath( 0, dagPath ) )
+	{
+		return;
+	}
+
+	// Invalid dag path
+	std::string pathStr;
+	IECoreScene::SceneInterface::pathToString( path, pathStr );
+	throw Exception(
+		boost::str(
+			boost::format( "IECoreMaya::LiveScene::pathToDagPath invalid conversion to dag path from \"%1%\"." ) % pathStr
+		)
+	);
+}
+
 void LiveScene::registerCustomObject( HasFn hasFn, ReadFn readFn )
 {
 	CustomReader r;

src/IECoreMaya/bindings/LiveSceneBinding.cpp

@@ -204,6 +204,39 @@ inline std::string dagPath( object liveSceneObject )
 	return liveScene.dagPath().fullPathName().asChar();
 }
 
+inline list dagPathToPath( object dagObj )
+{
+	list pathList;
+	extract<MDagPath> dagPath( dagObj );
+
+	// Return the root path (an empty list) if we are given an empty string
+	// Maya doesn't really have a "root" dag path, so this is as close as we can get while simultaneously
+	// ensuring dagPathToPath( pathToDagPath( [] ) ) == []
+	if( dagPath.check() && len( dagObj ) == 0 )
+	{
+		return pathList;
+	}
+
+	// Get the path, or throw if the dag path object is invalid
+	IECoreScene::SceneInterface::Path path;
+	LiveScene::dagPathToPath( dagPath(), path );
+	for(const auto &name : path )
+	{
+		pathList.append( name.string() );
+	}
+	return pathList;
+}
+
+inline std::string pathToDagPath( list pathList )
+{
+	IECoreScene::SceneInterface::Path path;
+	container_utils::extend_container( path, pathList );
+
+	MDagPath dagPath;
+	LiveScene::pathToDagPath( path, dagPath );
+	return dagPath.fullPathName().asChar();
+}
+
 } // namespace
 
 void IECoreMaya::bindLiveScene()
@@ -213,6 +246,8 @@ void IECoreMaya::bindLiveScene()
 		.def( "registerCustomTags", registerCustomTags, ( arg_( "hasFn" ), arg_( "readFn" ) ) ).staticmethod( "registerCustomTags" )
 		.def( "registerCustomAttributes", registerCustomAttributes, (  arg_( "namesFn" ), arg_( "readFn" ), arg_( "mightHaveFn" ) = object() ) ).staticmethod( "registerCustomAttributes" )
 		.def( "dagPath", ::dagPath )
+		.def( "dagPathToPath", ::dagPathToPath ).staticmethod( "dagPathToPath" )
+		.def( "pathToDagPath", ::pathToDagPath ).staticmethod( "pathToDagPath" )
 		.def( "toMayaAttributeName", LiveScene::toMayaAttributeName ).staticmethod( "toMayaAttributeName" )
 		.def( "fromMayaAttributeName", LiveScene::fromMayaAttributeName ).staticmethod( "fromMayaAttributeName" )
 		.def_readonly("visibilityOverrideName", LiveScene::visibilityOverrideName )

test/IECoreMaya/LiveSceneTest.py

@@ -1458,6 +1458,46 @@ def testDagPath( self ):
 		cubeScene = liveScene.scene( [group, cube] )
 		self.assertEqual( cubeScene.dagPath(), '|{}|{}'.format( group, cube ) )
 
+	def testDagPathToPath( self ):
+		group = str( maya.cmds.group( empty=True ) )
+		cubeTransform = maya.cmds.polyCube( constructionHistory=False )[0]
+		maya.cmds.parent( cubeTransform, group )
+		cubeTransform = str( maya.cmds.ls( cubeTransform, long=True )[0] )
+		cubeShape = str( maya.cmds.listRelatives( cubeTransform, fullPath=True )[0] )
+
+		dagTransform = OpenMaya.MDagPath()
+		dagShape = OpenMaya.MDagPath()
+		sel = OpenMaya.MSelectionList()
+		sel.add( cubeTransform )
+		sel.add( cubeShape )
+		sel.getDagPath( 0, dagTransform )
+		sel.getDagPath( 0, dagShape )
+
+		pathTransform = IECoreMaya.LiveScene.dagPathToPath( dagTransform.fullPathName() )
+		self.assertEqual( pathTransform, cubeTransform[1:].split('|') )
+
+		pathShape = IECoreMaya.LiveScene.dagPathToPath( dagShape.fullPathName() )
+		self.assertEqual( pathShape, cubeTransform[1:].split('|') )
+
+		pathRoot = IECoreMaya.LiveScene.dagPathToPath( '' )
+		self.assertEqual( pathRoot, [] )
+
+		self.assertRaises( Exception, IECoreMaya.LiveScene.dagPathToPath, '|invalid' )
+
+	def testPathToDagPath( self ):
+		group = str( maya.cmds.group( empty=True ) )
+		cube = str( maya.cmds.polyCube( constructionHistory=False )[0] )
+		maya.cmds.parent( cube, group )
+
+		path = [group, cube]
+		dagTransform = IECoreMaya.LiveScene.pathToDagPath( path )
+		self.assertEqual( dagTransform, '|{}|{}'.format( group, cube ) )
+
+		dagRoot = IECoreMaya.LiveScene.pathToDagPath( [] )
+		self.assertEqual( dagRoot, '' )
+
+		self.assertRaises( Exception, IECoreMaya.LiveScene.pathToDagPath, ['invalid'] )
+
 
 if __name__ == "__main__":
 	IECoreMaya.TestProgram( plugins = [ "ieCore" ] )