示例#1
0
        def load_clip(index):
            image = self.sequence[index]
            text = titles[index]
            if text.startswith("W:"):
                text = text[2:]
                show_full_height = True
            else:
                show_full_height = False
            if height is None and width is None:
                clip = ImageClip(image, duration=image_duration)
            else:
                if zoom_images:
                    clip = ImageClip(image, duration=image_duration) \
                            .fx(image_effect, screensize=(width, height), \
                            duration=20, show_full_height=show_full_height)
                elif show_full_height:
                    clip = ImageClip(image, duration=image_duration) \
                            .fx(resize, height=height).set_position('center',
                                    'center')
                    clip = CompositeVideoClip([clip], size=(width, height))

                else:
                    clip = ImageClip(image, duration=image_duration) \
                            .fx(resize, height=height, width=width)
            #Adds text label etc. on clip
            clip = make_clip(clip, text, height, width, font, font_color,
                             fontsize)
            return clip
示例#2
0
    def __init__(self,
                 img,
                 ismask=False,
                 transparent=True,
                 fromalpha=False,
                 duration=None,
                 dpi=96,
                 width=None,
                 height=None):
        self.svg = svgutils.transform.fromfile(img)
        svg_bytestring = self.svg.to_str()
        png_file = io.BytesIO()
        if width is not None and height is not None:
            current_width = float(self.svg.width.replace("px", ""))
            current_height = float(self.svg.height.replace("px", ""))
            scale = max(height / current_height, width / current_width)
            cairosvg.svg2png(bytestring=svg_bytestring,
                             write_to=png_file,
                             parent_width=width,
                             parent_height=height,
                             scale=scale)
        else:
            #Converts to png and saves to bytestring
            cairosvg.svg2png(bytestring=svg_bytestring, write_to=png_file)

        #np_img = svg_to_npim(svg_bytestring, dpi)
        np_img = imread(png_file.getvalue())
        ImageClip.__init__(self,
                           np_img,
                           ismask=ismask,
                           transparent=transparent,
                           fromalpha=fromalpha,
                           duration=duration)
示例#3
0
def render():
    if img1 is None:
        alert = QMessageBox()
        alert.setText('64비트 이미지를 선택해주세요.')
        alert.exec_()
        return

    if not pixelized:
        alert = QMessageBox()
        alert.setText('픽셀화를 해주세요.')
        alert.exec_()
        return

    if img2 is None:
        alert = QMessageBox()
        alert.setText('128비트 이미지를 선택해주세요.')
        alert.exec_()
        return

    image = Image.open(img2)
    resize(image).save('./resource/128bit.png')
    clips = [ImageClip(f'./resource/{m}').set_duration(1) for m in ['1bit.png', '2bit.png', '4bit.png', '8bit.png']]
    clips.append(ImageClip('./resource/16bit.png').set_duration(1.6))
    clips.append(ImageClip('./resource/32bit.png').set_duration(1.8))
    clips.append(ImageClip('./resource/64bit.png').set_duration(2))
    clips.append(ImageClip('./resource/128bit.png').set_duration(1))
    concat_clip = concatenate_videoclips(clips, method="compose")
    concat_clip.audio = AudioFileClip(r"./resource/audio.mp3")
    concat_clip.write_videofile("result.mp4", fps=24)
    
    alert = QMessageBox()
    alert.setText('렌더링 완료 result.mp4가 생성되었습니다.')
    alert.exec_()
示例#4
0
def test_issue_285():
    clip_1, clip_2, clip_3 = (
        ImageClip("media/python_logo.png", duration=10),
        ImageClip("media/python_logo.png", duration=10),
        ImageClip("media/python_logo.png", duration=10),
    )
    merged_clip = concatenate_videoclips([clip_1, clip_2, clip_3])
    assert merged_clip.duration == 30
示例#5
0
文件: ve.py 项目: huvipg/python
def addlogo(file_dir,img="",time=20,X=30,Y=30):
   
    clip = VideoFileClip(file_dir)
    img_clip = ImageClip(img)   #位置
    img_clip = img_clip.set_pos((X,Y)).set_duration(time)
    clip = CompositeVideoClip([clip, img_clip])
    filen = os.path.basename(file_dir)
    clip.write_videofile(work_path+"\\"+filen)
    clip.close()
