def METHOD_NAME(self):
    if len(self.Images) == 0:
        self.Output.meta.NOTREADY = True
        return
    # Sanity check
    stacked_axiskey = self.AxisFlag.value
    nonstacked_tagged_shape = self.Images[0].meta.getTaggedShape()
    del nonstacked_tagged_shape[stacked_axiskey]
    nonstacked_shape = tuple(nonstacked_tagged_shape.values())
    input_axes = self.Images[0].meta.getAxisKeys()
    first_dtype = self.Images[0].meta.dtype
    for slot in self.Images[1:]:
        assert stacked_axiskey in slot.meta.getAxisKeys(), "Can't stack on an axis that doesn't exist yet."
        assert (
            input_axes == slot.meta.getAxisKeys()
        ), "All stacked images must have the same axis order: {} != {}".format(input_axes, slot.meta.getAxisKeys())
        assert slot.meta.dtype == first_dtype, "Can't stack images with different dtypes"
        tagged_shape = slot.meta.getTaggedShape()
        del tagged_shape[stacked_axiskey]
        assert (
            tuple(tagged_shape.values()) == nonstacked_shape
        ), "Can't stack images whose shapes differ (other than the stacked axis itself)"
    stacked_sizes = []
    stacked_channel_names = []
    for slot_index, slot in enumerate(self.Images):
        stacked_sizes.append(slot.meta.getTaggedShape()[stacked_axiskey])
        if slot.meta.channel_names:
            stacked_channel_names += slot.meta.channel_names
        else:
            slot_stacked_size = slot.meta.getTaggedShape()[stacked_axiskey]
            stacked_channel_names += ["stacked-image-{}-{}".format(slot_index, i) for i in range(slot_stacked_size)]
    # Compute output ranges for each input.
    # For example, if inputs have length 10, 15, 20,
    # stacked_output_ranges = [(0, 10), (10, 25), (25, 45)]
    stacked_range_stops = [0] + list(np.add.accumulate(stacked_sizes))
    self.stacked_output_ranges = list(zip(stacked_range_stops[:-1], stacked_range_stops[1:]))
    # Assign output metadata
    self.Output.meta.assignFrom(self.Images[0].meta)
    stacked_axisindex = self.Images[0].meta.getAxisKeys().index(stacked_axiskey)
    output_shape = list(nonstacked_shape)
    output_shape.insert(stacked_axisindex, sum(stacked_sizes))
    self.Output.meta.shape = tuple(output_shape)
    self.Output.meta.channel_names = stacked_channel_names
    ideal_blockshape = self.Output.meta.ideal_blockshape
    if ideal_blockshape is not None:
        ideal_blockshape = (
            tuple(ideal_blockshape[:stacked_axisindex]) + (1,) + tuple(ideal_blockshape[stacked_axisindex + 1 :])
        )
        self.Output.meta.ideal_blockshape = ideal_blockshape
    max_blockshape = self.Output.meta.max_blockshape
    if max_blockshape is not None:
        max_blockshape = max_blockshape[:stacked_axisindex] + (1,) + max_blockshape[stacked_axisindex + 1 :]
        self.Output.meta.max_blockshape = max_blockshape