def create_item(self, name=None):
"""
Creates a new item (folder) inside the selected item
:param name: str, name of the new item
"""
current_item = self._current_item
if current_item:
item_path = self.get_tree_item_path_string(self._current_item)
item_path = path.join_path(self._directory, item_path)
if path.is_file(item_path):
item_path = path.get_dirname(item_path)
current_item = self._current_item.parent()
if not current_item:
item_path = self._directory
if not name:
name = self.NEW_ITEM_NAME
folder.create_folder(name=name, directory=item_path)
if current_item:
self._add_sub_items(current_item)
self.setItemExpanded(current_item, True)
else:
self.refresh()
def save(self, file_path, image_type='png'):
"""
Saves screen to a file
:param file_path: str, path to save image into
:param image_type: str, image type (png or jpg)
"""
saved = None
if not file_path:
LOGGER.error('Path not specificed for snapshot.')
self.saved.emit(saved)
return
file_dir, file_name, file_ext = path_utils.split_path(file_path)
if not os.path.isdir(file_dir):
folder_utils.create_folder(file_dir)
else:
if os.path.isfile(file_path):
fileio.delete_file(file_path)
image_type = image_type if image_type.startswith('.') else '.{}'.format(image_type)
if image_type != file_ext:
if file_ext not in ('.png', '.jpg'):
LOGGER.warning('Image of type "{}" is not supported by snapshot!'.format(file_ext))
return
image_type = file_ext
if image_type.startswith('.'):
image_type = image_type[1:]
image_type = image_type.upper()
saved = self._snapshot_pixmap.save(file_path, image_type)
self._last_saved_location = file_path
self.saved.emit(file_path if saved else None)
def create_folder(self, name, relative_path=None):
if relative_path is None:
folder.create_folder(name=name, directory=self.full_path)
else:
folder.create_folder(name=name,
directory=path.join_path(
self.full_path, relative_path))
def create_project(self):
project_full_path = self.full_path
if path.is_dir(project_full_path):
logger.warning(
'Project Path {} already exists! Choose another one ...'.
format(project_full_path))
return
folder.create_folder(name=self.name, directory=self._project_path)
self._set_default_settings()
return self
def copy(self, target_path):
current_path = self.format_identifier()
if not os.path.isdir(target_path):
folder.create_folder(target_path)
folder.copy_directory_contents(current_path, target_path)
# We force sync after doing copy operation
self._db.sync()
return target_path
def _get_curves_data_path(self):
current_path = curves.__path__[0]
custom_curve_path = utils.get_custom('custom_curve_path')
if custom_curve_path and os.path.isdir(custom_curve_path):
curve_data = os.path.join(custom_curve_path)
folder.create_folder(curve_data)
logger.info(
'Using custom curve directory: {}'.format(custom_curve_path))
current_path = custom_curve_path
self._curves_data_path = current_path
return self._curves_data_path
def create_metadata(self, version):
# We make sure the current item exists and also, we make sure the item has all composition metadata
item = self._db.get(self._id)
if not item:
return
metadata = item.metadata_dict() or dict()
metadata_path = self.get_metadata_path(version)
metadata_dir = os.path.dirname(metadata_path)
if not os.path.isdir(metadata_dir):
folder.create_folder(metadata_dir)
jsonio.write_to_file(metadata, metadata_path)
self.set_metadata(version, metadata)
def __init__(self, session_path):
self._path = session_path
if not os.path.isfile(session_path):
session_path_dir = os.path.dirname(session_path)
if not os.path.isdir(session_path_dir):
folder.create_folder(session_path_dir)
valid = fileio.create_file(os.path.basename(session_path),
os.path.dirname(session_path))
if not valid:
LOGGER.warning(
'Impossible to create session file. Session functionality disabled ...'
)
return
with open(session_path, 'w') as fh:
fh.write('{}')
def save(self, *args, **kwargs):
dependencies = dict()
filepath = self.format_identifier()
if not filepath.endswith(MayaAttributesData.EXTENSION):
filepath = '{}{}'.format(filepath, MayaAttributesData.EXTENSION)
if not filepath:
LOGGER.warning(
'Impossible to save Attributes file because save file path not defined!'
)
return
objects = kwargs.get('objects', None)
scope = self._get_scope(objects)
if not scope:
LOGGER.warning(
'Nothing selected to export attributes of. Please, select a mesh,'
' curve, NURBS surface or lattice with skin weights to export')
return False
LOGGER.debug('Saving {} | {}'.format(filepath, kwargs))
if not os.path.isdir(filepath):
attributes_folder = folder.create_folder(filepath)
dependencies[attributes_folder] = 'attributes_folder'
for obj in scope:
LOGGER.info('Exporting attributes of {}'.format(obj))
file_name = fileio.create_file('{}{}'.format(obj, self.EXTENSION),
filepath)
lines = list()
attributes_to_export = self._get_attributes(obj)
shapes = self._get_shapes(obj)
if shapes:
shape = shapes[0]
shape_attributes = self._get_shape_attributes(shape)
if shape_attributes:
attributes_to_export = list(
set(attributes_to_export).union(shape_attributes))
if not attributes_to_export:
continue
for attribute_to_export in attributes_to_export:
try:
value = dcc.get_attribute_value(obj, attribute_to_export)
except Exception:
continue
lines.append("[ '{}', {} ]".format(attribute_to_export, value))
write_file = fileio.FileWriter(file_name)
write_file.write(lines)
if file_name and os.path.isfile(file_name):
dependencies[file_name] = 'attribute'
LOGGER.info('Attributes data export operation completed successfully!')
return dependencies
def set_sub_folder(self, name):
"""
Sets the sub folder of this data folder
:param name: str, name of the sub folder
"""
if not name:
return
if not self.settings:
self._load_folder()
self.settings.set('sub_folder', name)
sub_folder = path_utils.join_path(self.folder_path,
'.sub/{}'.format(name))
folder.create_folder(sub_folder)
self.settings.set('data_type', str(self.data_type))
def _create_folder(self):
"""
Internal function that creates data folder
"""
data_path = folder.create_folder(self.name, self.file_path)
self.folder_path = data_path
self._set_default_settings()
def export_animation(self, export_path):
"""
Exports all the animation of the current shot into
:return:
"""
if not tp.is_maya():
LOGGER.warning('Shot Animation Export is only supported in Maya!')
return
from artellapipe.dccs.maya.core import sequencer
all_anim_curves = tp.Dcc.all_animation_curves()
if not all_anim_curves:
LOGGER.warning(
'Impossible teo export shot animation because no animation curves were found in current scene!'
)
return False
export_name = os.path.basename(export_path)
export_dir = os.path.dirname(export_path)
if not os.path.isdir(export_dir):
folder.create_folder(export_name, export_dir)
start_frame = self.get_start_frame()
end_frame = self.get_end_frame()
max_time = self.get_max_time()
min_time = self.get_min_time()
post_hold = self.get_post_hold()
if post_hold > 0.0:
raise NotImplementedError(
'post_hold greater than 0.0 is not supported yet')
valid_export = sequencer.SequencerShotExporter(
anim_curves=all_anim_curves).export_shot_animation_curves(
export_file_path=export_path,
start_frame=start_frame,
end_frame=end_frame,
sequencer_least_key=min_time,
sequencer_great_key=max_time)
return valid_export
def create_version(self, comment):
version_path = self.version_path()
if version_path and not os.path.isdir(version_path):
folder.create_folder(version_path)
if version_path and os.path.isdir(version_path):
versions_path = os.path.dirname(version_path)
version_folder_name = os.path.basename(version_path)
version_file = version.VersionFile(self.format_identifier())
version_file.set_version_folder(versions_path)
version_file.set_version_folder_name(version_folder_name)
version_file.save(comment or '')
last_version = version_file.get_latest_version()
else:
return False
if last_version:
self.create_metadata(os.path.basename(last_version).split('.')[-1])
return True
def _create_version_folder(self):
from tpDcc.libs.python import folder
self._version_folder = folder.create_folder(
name=self._version_folder_name, directory=self._path)
def save(self, *args, **kwargs):
"""
Saves NG Skin weights file
"""
dependencies = dict()
filepath = self.format_identifier()
if not filepath:
logger.warning(
'Impossible to save NGSkin Cluster Weights file because save file path not defined!'
)
return
objects = kwargs.get('objects', None)
if not objects:
objects = dcc.client().selected_nodes(full_path=True)
if not objects:
logger.warning(
'Nothing selected to export skin weights of. Please, select a mesh,'
' curve, NURBS surface or lattice with skin weights to export')
return False
logger.debug('Saving {} | {}'.format(filepath, kwargs))
try:
if not dcc.is_plugin_loaded('ngSkinTools2'):
dcc.load_plugin('ngSkinTools2')
import ngSkinTools2
from ngSkinTools2 import api as ngst_api
except ImportError:
logger.warning(
'NgSkinTools 2.0 is not installed. Impossible to export ngSkin data'
)
return False
valid_nodes = list()
# Check that all objects that we are going to export have at least one skin cluster node associated
# Make sure also that all objects skin output folder have been created
obj_dirs = OrderedDict()
skin_nodes = OrderedDict()
geo_paths = OrderedDict()
skin_weights = OrderedDict()
for obj in objects:
if dcc.client().node_is_a_shape(obj):
obj = dcc.client().node_parent(obj, full_path=True)
obj_filename = obj
if obj.find('|') > -1:
obj_filename = obj_filename.replace('|', '.')
if obj_filename.startswith('.'):
obj_filename = obj_filename[1:]
if obj_filename.find(':') > -1:
obj_filename = obj_filename.replace(':', '-')
skin = dcc.client().find_deformer_by_type(obj, 'skinCluster')
if not skin:
logger.warning(
'Skip skin weights export for object because no skinCluster found!'
.format(obj))
continue
valid_nodes.append((obj, obj_filename, skin))
if not valid_nodes:
logger.warning(
'Skin exported failed! No objects found with skinClusters applied!'
)
return False
# Create skin folder only is valid nodes are available
file_name = '.{}'.format(os.path.basename(filepath))
file_folder = path_utils.join_path(os.path.dirname(filepath),
file_name)
if not os.path.isdir(file_folder):
skin_folder = folder.create_folder(file_folder, make_unique=True)
dependencies[skin_folder] = 'skin_folder'
for node_data in valid_nodes:
obj, obj_filename, skin = node_data
geo_path = path_utils.join_path(file_folder, obj_filename)
if path_utils.is_dir(geo_path):
folder.delete_folder(obj_filename, file_folder)
geo_path = folder.create_folder(obj_filename, file_folder)
if not geo_path:
logger.error(
'Unable to create skin weights directory: "{}" in "{}"'.
format(obj_filename, file_folder))
return False
dependencies[geo_path] = 'geo_path'
weights = dcc.client().get_skin_weights(skin)
obj_dirs[obj] = obj_filename
skin_nodes[obj] = skin
geo_paths[obj] = geo_path
skin_weights[obj] = weights
for (obj, skin_node), (_, geo_path), (_, skin_weights) in zip(
skin_nodes.items(), geo_paths.items(), skin_weights.items()):
logger.info('Exporting weights: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
info_lines = list()
info_file = fileio.create_file('influence.info', geo_path)
for influence in skin_weights:
if influence is None or influence == 'None':
continue
weight_list = skin_weights[influence]
if not weight_list:
continue
influence_name = skin_utils.get_skin_influence_at_index(
influence, skin_node)
if not influence_name or not dcc.node_exists(influence_name):
continue
influence_position = dcc.node_world_space_translation(
influence_name)
influence_line = "{'%s' : {'position' : %s}}" % (
influence_name, str(influence_position))
info_lines.append(influence_line)
writer = fileio.FileWriter(info_file)
writer.write(info_lines)
settings_file = fileio.create_file('settings.info', geo_path)
setting_lines = list()
if shape_utils.has_shape_of_type(obj, 'mesh'):
self._export_mesh_obj(obj, geo_path)
setting_lines.append("['skinNodeName', '{}']".format(
dcc.node_short_name(skin_node)))
if dcc.attribute_exists(skin_node, 'blendWeights'):
blend_weights = skin_utils.get_skin_blend_weights(skin_node)
setting_lines.append(
"['blendWeights', {}]".format(blend_weights))
if dcc.attribute_exists(skin_node, 'skinningMethod'):
skin_method = dcc.get_attribute_value(skin_node,
'skinningMethod')
setting_lines.append(
"['skinningMethod', {}]".format(skin_method))
write_settings = fileio.FileWriter(settings_file)
write_settings.write(setting_lines)
ng_skin_file_name = os.path.join(geo_path, 'ngdata.json')
ngst_api.export_json(obj, file=ng_skin_file_name)
logger.info(
'Skin weights exported successfully: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
data_to_save = OrderedDict()
for obj, obj_filename in obj_dirs.items():
data_to_save[obj] = {'enabled': True, 'folder': obj_filename}
with open(filepath, 'w') as fh:
json.dump(data_to_save, fh)
logger.info('Skin weights export operation completed successfully!')
return True
def _create_version_folder(self):
self._version_folder = folder.create_folder(self._version_folder_name,
self._path)
def test_folder_creation_path(self):
self.assertTrue(
os.path.isdir(folder.create_folder(self._get_folder_path())))
def test_folder_creation_name_directory(self):
split_folder_path = self._get_folder_path(split=True)
self.assertTrue(
os.path.isdir(
folder.create_folder(split_folder_path[1],
split_folder_path[0])))
def save(self, *args, **kwargs):
dependencies = dict()
filepath = self.format_identifier()
if not filepath.endswith(SkinWeightsData.EXTENSION):
filepath = '{}{}'.format(filepath, SkinWeightsData.EXTENSION)
if not filepath:
logger.warning(
'Impossible to save Maya Skin Weights file because save file path not defined!'
)
return
objects = kwargs.get('objects', None)
if not objects:
objects = dcc.client().selected_nodes(full_path=True)
if not objects:
logger.warning(
'Nothing selected to export skin weights of. Please, select a mesh,'
' curve, NURBS surface or lattice with skin weights to export')
return False
logger.debug('Saving {} | {}'.format(filepath, kwargs))
valid_nodes = list()
# Check that all objects that we are going to export have at least one skin cluster node associated
# Make sure also that all objects skin output folder have been created
obj_dirs = OrderedDict()
skin_nodes = OrderedDict()
geo_paths = OrderedDict()
skin_weights = OrderedDict()
for obj in objects:
if dcc.client().node_is_a_shape(obj):
obj = dcc.client().node_parent(obj, full_path=True)
obj_filename = obj
if obj.find('|') > -1:
obj_filename = obj_filename.replace('|', '.')
if obj_filename.startswith('.'):
obj_filename = obj_filename[1:]
if obj_filename.find(':') > -1:
obj_filename = obj_filename.replace(':', '-')
skin = dcc.client().find_deformer_by_type(obj, 'skinCluster')
if not skin:
logger.warning(
'Skip skin weights export for object because no skinCluster found!'
.format(obj))
continue
valid_nodes.append((obj, obj_filename, skin))
if not valid_nodes:
logger.warning(
'Skin exported failed! No objects found with skinClusters applied!'
)
return False
# Create skin folder only is valid nodes are available
file_name = '.{}'.format(os.path.basename(filepath))
file_folder = path_utils.join_path(os.path.dirname(filepath),
file_name)
if not os.path.isdir(file_folder):
skin_folder = folder.create_folder(file_folder, make_unique=True)
dependencies[skin_folder] = 'skin_folder'
for node_data in valid_nodes:
obj, obj_filename, skin = node_data
geo_path = path_utils.join_path(file_folder, obj_filename)
if path_utils.is_dir(geo_path):
folder.delete_folder(obj_filename, file_folder)
geo_path = folder.create_folder(obj_filename, file_folder)
if not geo_path:
logger.error(
'Unable to create skin weights directory: "{}" in "{}"'.
format(obj_filename, file_folder))
return False
dependencies[geo_path] = 'geo_path'
weights = dcc.client().get_skin_weights(skin)
obj_dirs[obj] = obj_filename
skin_nodes[obj] = skin
geo_paths[obj] = geo_path
skin_weights[obj] = weights
for (obj, skin_node), (_, geo_path), (_, skin_weights) in zip(
skin_nodes.items(), geo_paths.items(), skin_weights.items()):
logger.info('Exporting weights: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
info_lines = list()
info_file = fileio.create_file('influence.info', geo_path)
dependencies[info_file] = 'info_file'
for influence in skin_weights:
if influence is None or influence == 'None':
continue
weight_list = skin_weights[influence]
if not weight_list:
continue
thread = LoadWeightFileThread()
influence_line, weight_path = thread.run(
influence, skin_node, skin_weights[influence], geo_path)
if influence_line:
info_lines.append(influence_line)
if weight_path and os.path.isfile(weight_path):
dependencies[weight_path] = 'weight'
writer = fileio.FileWriter(info_file)
writer.write(info_lines)
settings_file = fileio.create_file('settings.info', geo_path)
dependencies[settings_file] = 'settings'
setting_lines = list()
if dcc.client().node_has_shape_of_type(obj, 'mesh'):
mesh_path = self._export_mesh_obj(obj, geo_path)
if mesh_path and os.path.isfile(mesh_path):
dependencies[mesh_path] = 'geo_file'
if dcc.client().attribute_exists(skin_node, 'blendWeights'):
blend_weights = dcc.client().get_skin_blend_weights(skin_node)
setting_lines.append(
"['blendWeights', {}]".format(blend_weights))
if dcc.client().attribute_exists(skin_node, 'skinningMethod'):
skin_method = dcc.client().get_attribute_value(
skin_node, 'skinningMethod')
setting_lines.append(
"['skinningMethod', {}]".format(skin_method))
write_settings = fileio.FileWriter(settings_file)
write_settings.write(setting_lines)
logger.info(
'Skin weights exported successfully: {} > {} --> "{}"'.format(
obj, skin_node, geo_path))
data_to_save = OrderedDict()
for obj, obj_filename in obj_dirs.items():
data_to_save[obj] = {'enabled': True, 'folder': obj_filename}
with open(filepath, 'w') as fh:
json.dump(data_to_save, fh)
logger.info('Skin weights export operation completed successfully!')
return dependencies
def save(self, **kwargs):
new_folder = folder.create_folder(self.format_identifier())
return os.path.isdir(new_folder)
def test_folder_creation_unique(self):
folder_path = self._get_folder_path()
folder.create_folder(folder_path)
self.assertTrue(
os.path.isdir(folder.create_folder(folder_path, make_unique=True)))