示例#6
0
def find_objects(clip, size_threshold=500, preview=False):
    """
    Returns a list of ImageClips representing each a separate object on
    the screen.

    size_threshold : all objects found with size < size_threshold will be
         considered false positives and will be removed

    """

    image = clip.get_frame(0)
    if not clip.mask:
        clip = clip.add_mask()

    mask = clip.mask.get_frame(0)
    labelled, num_features = ndi.measurements.label(image[:, :, 0])

    # find the objects
    slices = []
    for obj in ndi.find_objects(labelled):
        if mask[obj[0], obj[1]].mean() <= 0.2:
            # remove letter holes (in o,e,a, etc.)
            continue
        if image[obj[0], obj[1]].size <= size_threshold:
            # remove very small slices
            continue
        slices.append(obj)
    indexed_slices = sorted(enumerate(slices),
                            key=lambda slice: slice[1][1].start)

    letters = []
    for i, (sy, sx) in indexed_slices:
        """ crop each letter separately """
        sy = slice(sy.start - 1, sy.stop + 1)
        sx = slice(sx.start - 1, sx.stop + 1)
        letter = image[sy, sx]
        labletter = labelled[sy, sx]
        maskletter = (labletter == (i + 1)) * mask[sy, sx]
        letter = ImageClip(image[sy, sx])
        letter.mask = ImageClip(maskletter, is_mask=True)
        letter.screenpos = np.array((sx.start, sy.start))
        letters.append(letter)

    if preview:
        import matplotlib.pyplot as plt

        print(f"Found {num_features} objects")
        fig, ax = plt.subplots(2)
        ax[0].axis("off")
        ax[0].imshow(labelled)
        ax[1].imshow([range(num_features)], interpolation="nearest")
        ax[1].set_yticks([])
        plt.show()

    return letters
示例#7
0
def test_exifrotate():
    image_file = 'media/balloons_portrait.jpg'
    with ImageClip(image_file, duration=1) as clip:
        assert clip.img.meta['EXIF_MAIN']['ExifImageWidth'] == 4032
        assert clip.img.meta['EXIF_MAIN']['ExifImageHeight'] == 3024
        assert clip.img.meta['EXIF_MAIN']['Orientation'] == 6
        assert clip.size == (3024, 4032)

    with ImageClip(image_file, duration=1, 
                   imageio_params={'exifrotate': False}) as clip:
        assert clip.size == (4032, 3024)
示例#8
0
 def _make_circle(radius, color=(0, 255, 0)):
     circle_clip = ImageClip(
         circle((2 * radius, 2 * radius), (radius, radius), radius, color,
                (0, 0, 0)))
     #Make mask from it (channel 1 - green) since it's single color
     circle_mask = ImageClip(circle((2 * radius, 2 * radius),
                                    (radius, radius), radius, 1, 0),
                             ismask=True)
     #And use it as a mask
     circle_clip = circle_clip.set_mask(circle_mask)
     return circle_clip, radius
示例#9
0
def test_issue_782():
    clip = ImageClip('flower.png')
    clip_2 = clip.fx(vfx.mirror_y)
    if clip.image_transform == clip_2.image_transform:
        assert False
    else:
        pass
    clip_3 = clip.fx(vfx.mirror_x)
    if clip.image_transform == clip_3.image_transform:
        assert False
    else:
        assert True
示例#10
0
def findObjects(clip, rem_thr=500, preview=False):
    """ 
    Returns a list of ImageClips representing each a separate object on
    the screen.
        
    rem_thr : all objects found with size < rem_Thr will be
         considered false positives and will be removed
    
    """

    image = clip.get_frame(0)
    if clip.mask == None:
        clip = clip.add_mask()

    mask = clip.mask.get_frame(0)
    labelled, num_features = ndi.measurements.label(image[:, :, 0])

    # find the objects
    slices = ndi.find_objects(labelled)
    # cool trick to remove letter holes (in o,e,a, etc.)
    slices = [e for e in slices if mask[e[0], e[1]].mean() > 0.2]
    # remove very small slices
    slices = [e for e in slices if image[e[0], e[1]].size > rem_thr]
    # Sort the slices from left to right
    islices = sorted(enumerate(slices), key=lambda s: s[1][1].start)

    letters = []
    for i, (ind, (sy, sx)) in enumerate(islices):
        """ crop each letter separately """
        sy = slice(sy.start - 1, sy.stop + 1)
        sx = slice(sx.start - 1, sx.stop + 1)
        letter = image[sy, sx]
        labletter = labelled[sy, sx]
        maskletter = (labletter == (ind + 1)) * mask[sy, sx]
        letter = ImageClip(image[sy, sx])
        letter.mask = ImageClip(maskletter, ismask=True)
        letter.screenpos = np.array((sx.start, sy.start))
        letters.append(letter)

    if preview:
        import matplotlib.pyplot as plt

        print "found %d objects" % (num_features)
        fig, ax = plt.subplots(2)
        ax[0].axis("off")
        ax[0].imshow(labelled)
        ax[1].imshow([range(num_features)], interpolation="nearest")
        ax[1].set_yticks([])
        plt.show()

    return letters
