Python imageio.mimwrite方法代码示例

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def make_gif(screenshot_dir_path,name = "test_recap",suffix=".gif",duration=2):
    "Creates gif of the screenshots"
    gif_name = None
    images = []

    if "/" in name:
        name=name.split("/")[-1]

    filenames = os.listdir(screenshot_dir_path)
    if len(filenames) != 0:
        gif_name = os.path.join(screenshot_dir_path, name + suffix)
        for files in sorted(filenames):
            images.append(imageio.imread(os.path.join(screenshot_dir_path, files)))
        imageio.mimwrite(gif_name, images, duration=duration)

    return gif_name 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def main():
    assert len(sys.argv) >= 2
    d = sys.argv[1]

    fps = glob(osp.join(d, '*.jpg'))
    fps = sorted(fps, key=lambda x: int(x.split('/')[-1].replace('.jpg', '')))

    imgs = []
    for fp in fps:
        img = imageio.imread(fp)
        imgs.append(img)

    if len(sys.argv) >= 3:
        imageio.mimwrite(sys.argv[2], imgs, fps=24, macro_block_size=None)
    else:
        imageio.mimwrite(osp.basename(d) + '.mp4', imgs, fps=24, macro_block_size=None) 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def make_banner(self, text: str, colour: str) -> BytesIO:
        im = Image.new("RGBA", (300, 100), (0, 0, 0, 0))
        font = ImageFont.truetype(str(bundled_data_path(self) / "impact.ttf"), 18)
        draw = ImageDraw.Draw(im)
        size_w, size_h = draw.textsize(text, font=font)
        W, H = (size_w + 25, 100)

        images = []
        for i in range(0, W):
            im = Image.new("RGBA", (W, H), colour)
            draw = ImageDraw.Draw(im)
            draw.text((((W - size_w) / 2) - i, (100 - size_h) / 2), text, font=font, fill="white")
            draw.text((10 + W - i, (100 - size_h) / 2), text, font=font, fill="white")
            images.append(np.array(im))

        temp = BytesIO()
        temp.name = "temp.gif"
        imageio.mimwrite(temp, images, "gif", duration=0.02)
        temp.seek(0)
        return temp 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def save_observation_series_to_gif(batched_observation_series,
                                   fpath,
                                   solved_states=None):
    """Saves a list of arrays of intermediate scenes as a gif."""
    max_steps = max(len(img) for img in batched_observation_series)
    images_per_step = []
    for step in range(max_steps):
        images_for_step = []
        for i, images in enumerate(batched_observation_series):
            real_step = min(len(images) - 1, step)
            if solved_states is None:
                solved = None
            else:
                solved = solved_states[i]
            images_for_step.append(
                observations_to_uint8_rgb(images[real_step], is_solved=solved))
        images_for_step = np.concatenate(images_for_step, axis=1)
        images_per_step.append(images_for_step)

    imageio.mimwrite(fpath, images_per_step, format="gif") 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def save_gif(self, filename=None):
        """Save the stored GIF frames to a file.

        To use this asynchronously, run the viewer with the ``record``
        flag and the ``run_in_thread`` flags set.
        Kill the viewer after your desired time with
        :meth:`.Viewer.close_external`, and then call :meth:`.Viewer.save_gif`.

        Parameters
        ----------
        filename : str
            The file to save the GIF to. If not specified,
            a file dialog will be opened to ask the user where
            to save the GIF file.
        """
        if filename is None:
            filename = self._get_save_filename(['gif', 'all'])
        if filename is not None:
            self.viewer_flags['save_directory'] = os.path.dirname(filename)
            imageio.mimwrite(filename, self._saved_frames,
                             fps=self.viewer_flags['refresh_rate'],
                             palettesize=128, subrectangles=True)
        self._saved_frames = [] 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def make_anishot():
    image = Image.fromarray(imageio.imread(ARGS.input.name))
    frames = []

    if ARGS.zoom_steps:
        make_zoomin(image, frames)
    make_scroll(image, frames)

    imageio.mimwrite(ARGS.output,
                     map(lambda f: numpy.array(f[0]), frames),
                     duration=list(map(lambda f: f[1], frames))) 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def _save_gif(self):
        # Get save file location
        try:
            root = Tk()
            fn = ''
            if self._save_filename:
                fn = '{}.gif'.format(self._save_filename)
            filename = filedialog.asksaveasfilename(initialfile = fn,
                                                    initialdir = (self._save_directory or os.getcwd()),
                                                    title = 'Select file save location',
                                                    filetypes = (('gif files','*.gif'),
                                                                ('all files','*.*')))
        except:
            logging.warning('Cannot use Tkinter file dialogs over SSH')
            self._saved_frames = []
            return

        root.destroy()
        if filename == ():
            self._saved_frames = []
            return
        else:
            self._save_directory = os.path.dirname(filename)

        imageio.mimwrite(filename, self._saved_frames, fps=30.0, palettesize=128, subrectangles=True)

        self._saved_frames = [] 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def _save_movie_data(fname, data, fps, fmt):
    if fmt == 'gif':
        imageio.mimwrite(fname+'.gif', data,
                         duration=1/fps, subrectangles=True)
    else:
        imageio.mimwrite(fname + '.' + fmt, data,
                         fps=fps, macro_block_size=SPRITE_SIZE,
                         ffmpeg_log_level='quiet') 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def png2tiff(ofn: Path, pat: str, indir: Path = None):
    """
    convert series of PNG, which may not be exactly the same shape,
    to a multipage TIFF (in the same directory)

    alternatives: use ImageMagick from command line, or Wand.
    however, since the files are grouped in a specific weird way, the histfeas program
    worked best to have this perhaps ImageMagick duplicative functionality in
    Python/imageio/skimage.
    """
    if resize is None:
        raise ImportError('pip install scikit-image')

    ofn = Path(ofn).expanduser()
    indir = ofn.parent if indir is None else Path(indir).expanduser()
