Skip to content

deeplabcut.utils.video_processor

Author: Hao Wu hwu01@g.harvard.edu You can find the directory for your ffmpeg bindings by: "find / | grep ffmpeg" and then setting it.

This is the helper class for video reading and saving in DeepLabCut. Updated by AM

You can set various codecs below, fourcc = cv2.VideoWriter_fourcc(*'MJPG') i.e. 'XVID'

Classes:

Name Description
VideoProcessor

Base class for a video processing unit, implementation is required for video
VideoProcessorCV

OpenCV implementation of VideoProcessor requires opencv-python==3.4.0.12.

VideoProcessor

Base class for a video processing unit, implementation is required for video loading and saving.

sh and sw are the output height and width respectively.

Methods:

Name Description
close

Implement your own.
create_video

Implement your own.
get_info

Implement your own.
get_video

Implement your own.
save_frame

Implement your own.
Source code in deeplabcut/utils/video_processor.py 
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
class VideoProcessor:
    """Base class for a video processing unit, implementation is required for video
    loading and saving.

    sh and sw are the output height and width respectively.
    """

    def __init__(self, fname="", sname="", nframes=-1, fps=None, codec="X264", sh="", sw=""):
        self.fname = fname
        self.sname = sname
        self.nframes = nframes
        self.codec = codec
        self.h = 0
        self.w = 0
        self.nc = 3
        self.i = 0

        try:
            if self.fname != "":
                self.vid = self.get_video()
                self.get_info()
                self.sh = 0
                self.sw = 0
            if self.sname != "":
                if sh == "" and sw == "":
                    self.sh = self.h
                    self.sw = self.w
                else:
                    self.sw = sw
                    self.sh = sh
                self.svid = self.create_video()

        except Exception as ex:
            print("Error: %s", ex)

        if fps is not None:  # Overwrite the video's FPS
            self.FPS = fps

    def load_frame(self):
        frame = self._read_frame()
        if frame is not None:
            self.i += 1
        return frame

    def height(self):
        return self.h

    def width(self):
        return self.w

    def fps(self):
        return self.FPS

    def counter(self):
        return self.i

    def frame_count(self):
        return self.nframes

    def get_video(self):
        """Implement your own."""
        pass

    def get_info(self):
        """Implement your own."""
        pass

    def create_video(self):
        """Implement your own."""
        pass

    def _read_frame(self):
        """Implement your own."""
        pass

    def save_frame(self, frame):
        """Implement your own."""
        pass

    def close(self):
        """Implement your own."""
        pass

close 

close()

Implement your own.

Source code in deeplabcut/utils/video_processor.py 
107
108
109
def close(self):
    """Implement your own."""
    pass

create_video 

create_video()

Implement your own.

Source code in deeplabcut/utils/video_processor.py 
95
96
97
def create_video(self):
    """Implement your own."""
    pass

get_info 

get_info()

Implement your own.

Source code in deeplabcut/utils/video_processor.py 
91
92
93
def get_info(self):
    """Implement your own."""
    pass

get_video 

get_video()

Implement your own.

Source code in deeplabcut/utils/video_processor.py 
87
88
89
def get_video(self):
    """Implement your own."""
    pass

save_frame 

save_frame(frame)

Implement your own.

Source code in deeplabcut/utils/video_processor.py 
103
104
105
def save_frame(self, frame):
    """Implement your own."""
    pass

VideoProcessorCV

Bases: VideoProcessor

OpenCV implementation of VideoProcessor requires opencv-python==3.4.0.12.

Source code in deeplabcut/utils/video_processor.py 
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
class VideoProcessorCV(VideoProcessor):
    """OpenCV implementation of VideoProcessor requires opencv-python==3.4.0.12."""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def get_video(self):
        return cv2.VideoCapture(self.fname)

    def get_info(self):
        self.w = int(self.vid.get(cv2.CAP_PROP_FRAME_WIDTH))
        self.h = int(self.vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
        all_frames = int(self.vid.get(cv2.CAP_PROP_FRAME_COUNT))
        self.FPS = self.vid.get(cv2.CAP_PROP_FPS)
        self.nc = 3
        if self.nframes == -1 or self.nframes > all_frames:
            self.nframes = all_frames

    def create_video(self):
        fourcc = cv2.VideoWriter_fourcc(*self.codec)
        return cv2.VideoWriter(self.sname, fourcc, self.FPS, (self.sw, self.sh), True)

    def _read_frame(self):  # return RGB (rather than BGR)!
        # return cv2.cvtColor(np.flip(self.vid.read()[1],2), cv2.COLOR_BGR2RGB)
        success, frame = self.vid.read()
        if not success:
            return frame
        return np.flip(frame, 2)

    def save_frame(self, frame):
        if frame is not None:
            self.svid.write(np.flip(frame, 2))

    def close(self):
        if hasattr(self, "svid") and self.svid is not None:
            self.svid.release()
        if hasattr(self, "vid") and self.vid is not None:
            self.vid.release()