def findObjects(clip, rem_thr=500, preview=False):
    """ 
    Returns a list of ImageClips representing each a separate object on
    the screen.
        
    rem_thr : all objects found with size < rem_Thr will be
         considered false positives and will be removed
    
    """

    image = clip.get_frame(0)
    if clip.mask is None:
        clip = clip.add_mask()

    mask = clip.mask.get_frame(0)
    labelled, num_features = ndi.measurements.label(image[:, :, 0])

    #find the objects
    slices = ndi.find_objects(labelled)
    # cool trick to remove letter holes (in o,e,a, etc.)
    slices = [e for e in slices if mask[e[0], e[1]].mean() > 0.2]
    # remove very small slices
    slices = [e for e in slices if image[e[0], e[1]].size > rem_thr]
    # Sort the slices from left to right
    islices = sorted(enumerate(slices), key=lambda s: s[1][1].start)

    letters = []
    for i, (ind, (sy, sx)) in enumerate(islices):
        """ crop each letter separately """
        sy = slice(sy.start - 1, sy.stop + 1)
        sx = slice(sx.start - 1, sx.stop + 1)
        letter = image[sy, sx]
        labletter = labelled[sy, sx]
        maskletter = (labletter == (ind + 1)) * mask[sy, sx]
        letter = ImageClip(image[sy, sx])
        letter.mask = ImageClip(maskletter, ismask=True)
        letter.screenpos = np.array((sx.start, sy.start))
        letters.append(letter)

    if preview:
        import matplotlib.pyplot as plt
        print("found %d objects" % (num_features))
        fig, ax = plt.subplots(2)
        ax[0].axis('off')
        ax[0].imshow(labelled)
        ax[1].imshow([range(num_features)], interpolation='nearest')
        ax[1].set_yticks([])
        plt.show()

    return letters
示例#12
0
    def _render_clip(self, frames):
        logger = logging.getLogger('logger')
        logger.info("Rendering video...")

        clips = []
        clip_duration = 1 / self.frame_rate
        for frame in frames:
            clip = ImageClip(frame.img)
            clip = clip.set_duration(clip_duration)
            clips.append(clip)
        final_clip = concatenate_videoclips(clips, method="chain")
        final_clip = final_clip.set_audio(AudioFileClip(self.audio.path))
        final_clip = final_clip.set_fps(self.frame_rate)
        return final_clip
示例#13
0
    def make_clip(self, value, width=None, height=None):
        """ value to show on gauge

        Width and height can also be changed since it's SVG
        """
        #calculates to which angle we need to turn cursor based on speed
        angle = self.map_speed(value)
#Turns the cursor. We need to use this instead of rotate function since we need
        #to forget previous transformations
        self.cursor.root.set("transform", "rotate(%f %f %f)" % (angle,
            self.cursor_x, self.cursor_y))
        svg_bytestring = self.svg.to_str()
        png_file = io.BytesIO()
        if width is not None and height is not None:
            current_width = float(self.svg.width)
            current_height = float(self.svg.height)
            scale = max(height/current_height, width/current_width)
            cairosvg.svg2png(bytestring=svg_bytestring,write_to=png_file,
                    parent_width=width, parent_height=height, scale=scale)
        else:
#Converts to png and saves to bytestring
            cairosvg.svg2png(bytestring=svg_bytestring,write_to=png_file)
#Reads as numpy image
#TODO: does transparency work?
        return ImageClip(imread(png_file.getvalue()), transparent=self.transparent)
示例#14
0
def test_PR_528(util):
    with ImageClip("media/vacation_2017.jpg") as clip:
        new_clip = scroll(clip, w=1000, x_speed=50)
        new_clip = new_clip.with_duration(0.2)
        new_clip.fps = 24
        new_clip.write_videofile(os.path.join(util.TMP_DIR, "pano.mp4"),
                                 logger=None)
