Comment lire une image à partir d'YUV fichier dans OpenCV?

J'ai écrit un code python pour lire YUV NV21 flux à partir d'un fichier binaire.

import cv2
import numpy as np

class VideoCaptureYUV:
    def __init__(self, filename, size):
        self.height, self.width = size
        self.frame_len = self.width * self.height * 3 /2
        self.f = open(filename, 'rb')
        self.shape = (int(self.height*1.5), self.width)

    def read_raw(self):
        try:
            raw = self.f.read(self.frame_len)
            yuv = np.frombuffer(raw, dtype=np.uint8)
            yuv = yuv.reshape(self.shape)
        except Exception as e:
            print str(e)
            return False, None
        return True, yuv

    def read(self):
        ret, yuv = self.read_raw()
        if not ret:
            return ret, yuv
        bgr = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR_NV21)
        return ret, bgr


if __name__ == "__main__":
    #filename = "data/20171214180916RGB.yuv"
    filename = "data/20171214180916IR.yuv"
    size = (480, 640)
    cap = VideoCaptureYUV(filename, size)

    while 1:
        ret, frame = cap.read()
        if ret:
            cv2.imshow("frame", frame)
            cv2.waitKey(30)
        else:
            break

OriginalL'auteur xianyanlin

Mise à JOUR il y a une version plus récente du code ici: https://github.com/chelyaev/opencv-yuv

Je poste un code qui va lire un unique YUV 4:2:0 plane fichier image. Vous pouvez appliquer directement à la plupart YUV fichiers (il suffit de garder la lecture à partir de la même FILE objet). Le exception de cela est lorsque vous traitez avec YUV fichiers d'en-tête (en général, ils ont une *.y4m extension). Si vous voulez traiter avec ces fichiers, vous avez deux options:

1. Écrire votre propre fonction pour consommer les données d'en-tête de la FILE objet avant d'utiliser le code ci-dessous
2. Bande les en-têtes à partir de *.y4m images (à l'aide de ffmpeg ou un outil similaire). C'est l'option que je préfère car c'est le plus simple.

Il permettra aussi de ne pas travailler pour toute autre forme de format YUV (non-planaire, différents chroma décimation). @Stephane a souligné, il y a de nombreux formats (et la plupart d'entre eux n'ont pas d'identifier les en-têtes), qui est probablement pourquoi OpenCV ne prend pas en charge hors de la boîte.

Mais de travailler avec eux, c'est assez simple:

• Commencer avec une image et ses dimensions (ceci est requis lors de la lecture d'un fichier YUV)
• Lire la luminance et la chrominance en 3 les images
• Haut de gamme chroma images par un facteur de 2 à rémunération pour la chrominance décimation. Note qu'il y a effectivement plusieurs des façons de compenser pour la chrominance décimation. Suréchantillonnage est juste le plus simple
• Combiner en YUV image. Si vous voulez RVB, vous pouvez utiliser cvCvtColor.

Enfin, le code:

IplImage * 
cvLoadImageYUV(FILE *fin, int w, int h)
{
    assert(fin);

    IplImage *py      = cvCreateImage(cvSize(w,    h), IPL_DEPTH_8U, 1);
    IplImage *pu      = cvCreateImage(cvSize(w/2,h/2), IPL_DEPTH_8U, 1);
    IplImage *pv      = cvCreateImage(cvSize(w/2,h/2), IPL_DEPTH_8U, 1);
    IplImage *pu_big  = cvCreateImage(cvSize(w,    h), IPL_DEPTH_8U, 1);
    IplImage *pv_big  = cvCreateImage(cvSize(w,    h), IPL_DEPTH_8U, 1);
    IplImage *image   = cvCreateImage(cvSize(w,    h), IPL_DEPTH_8U, 3);
    IplImage *result  = NULL;

    assert(py);
    assert(pu);
    assert(pv);
    assert(pu_big);
    assert(pv_big);
    assert(image);

    for (int i = 0; i < w*h; ++i)
    {
        int j = fgetc(fin);
        if (j < 0)
            goto cleanup;
        py->imageData[i] = (unsigned char) j;
    }

    for (int i = 0; i < w*h/4; ++i)
    {
        int j = fgetc(fin);
        if (j < 0)
            goto cleanup;
        pu->imageData[i] = (unsigned char) j;
    }

    for (int i = 0; i < w*h/4; ++i)
    {
        int j = fgetc(fin);
        if (j < 0)
            goto cleanup;
        pv->imageData[i] = (unsigned char) j;
    }

    cvResize(pu, pu_big, CV_INTER_NN);
    cvResize(pv, pv_big, CV_INTER_NN);
    cvMerge(py, pu_big, pv_big, NULL, image);

    result = image;

cleanup:
    cvReleaseImage(&pu);
    cvReleaseImage(&pv);

    cvReleaseImage(&py);
    cvReleaseImage(&pu_big);
    cvReleaseImage(&pv_big);

    if (result == NULL)
        cvReleaseImage(&image);

    return result;
}

OriginalL'auteur mpenkov

J'ai rencontré le même problème. Ma solution est
1. lire un yuv image (comme I420) à un objet de type string "yuv".
2. convertir le yuv cadre de BGR24 format. J'utilise libyuv de le faire. Il est facile d'écrire un wrapper python pour libyuv fonctions. maintenant, vous obtenez un autre objet de type string "bgr" avec BGR24 format.
3. utilisation de numpy.fromstring pour obtenir l'image de l'objet à partir de la "bgr" objet de type string. vous avez besoin de changer la forme de l'objet image.

Ci-dessous est un simple yuv viewer pour votre référence.

import cv2
# below is the extension wrapper for libyuv
import yuvtorgb
import numpy as np

f = open('i420_cif.yuv', 'rb')

w = 352
h = 288
size = 352*288*3/2

while True:
    try:
        yuv = f.read(size)
    except:
        break
    if len(yuv) != size:
        f.seek(0, 0)
        continue

    bgr = yuvtorgb.i420_to_bgr24(yuv, w, h)

    img = np.fromstring(bgr, dtype=np.uint8)
    img.shape = h,w,3

    cv2.imshow('img', img)

    if cv2.waitKey(50) & 0xFF == ord('q'):
        break

cv2.destroyAllWindows()

OriginalL'auteur Yi Wang