Fügen Sie Videos mit OpenCV + Python einen gefälschten Tilt-Shift-Effekt hinzu

Die Quelle ist https://github.com/osoken/tiltshift_effector

Ein Python-Skript, das einen gefälschten Tilt-Shift-Effekt auf eine Videodatei wie ".mov" anwendet. Ich habe "Numpy", "Scipy", "OpenCV", "Pillow" verwendet. Für Python 2.7.

Das Prinzip ist einfach: Kombinieren Sie einfach das Originalbild und das unscharfe Bild, während Sie es maskieren. Original

Maske

Verschwommenes Bild

Nach der Synthese

Aus Gründen der Klarheit ist es ziemlich stark aufgehängt.

Eine Funktion, die eine Maske generiert.

def gen_mask(sz, t, tc, c, bc):
  bounds = (0,limit_value(int(sz[1]*t),0,sz[1]),limit_value(int(sz[1]*(t+tc)),0,sz[1]),limit_value(int(sz[1]*(t+tc+c)),0,sz[1]),limit_value(int(sz[1]*(t+tc+c+bc)),0,sz[1]),sz[1]);
  mask = np.array(Image.new('L', sz));
  mask[bounds[0]:bounds[1],:] = 255;
  for i in range(bounds[1],bounds[2]):
    mask[i,:] = 255 - int(255.0/float( bounds[2] - bounds[1] ) * float(i - bounds[1]));
  mask[bounds[3]:bounds[2],:] = 0;
  for i in range(bounds[3],bounds[4]):
    mask[i,:] = int(255.0/float( bounds[4] - bounds[3] ) * float(i - bounds[3]));
  mask[bounds[4]:bounds[5],:] = 255;
  mask = Image.fromarray(mask);
  return mask;

sz ist ein Taple von (Breite, Höhe). "t", "tc", "c", "bc" sind Zahlen von "0,0" bis "1,0", "t" ist der obere weiße Bereich, "c" ist der mittlere schwarze Bereich, "tc" ist " Zwischen t "und" c "drückt" bc "die Breite des Gradienten zwischen" c "und dem weißen Bereich darunter aus, wobei das Gesamtverhältnis" 1,0 "beträgt.

Um das unscharfe Bild zu erzeugen, habe ich den gaussian_filter in scipy so wie er ist verwendet.

def gen_blurred_image(image, blur_factor):
  if blur_factor == 0:
    return image;
  im = np.array(image);
  return Image.fromarray(ndimage.gaussian_filter(im, sigma=[blur_factor, blur_factor, 0]));

Es ist sinnlos, die Variable "image" in den Typ "image" von "PIL" zu konvertieren, sie nur zum Filtern in den Typ "numpy.array" zu konvertieren und sie sofort zurückzugeben, jedoch unter Berücksichtigung anderer Operationen Es sieht aus wie das ... blur_factor ist die Stärke der Unschärfe, angegeben als schwebende Fraktion.

Kombinieren Sie die Maske und das unscharfe Bild mit der Paste-Funktion von PIL.

def paste_image(base, layer, mask):
  im = base;
  im.paste(layer, mask = mask);
  return im;

Sobald Sie fertig sind, müssen Sie nur noch das Video öffnen und für jedes Bild dieselbe Verarbeitung anwenden.

  cap = cv2.VideoCapture('input.mov');
  orig_size = (int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)),int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)));
  out = cv2.VideoWriter('output.mov', cv2.cv.CV_FOURCC('m','p','4','v'), int(cap.get(cv2.cv.CV_CAP_PROP_FPS)), orig_size);
  mask = gen_mask(orig_size, 0.4, 0.15, 0.05, 0.1);
  while cap.isOpened():
    ret,im_orig = cap.read();
    if ret == True:
      im = Image.fromarray(im_orig);
      im_blur = gen_blurred_image(im, 2.0);
      im = np.array(paste_image(im, im_blur, mask));
      cv2.imshow('view', im);
      out.write(im);
      key = cv2.waitKey(1);
      if key == 27:
        break;
    else:
      break;

  out.release();
  cap.release();
  cv2.destroyAllWindows();

Die Version im Repository verarbeitet Eingabeoptionen usw., sodass die Anzahl der Zeilen groß ist, aber im Wesentlichen ist dies so. Ich passe auch die Bildqualität und Sättigung an. Der letzte key == 27 in der Schleife endet vorzeitig mit esc.