示例#15
0
def freeze_at_end(clip, freeze_duration=None, total_duration=None):
    """
    Makes the clip freeze on its last frame.  With ``duration`` you can
    specify the duration of the freeze. With ``total_duration`` you can
    specify the total duration of the clip and the freeze (i.e. the
    duration of the freeze is automatically calculated). If neither
    is provided, the freeze will have an infinite length.
    """
    
    freezed_clip = ImageClip(clip.get_frame(clip.end))
    if total_duration:
        freeze_duration = total_duration - clip.duration
    if freeze_duration:
        freezed_clip = freezed_clip.set_duration(freeze_duration)
    
    return CompositeVideoClip([clip,freezed_clip.set_start(clip.end)])
示例#16
0
def chose2():
    print("This takes some time..")
    time.sleep(2)
    for (dirpath, dirnames, filenames) in walk(os.getcwd()):
        files.extend(filenames)
        break

    for i in files:
        if (i[-3:]) == "jpg":
            images.append(ImageClip(i).resize([640, 1136]).set_duration(3))
        if (i[-3:]) == "mp4":
            videos.append(VideoFileClip(i))

    final_clip = concatenate_videoclips(videos + images, method="compose")
    final_clip.write_videofile("input.mp4")

    time.sleep(2)

    stream = os.popen(
        r'ffmpeg -i input.mp4 -lavfi "[0:v]scale=1920*2:1080*2,boxblur=luma_radius=min(h\,w)/20:luma_power=1:chroma_radius=min(cw\,ch)/20:chroma_power=1[bg];[0:v]scale=-1:1080[ov];[bg][ov]overlay=(W-w)/2:(H-h)/2,crop=w=1920:h=1080" Output.mp4'
    )
    output = stream.read()

    os.rename(os.getcwd() + r"\input.mp4",
              os.getcwd() + r"\withBlackBorders.mp4")
    print("\nFinished! Enjoy Output.mp4")
示例#17
0
def test_afterimage():
    ai = ImageClip("media/afterimage.png")
    masked_clip = mask_color(ai, color=[0, 255, 1])  # for green
    some_background_clip = ColorClip((800, 600), color=(255, 255, 255))
    final_clip = CompositeVideoClip([some_background_clip, masked_clip],
                                    use_bgclip=True).with_duration(0.2)
    final_clip.write_videofile(os.path.join(TMP_DIR, "afterimage.mp4"), fps=30)
示例#18
0
def freeze_at_start(clip, freeze_duration=None, total_duration=None):
    """
    Makes the clip freeze on its last frame.  With ``duration`` you can
    specify the duration of the freeze. With ``total_duration`` you can
    specify the total duration of the clip and the freeze (i.e. the
    duration of the freeze is automatically calculated). If neither
    is provided, the freeze will have an infinite length.
    """
    
    freezed_clip = ImageClip(clip.get_frame(0))
    if total_duration:
        freeze_duration = total_duration - clip.duration
    if freeze_duration:
        freezed_clip = freezed_clip.set_duration(freeze_duration)
    
    return concatenate([freezed_clip,clip])
示例#19
0
def freeze_at_start(clip, freeze_duration=None, total_duration=None):
    """ Momentarily freeze the clip on its first frame.

    With ``duration``you can specify the duration of the freeze.
    With ``total_duration`` you can specify the total duration of
    the clip and the freeze (i.e. the duration of the freeze is
    automatically calculated). If neither is provided, the freeze
    will have an infinite length.
    """

    freezed_clip = ImageClip(clip.get_frame(0))
    if total_duration:
        freeze_duration = total_duration - clip.duration
    if freeze_duration:
        freezed_clip = freezed_clip.set_duration(freeze_duration)

    return concatenate([freezed_clip, clip])
示例#20
0
def define_image(op, ext_duration=None):
    """ Define a static image clip from source file.

        source   - absolute path to the file
        duration - duration in seconds
        ext_duration - clip to obtain the duration from

        Mainly used for intro/outro and static background.
    """
    if ext_duration:
        # clip = ImageClip(op.source, duration=find_video_period(ext_duration))
        clip = ImageClip(op.source, duration=ext_duration.duration)

    else:
        clip = ImageClip(op.source, duration=op.duration)

    return clip
