def get_frame_range(self):
"""
Return the layer's frame range. If the layer and its
parent outline file have incompatible frame ranges,
return None.
@rtype: String
@return: The layer's frame range;
"""
if self.__args["range"]:
rng = self.__args["range"]
elif self.__parent:
rng = self.get_parent().get_frame_range()
else:
rng = None
if self.__outline:
# If there is a layer range and an OL range, return
# the intersection. If the intersection cannot be
# made then a LayerException is thrown.
# If there is just a layer range,return the layer range.
# if there is no layer range but an ol range, return the ol_range.
# if there is neither a layer range or ol range, return a single frame range.
if rng and self.__outline.get_frame_range():
ol_rng = FileSequence.FrameSet(
self.__outline.get_frame_range())
ly_rng = FileSequence.FrameSet(rng)
intersect = util.intersect_frame_set(ol_rng,
ly_rng,
normalize=False)
if not intersect:
return None
# If nomalizing does not change the order of frames, return normalized
normalized = FileSequence.FrameSet(str(intersect))
normalized.normalize()
if list(intersect) == list(normalized):
return str(normalized)
return str(intersect)
elif rng:
return rng
elif not rng and self.__outline.get_frame_range():
return self.__outline.get_frame_range()
elif not rng and not self.__outline.get_frame_range():
return DEFAULT_FRAME_RANGE
else:
# There is no parent outline
if rng:
return rng
else:
return DEFAULT_FRAME_RANGE
def build_dependencies(ol, layer, all_depends):
"""
Iterate through all the layer's dependencies and
add them to the job spec.
"""
for dep in layer.get_depends():
depend = Et.SubElement(all_depends, "depend",
type=dep.get_type(),
anyframe=bool_to_str(dep.is_any_frame()))
if dep.get_type() == outline.depend.DependType.LayerOnSimFrame:
frame_range = dep.get_depend_on_layer().get_frame_range()
first_frame = FileSequence.FrameSet(frame_range)[0]
sub_element(depend, "depjob", ol.get_name())
sub_element(depend, "deplayer", layer.get_name())
sub_element(depend, "onjob", ol.get_name())
sub_element(depend, "onframe", "%04d-%s"
% (first_frame, dep.get_depend_on_layer().get_name()))
else:
sub_element(depend, "depjob", ol.get_name())
sub_element(depend, "deplayer", layer.get_name())
sub_element(depend, "onjob", ol.get_name())
sub_element(depend, "onlayer", dep.get_depend_on_layer().get_name())
def get_slice(frame_range, frames, items):
"""
Given the full frame range, local frame range, and a array items,
return the slice of the items array.
"""
frame_set = FileSequence.FrameSet(frame_range)
return [items[frame_set.index(frame)] for frame in frames]
def _frameRangeSelectionFilterUpdate(self):
if not self.frameMonitorTree.getJob():
self.frameRangeSelection.setFrameRange(["1", "10000"])
else:
layers = self.frameMonitorTree.getJob().getLayers()
_min = None
_max = None
for layer in layers:
seq = FileSequence.FrameSet(layer.range())
seq.normalize()
frameList = seq.getAll()
if _min is not None:
_min = min(_min, int(frameList[0]))
else:
_min = int(frameList[0])
if _max is not None:
_max = max(_max, int(frameList[-1]))
else:
_max = int(frameList[-1])
if _min == _max:
_max += 1
self.frameRangeSelection.default_select_size = 1000 // len(layers)
self.frameRangeSelection.setFrameRange([str(_min), str(_max)])
def __init__(self, path, **args):
Path.__init__(self, path, **args)
try:
self.__fs = FileSequence.FileSequence(self.get_path())
except ValueError, e:
logger.critical("Failed to parse spec: %s." % self.get_path())
raise e
def build_frame_range(frame_range, chunk_size):
"""
Return an array of frames with no duplicates and chunking applied.
"""
frame_set = FileSequence.FrameSet(frame_range)
frames = []
if chunk_size > 1:
if chunk_size >= len(frame_set):
frames.append(frame_set.__getitem__(0))
else:
unique_frames = list(set(frame_set))
for i, unique_frame in enumerate(unique_frames):
if i % chunk_size == 0:
frames.append(unique_frame)
else:
frames = list(FileSequence.FrameSet(frame_range))
return frames
def get_frame_set(self):
"""
Return the sequence's frame set object.
:rtype: FrameSet
:return: The current framet set.
"""
return FileSequence.FrameSet(str(self.__fs.frameSet))
def __init__(self, path, **args):
Path.__init__(self, path, **args)
try:
self.__fs = FileSequence.FileSequence(self.get_path())
except ValueError as e:
logger.critical("Failed to parse spec: %s." % self.get_path())
raise e
if "mkdir" not in args:
self.set_attribute("mkdir", False)
def validatePage(self):
frames = str(self.field("onFrame"))
if frames:
try:
fs = FileSequence.FrameSet(frames)
fs.normalize()
self.wizard().onFrame = list(map(int, fs.getAll()))
return True
except Exception as e:
list(map(logger.warning, cuegui.Utils.exceptionOutput(e)))
return False
def test_get_set_frame_range(self):
with test_utils.TemporarySessionDirectory():
ol = outline.load_outline(self.path)
# Set frame range from string
ol.set_frame_range('1-10')
self.assertEqual('1-10', ol.get_frame_range())
# Set frame range from sequence
ol.set_frame_range([1, 2, 3, 4, 5])
self.assertEqual('1,2,3,4,5', ol.get_frame_range())
# Set frame range from FrameSet
ol.set_frame_range(FileSequence.FrameSet('5-10'))
self.assertEqual('5,6,7,8,9,10', ol.get_frame_range())
def make_frame_set(frames, normalize=True):
"""
Takes an array of integers and makes a normalized
FrameSet object.
:type frames: List<int>
:param frames: The frame list to change into a FrameSet
:rtype: FrameSet
:return: a normalized FileSequence.FrameSet
"""
fs = FileSequence.FrameSet(",".join([str(f) for f in frames]))
if normalize:
fs.normalize()
return fs
def get_frame_range(self):
"""
Return the frame's number. This overrides the
get_frame_range implementation in Frame so it always
returns a single frame. If the pre-process's creator
layer has no valid range then the pre-process
range should be None as well.
@rtype: String
@return: The frame number.
"""
seq = self.__creator.get_frame_range()
if not seq:
return None
fs = FileSequence.FrameSet(seq)
return str(fs[0])
def get_frame_range(self):
"""
Return the frame's number. This overrides the
get_frame_range implementation in Layer so it always
returns a single frame. Frames are immune to being
removed from the job if they do not instersect with
the job's frame range.
:rtype: String
:return: The frame number.
"""
# An outline's frame range might be None, in that case
# just return the default frame.
if self.get_outline().get_frame_range():
seq = FileSequence.FrameSet(self.get_outline().get_frame_range())
return str(seq[0])
return DEFAULT_FRAME_RANGE
def get_local_frame_set(self, start_frame):
"""
Set the local frame set. The local frame set is the frame
list that must be handled by the execute() function. The local
frame set can have more than one frame when chunk_size is greater
than 1.
@type start_frame: int
@param start_frame: the starting of the frame set.
"""
chunk = self.get_chunk_size()
if chunk == 1:
return util.make_frame_set([int(start_frame)])
else:
local_frame_set = []
#
# Remove the duplicates out of our frame range.
#
frame_range = FileSequence.FrameSet(self.get_frame_range())
frame_set = util.deaggregate_frame_set(frame_range)
#
# Now find the index for the current frame and start
# frame there. Find all of frames this instance
# is responsible for.
#
idx = frame_set.index(int(start_frame))
for i in range(idx, idx + chunk):
try:
if frame_set[i] in local_frame_set:
continue
local_frame_set.append(frame_set[i])
except IndexError:
break
if not local_frame_set:
raise LayerException(
"Frame %d is outside of the frame range." % start_frame)
else:
return util.make_frame_set(local_frame_set)