# %% convert these sets of images to multipage image
    flist = sorted(indir.glob(pat))  # yes, sorted()
    if not flist:
        raise FileNotFoundError('found no files with {pat} in {ofn}')

    im0 = imageio.imread(flist[0])  # priming read
    images = np.empty((len(flist), *im0.shape), dtype=im0.dtype)
    for i, f in enumerate(flist):
        im = imageio.imread(f)
        images[i, ...] = resize(im, im0.shape, mode='edge')  # they are all of slightly different shape

    imageio.mimwrite(ofn, images) 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def save_data(self):
        if self.base_dir is not None:
            if self.dc is not None:
                # save the stimulus movie if it is generated
                movie, movie_times = self.window_display.widget_display.get_movie()
                if movie is not None:
                    if self.stim_movie_format == "h5":
                        movie_dict = dict(
                            movie=np.stack(movie, 0), movie_times=movie_times
                        )
                        fl.save(
                            self.filename_base() + "stim_movie.h5",
                            movie_dict,
                            compression="blosc",
                        )
                    elif self.stim_movie_format == "mp4":
                        imageio.mimwrite(
                            self.filename_base() + "stim_movie.mp4",
                            movie,
                            fps=30,
                            quality=None,
                            ffmpeg_params=[
                                "-pix_fmt",
                                "yuv420p",
                                "-profile:v",
                                "baseline",
                                "-level",
                                "3",
                            ],
                        )
                    else:
                        raise Exception(
                            "Tried to write the stimulus video into an unsupported format"
                        )
        super().save_data() 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def save_animation(list_of_animated_images, image_path, fps):
  full_size_images = []
  for single_images in zip(*list_of_animated_images):
    full_size_images.append(
        pad_around(add_below(padded_grid(list(single_images)))))
  imageio.mimwrite(image_path, full_size_images, fps=fps) 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def _make_gif(input_png_path):
  png_filenames = [t for t in os.listdir(input_png_path) if t.endswith('.png')]
  png_filenames = sort_filename(png_filenames)
  out_gif_filename = os.path.join(input_png_path, 'plot.gif')
  images = []
  for filename in png_filenames:
    images.append(imageio.imread(os.path.join(input_png_path, filename)))
  imageio.mimwrite(out_gif_filename, images, duration=0.5, loop=0) 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def face_transition(self, images: list) -> BytesIO:
        img_list = []
        # base = Image.open(images[-1])
        for image in images[:-1]:
            overlay = Image.open(image)
            overlay = overlay.resize((256, 256), Image.ANTIALIAS)
            overlay = overlay.convert("RGBA")
            if len(overlay.split()) != 4:
                alpha = Image.new("L", overlay.size, 255)
            else:
                alpha = overlay.convert("L")  # Image.new("L", overlay.size, 255)
            overlay.putalpha(alpha)
            for i in range(0, 50):
                base_img = Image.open(images[-1])
                base_img = base_img.convert("RGBA")
                base_img = base_img.resize((256, 256), Image.ANTIALIAS)
                paste_mask = overlay.split()[3].point(lambda x: x * i / 50)
                base_img.paste(overlay, (0, 0), paste_mask)
                img_list.append(np.array(base_img))
            for i in range(49, -1, -1):
                base_img = Image.open(images[-1])
                base_img = base_img.convert("RGBA")
                base_img = base_img.resize((256, 256), Image.ANTIALIAS)
                paste_mask = overlay.split()[3].point(lambda x: x * i / 50)
                base_img.paste(overlay, (0, 0), paste_mask)
                img_list.append(np.array(base_img))
        # print(len(img_list))
        temp = BytesIO()
        temp.name = "merge.gif"
        imageio.mimwrite(temp, img_list, "gif", duration=0.02)
        return temp 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def compose_gifs_compact(input_fpathes, output_fpath):
    """Create progressin for first and last frames over time."""
    first_and_last_per_batch_id = []
    for fname in input_fpathes:
        data = imageio.mimread(fname)
        data = np.concatenate([data[0], data[-1]], axis=0)
        first_and_last_per_batch_id.append(data)
    if first_and_last_per_batch_id:
        imageio.mimwrite(output_fpath, first_and_last_per_batch_id) 

# 需要导入模块: import imageio [as 别名]
# 或者: from imageio import mimwrite [as 别名]
def compose_gifs(input_fpathes, output_fpath):
    """Concatenate and sync all gifs."""
    all_data = []
    for fname in input_fpathes:
        all_data.append(imageio.mimread(fname))
    max_timestamps = max(len(data) for data in all_data)

    def _pad(data):
        return data + [data[-1]] * (max_timestamps - len(data))

    all_data = np.concatenate([_pad(data) for data in all_data], 1)
    imageio.mimwrite(output_fpath, all_data)