示例#21
0
def test_find_objects(filename, expected_screenpos):
    clip = ImageClip(filename)
    objects = find_objects(clip)

    assert len(objects) == len(expected_screenpos)
    for i, object_ in enumerate(objects):
        assert np.array_equal(object_.screenpos,
                              np.array(expected_screenpos[i]))
示例#22
0
    def create_image_clip(image_filename):
        # having some encoding issues in moviepy
        if isinstance(image_filename, unicode):
            image_filename = image_filename.encode(sys.getdefaultencoding())

        image_filename = os.path.abspath(image_filename)
        assert (os.path.exists(image_filename))
        return ImageClip(image_filename)
示例#23
0
def freeze_at_end(clip, freeze_duration=None, total_duration=None, delta=0.05):
    """
    Makes the clip freeze on its last frame.  With ``duration`` you can
    specify the duration of the freeze. With ``total_duration`` you can
    specify the total duration of the clip and the freeze (i.e. the
    duration of the freeze is automatically calculated). If neither
    is provided, the freeze will have an infinite length.
    
    The clip is frozen on the frame at time (clip.duration - delta)
    """

    freezed_clip = ImageClip(clip.get_frame(clip.end - delta))
    if total_duration:
        freeze_duration = total_duration - clip.duration
    if freeze_duration:
        freezed_clip = freezed_clip.set_duration(freeze_duration)

    return CompositeVideoClip([clip, freezed_clip.set_start(clip.end)])
示例#24
0
 def generate_intro():
     logger.info('Generating intro...')
     color = (255, 255, 255)
     size = (1280, 720)
     clip = ColorClip(size, color, duration=3)
     logo = ImageClip(config.LOGO_PATH).set_duration(clip.duration) \
         .resize(width=400, height=200) \
         .set_pos(('center', 'center'))
     return CompositeVideoClip([clip, logo])
示例#25
0
def insert_image_into_frame(frame, face_image):
    im_insert = ImageClip(face_image)
    im_insert = painting.painting(im_insert)
    frame_mask = frame.mask.get_frame(0)

    size = frame.mask.size
    black_pixels = np.where(frame_mask == 0.0)
    black_start = (black_pixels[1][0], black_pixels[0][0])
    black_end = (black_pixels[1][-1], black_pixels[0][-1])
    black_size = (black_end[0] - black_start[0], black_end[1] - black_start[1])

    comp_clip = im_insert.resize(black_size)
    comp_clip = comp_clip.set_pos(black_start)

    composite = CompositeVideoClip([frame, comp_clip], frame.size)
    standardize_clip(composite)
    
    return composite
示例#26
0
def clip_from_path(path):
    if path == '':
        return None
    elif path.suffix.lower() in IMAGE_EXTENSIONS:
        from moviepy.video.VideoClip import ImageClip
        return ImageClip(str(path))
    else:
        from moviepy.video.io.VideoFileClip import VideoFileClip
        return VideoFileClip(str(path))
示例#27
0
 def add_pics(self, clip):
     logger.info('Adding pics...')
     pic_clip = [clip]
     for i in range(self.pic_num):
         x_pos, y_pos, x_size, y_size = self.generate_coordinates(clip)
         pic_path = config.PIC_PATH + str(i) + '.jpg'
         pic = ImageClip(pic_path).set_duration(clip.duration).resize((x_size, y_size)) \
             .set_pos((x_pos, y_pos)).add_mask().rotate(random.randint(-180, 180))
         pic_clip.append(pic)
     return CompositeVideoClip(pic_clip)
示例#28
0
def test_afterimage():
    ai = ImageClip("media/afterimage.png")
    masked_clip = mask_color(ai, color=[0, 255, 1])  # for green

    some_background_clip = ColorClip((800, 600), color=(255, 255, 255))

    final_clip = CompositeVideoClip([some_background_clip, masked_clip],
                                    use_bgclip=True)
    final_clip.duration = 5
    final_clip.write_videofile("/tmp/afterimage.mp4", fps=30)
示例#29
0
def createVideo(folder, file_movie_name):

    list_img = []
    for img in os.listdir(folder):
        list_img.append(folder + "/" + img)
        list_img.sort()
    clips = [ImageClip(m).set_duration(3) for m in list_img]

    concat_clip = concatenate_videoclips(clips, method="compose")
    concat_clip.write_videofile(file_movie_name, fps=24)
示例#30
0
    def create_silent_video(self, youtube=None, preview=False):
        log("Creating silent video", prnt=True)

        base_path = str(self.podcast.id) + '/' + str(self.episode.id)
        video_path = base_path + '.mp4'

        with NamedTemporaryFile(suffix='.mp4') as tf:
            with NamedTemporaryFile(suffix='.mp3') as _audio:
                self.videosyncepisode.update_sync_status({
                    'event':
                    'DOWNLOAD_AUDIO',
                    'timestamp':
                    arrow.utcnow().isoformat()
                })
                r = requests.get(self.audio_url, stream=True)
                for chunk in r.iter_content(chunk_size=4096):
                    _audio.write(chunk)
                _audio.seek(0)
                song = AudioSegment.from_file(File(_audio), format='mp3')

                sound_length = math.ceil(len(song) / 1000)

                self.videosyncepisode.update_sync_status({
                    'event':
                    'CREATE_VIDEO',
                    'timestamp':
                    arrow.utcnow().isoformat()
                })
                clip = ImageClip(self.videosyncepisode.artwork_path,
                                 duration=sound_length)
                clip.write_videofile(tf.name, fps=1, audio=_audio.name)

                self.videosyncepisode.update_sync_status({
                    'event':
                    'UPLOAD_VIDEO',
                    'timestamp':
                    arrow.utcnow().isoformat()
                })
                video_id = self.upload_video(youtube, tf.name)

                return video_id

        return None
示例#31
0
def generate_text_clip(text, number):
    filename = "tmp/" + name + "/clips/" + name + number + ".mp4"

    if not os.path.exists(filename):
        audio_filename = make_tts(text, number)
        audio = AudioFileClip(audio_filename)
        image = ImageClip(background_image).set_fps(30)
        video = image.set_duration(audio.duration)
        withaudio = video.set_audio(audio)

        fontsize = (len(text) + 10) / withaudio.w
        text_clip = TextClip(text,
                             fontsize=fontsize,
                             size=(withaudio.w, withaudio.h)).set_pos("center")

        final_clip = CompositeVideoClip(
            [withaudio, text_clip.set_duration(video.duration)])

        final_clip.write_videofile(filename)
    return filename
示例#32
0
def output_mp4(name, data, durations, max_workers=None, method='chain'):
    # sanity check the images
    sizes = {frame.shape for frame in data}
    assert method == 'compose' or len(sizes) == 1, sizes
    # turn the image into clips
    clips = [ImageClip(data, duration=d) for (data, d) in zip(data, durations)]
    # save the mp4
    movie = concatenate_videoclips(clips, method=method)
    movie.write_videofile(str(output_path / (name + '.mp4')),
                          fps=24,
                          threads=max_workers or cpu_count(),
                          bitrate='10M')
 def create_thumbnail(self):
     logger.info('Creating thumbnail...')
     color = (255, 255, 255)
     size = (1280, 720)
     background = ColorClip(size, color)
     logo = ImageClip(config.LOGO_PATH).set_duration(1) \
         .resize(width=400, height=200) \
         .set_pos(('center', 'center'))
     text = TextClip(txt=str(self.id), size=(500, 500)).set_position(
         ('center', 'bottom'))
     CompositeVideoClip([background, logo,
                         text]).save_frame(config.THUMB_PATH)
     logger.info('Thumbnail saved...')
示例#34
0
 def clip(self, frames_and_durations):
     if self.dynamic:
         clip = super().clip(frames_and_durations)
     else:
         clip = ImageClip(imageio.imread(
             next((output_path / self.dirname).glob('*.png'))),
                          duration=sum(frames_and_durations.values()))
     if self.margin:
         params = self.margin.copy()
         params['mar'] = params.pop('margin')
         params['color'] = white
         clip = margin(clip, **params)
     return clip
示例#35
0
文件: credits.py 项目: Zulko/moviepy
def credits1(creditfile, width, stretch=30, color='white', stroke_color='black',
             stroke_width=2, font='Impact-Normal', fontsize=60, gap=0):
    """

    Parameters
    -----------
    
    creditfile
      A text file whose content must be as follows: ::
        
        # This is a comment
        # The next line says : leave 4 blank lines
        .blank 4
        
        ..Executive Story Editor
        MARCEL DURAND
        
        ..Associate Producers
        MARTIN MARCEL
        DIDIER MARTIN
        
        ..Music Supervisor
        JEAN DIDIER
    
    width
      Total width of the credits text in pixels
      
    gap
      Horizontal gap in pixels between the jobs and the names
    
    color
      Color of the text. See ``TextClip.list('color')``
      for a list of acceptable names.

    font
      Name of the font to use. See ``TextClip.list('font')`` for
      the list of fonts you can use on your computer.

    fontsize
      Size of font to use

    stroke_color
      Color of the stroke (=contour line) of the text. If ``None``,
      there will be no stroke.

    stroke_width
      Width of the stroke, in pixels. Can be a float, like 1.5.
    
        
    Returns
    ---------
    
    image
      An ImageClip instance that looks like this and can be scrolled
      to make some credits:

          Executive Story Editor    MARCEL DURAND
             Associate Producers    MARTIN MARCEL
                                    DIDIER MARTIN
                Music Supervisor    JEAN DIDIER
              
    """

    # PARSE THE TXT FILE
    
    with open(creditfile) as f:
        lines = f.readlines()
    
    lines = filter(lambda x: not x.startswith('\n'), lines)
    texts = []
    oneline = True
    for l in lines:
        if not l.startswith('#'):
            if l.startswith('.blank'):
                for i in range(int(l.split(' ')[1])):
                    texts.append(['\n', '\n'])
            elif l.startswith('..'):
                texts.append([l[2:], ''])
                oneline = True
            else:
                if oneline:
                    texts.append(['', l])
                    oneline = False
                else:
                    texts.append(['\n', l])
               
    left, right = ["".join(l) for l in zip(*texts)]
    
    # MAKE TWO COLUMNS FOR THE CREDITS
    
    left, right = [TextClip(txt, color=color, stroke_color=stroke_color,
                            stroke_width=stroke_width, font=font,
                            fontsize=fontsize, align=al)
                   for txt, al in [(left, 'East'), (right, 'West')]]

    cc = CompositeVideoClip([left, right.set_pos((left.w+gap, 0))],
                            size=(left.w+right.w+gap, right.h),
                            bg_color=None)
    
    # SCALE TO THE REQUIRED SIZE
    
    scaled = resize(cc, width=width)
    
    # TRANSFORM THE WHOLE CREDIT CLIP INTO AN ImageCLip
    
    imclip = ImageClip(scaled.get_frame(0))
    amask = ImageClip(scaled.mask.get_frame(0), ismask=True)
    
    return imclip.set_mask(amask)
示例#36
0
            face_index = 0

    movie_clip = concatenate_videoclips(scenes)

    # Place the sound
    sound_path = pick_random_entry_from_dir('sources/soundtrack/')
    soundtrack = AudioFileClip(sound_path)
    soundtrack = soundtrack.subclip(0, 30)
    movie_clip = movie_clip.set_audio(soundtrack)

    return movie_clip


movie = create_movie(face_images)
gradient = color_gradient(size=(1280, 720),
    p1=(640, 60), p2=(640, 660),
    col1=np.array([195, 75, 99], 'uint8'),
    col2=np.array([127, 251, 19], 'uint8'),
    shape='linear')

gradient_clip = ImageClip(gradient)
gradient_clip = gradient_clip.set_opacity(0.20)
standardize_clip(gradient_clip)

movie = CompositeVideoClip([movie, gradient_clip], movie.size)
movie.duration = 30

movie.save_frame('frame.jpg')
#movie.preview(fps=10, audio=False)
#movie.duration = 1
movie.write_videofile('composite.mp4')
示例#37
0
def credits1(creditfile,width,stretch=30,color='white',
                 stroke_color='black', stroke_width=2,
                 font='Impact-Normal',fontsize=60):
    """
    
    The first credits I imagined. They take as argument a file like: ::
        
        # This is a comment
        # The next line says : leave 4 blank lines
        .blank 4
        
        ..Executive Story Editor
        MARCEL DURAND
        
        ..Associate Producers
        MARTIN MARCEL
        DIDIER MARTIN
        
        ..Music Supervisor
        JEAN DIDIER
        
    And produce an ImageClip that looks like :
    
        Executive Story Editor    MARCEL DURAND
           Associate Producers    MARTIN MARCEL
                                  DIDIER MARTIN
              Music Supervisor    JEAN DIDIER
    
    :param width: total width of the credits text
    :param stretch: stretch in pixels between the jobs and the names.
    
    The other keywords are passed to the ``TextClip``s
    """
    
    
    # PARSE THE TXT FILE
    
    with open(creditfile) as f:
        lines = f.readlines()
    
    lines = filter(lambda x:not x.startswith('\n'),lines) 
    texts = []
    oneline=True
    for l in  lines:
        if not l.startswith('#'):
            if l.startswith('.blank'):
                for i in range(int(l.split(' ')[1])):
                    texts.append(['\n','\n'])
            elif  l.startswith('..'):
                texts.append([l[2:],''])
                oneline=True
            else:
                if oneline:
                    texts.append(['',l])
                    oneline=False
                else:
                    texts.append(['\n',l])
               
    left,right = [ "".join(l) for l in zip(*texts)]
    
    # MAKE TWO COLUMNS FOR THE CREDITS
    
    left,right =  [TextClip(txt,color=color,stroke_color=stroke_color,
                                stroke_width=stroke_width,font=font,
                                fontsize=fontsize,align=al)
               for txt,al in [(left,'East'),(right,'West')]]
               

    cc = CompositeVideoClip( [left, right.set_pos((left.w+stretch,0))],
                             size = (left.w+right.w+stretch,right.h),
                             transparent=True)
    
    # SCALE TO THE REQUIRED SIZE
    
    scaled = cc.fx(resize , width=width)
    
    # TRANSFORM THE WHOLE CREDIT CLIP INTO AN ImageCLip
    
    imclip = ImageClip(scaled.get_frame(0))
    amask = ImageClip(scaled.mask.get_frame(0),ismask=True)
    
    return imclip.set_mask(amask)
示例#38
0
def credits1(creditfile,width,stretch=30,color='white',
                 stroke_color='black', stroke_width=2,
                 font='Impact-Normal',fontsize=60):
    """
    
    
    Parameters
    -----------
    
    creditfile
      A text file whose content must be as follows: ::
        
        # This is a comment
        # The next line says : leave 4 blank lines
        .blank 4
        
        ..Executive Story Editor
        MARCEL DURAND
        
        ..Associate Producers
        MARTIN MARCEL
        DIDIER MARTIN
        
        ..Music Supervisor
        JEAN DIDIER
    
    width
      Total width of the credits text in pixels
      
    gap
      Gap in pixels between the jobs and the names.
    
    **txt_kw
      Additional argument passed to TextClip (font, colors, etc.)
    
    
    
        
    Returns
    ---------
    
    image
       An ImageClip instance that looks like this and can be scrolled
       to make some credits :
        
        Executive Story Editor    MARCEL DURAND
           Associate Producers    MARTIN MARCEL
                                  DIDIER MARTIN
              Music Supervisor    JEAN DIDIER
              
    """
    
    
    # PARSE THE TXT FILE
    
    with open(creditfile) as f:
        lines = f.readlines()
    
    lines = filter(lambda x:not x.startswith('\n'),lines) 
    texts = []
    oneline=True
    for l in  lines:
        if not l.startswith('#'):
            if l.startswith('.blank'):
                for i in range(int(l.split(' ')[1])):
                    texts.append(['\n','\n'])
            elif  l.startswith('..'):
                texts.append([l[2:],''])
                oneline=True
            else:
                if oneline:
                    texts.append(['',l])
                    oneline=False
                else:
                    texts.append(['\n',l])
               
    left,right = [ "".join(l) for l in zip(*texts)]
    
    # MAKE TWO COLUMNS FOR THE CREDITS
    
    left,right =  [TextClip(txt,color=color,stroke_color=stroke_color,
                                stroke_width=stroke_width,font=font,
                                fontsize=fontsize,align=al)
               for txt,al in [(left,'East'),(right,'West')]]
               

    cc = CompositeVideoClip( [left, right.set_pos((left.w+gap,0))],
                             size = (left.w+right.w+gap,right.h),
                             transparent=True)
    
    # SCALE TO THE REQUIRED SIZE
    
    scaled = cc.fx(resize , width=width)
    
    # TRANSFORM THE WHOLE CREDIT CLIP INTO AN ImageCLip
    
    imclip = ImageClip(scaled.get_frame(0))
    amask = ImageClip(scaled.mask.get_frame(0),ismask=True)
    
    return imclip.set_mask(amask)