Masque de dégradé se fondant dans opencv python

Question

J'ai une image et une zone circulaire. Je dois tout brouiller, sauf pour la zone circulaire. Aussi je dois faire la frontière du cercle lisse.
L'entrée:

La sortie (fait dans l'image redactor avec un masque, mais je pense que opencv est en utilisant uniquement des masques bitmap):

Pour l'instant i ont un code en python, qui isn 't floue frontière du cercle.

def blur_image(cv_image, radius, center, gaussian_core, sigma_x): 
    blurred = cv.GaussianBlur(cv_image, gaussian_core, sigma_x) 
    h, w, d = cv_image.shape 
# masks 
    circle_mask = np.ones((h, w), cv_image.dtype) 
    cv.circle(circle_mask, center, radius, (0, 0, 0), -1) 
    circle_not_mask = np.zeros((h, w), cv_image.dtype) 
    cv.circle(circle_not_mask, center, radius, (2, 2, 2), -1) 
# Computing 
    blur_around = cv.bitwise_and(blurred, blurred, mask=circle_mask) 
    image_in_circle = cv.bitwise_and(cv_image, cv_image, mask=circle_not_mask) 
    res = cv.bitwise_or(blur_around, image_in_circle) 
    return res 

Version actuelle:
Comment puis-je brouiller la frontière du cercle? Dans l'exemple de sortie, j'ai utilisé le masque dégradé dans le programme. Y a-t-il quelque chose de similaire dans opencv?
MISE À JOUR 04,03
, j'ai essayé la formule de this answered topic et ce que je:

code:

def blend_with_mask_matrix(src1, src2, mask): 
    res = src2 * (1 - cv.divide(mask, 255.0)) + src1 * cv.divide(mask, 255.0) 
return res 

Ce code devrait fonctionner comme un semblable récent, mais il n'a pas . L'image en cercle est légèrement différente. Il a quelques problèmes de couleur. La question est toujours ouverte.

Answer 1

Donc le principal problème avec (mask/255) * blur + (1-mask/255)*another img était opérateurs. Ils ne travaillaient qu'avec un seul canal. Le prochain problème est de travailler avec les nombres flottants pour "lisser".
J'ai changé le code de mélange avec canal alpha à ceci:
1) que je prends tous les canaux pour les images source et masque
2) Exécution formule
3) La fusion des canaux

def blend_with_mask_matrix(src1, src2, mask): 
    res_channels = [] 
    for c in range(0, src1.shape[2]): 
     a = src1[:, :, c] 
     b = src2[:, :, c] 
     m = mask[:, :, c] 
     res = cv.add(
      cv.multiply(b, cv.divide(np.full_like(m, 255) - m, 255.0, dtype=cv.CV_32F), dtype=cv.CV_32F), 
      cv.multiply(a, cv.divide(m, 255.0, dtype=cv.CV_32F), dtype=cv.CV_32F), 
      dtype=cv.CV_8U) 
     res_channels += [res] 
    res = cv.merge(res_channels) 
    return res 

Et en tant que masque de dégradé, j'utilise simplement un cercle flou.

def blur_image(cv_image, radius, center, gaussian_core, sigma_x): 
    blurred = cv.GaussianBlur(cv_image, gaussian_core, sigma_x) 

    circle_not_mask = np.zeros_like(cv_image) 
    cv.circle(circle_not_mask, center, radius, (255, 255, 255), -1) 
#Smoothing borders 
    cv.GaussianBlur(circle_not_mask, (101, 101), 111, dst=circle_not_mask) 
# Computing 
    res = blend_with_mask_matrix(cv_image, blurred, circle_not_mask) 
    return res 

Résultat:

Il travaille un peu plus lent que toute première version sans frontières plus lisse, mais il est ok.
Question de clôture.

Answer 2

Vous pouvez facilement masquer sur une image en utilisant la funciton suivante:

def transparentOverlay(src, overlay, pos=(0, 0), scale=1): 
    overlay = cv2.resize(overlay, (0, 0), fx=scale, fy=scale) 
    h, w, _ = overlay.shape # Size of foreground 
    rows, cols, _ = src.shape # Size of background Image 
    y, x = pos[0], pos[1] # Position of foreground/overlay image 

    # loop over all pixels and apply the blending equation 
    for i in range(h): 
     for j in range(w): 
      if x + i >= rows or y + j >= cols: 
       continue 
      alpha = float(overlay[i][j][3]/255.0) # read the alpha channel 
      src[x + i][y + j] = alpha * overlay[i][j][:3] + (1 - alpha) * src[x + i][y + j] 
    return src 

Vous devez transmettre l'image source, alors que le masque et la position où vous souhaitez définir le masque. Vous pouvez même définir l'échelle de masquage. en l'appelant comme ça.

transparentOverlay(face_cigar_roi_color,cigar,(int(w/2),int(sh_cigar/2))) 

Pour plus de détails vous pouvez consulter ce lien: Face masking and Overlay using OpenCV python

Sortie:

Answer 3

Je pense que peut-être vous voulez quelque chose comme ça.

Ceci est l'image source :

La source-blured paire:

Le masque alphablened paire:

---

Le code avec description dans le commentaire de code.

#!/usr/bin/python3 
# 2018.01.16 13:07:05 CST 
# 2018.01.16 13:54:39 CST 
import cv2 
import numpy as np 

def alphaBlend(img1, img2, mask): 
    """ alphaBlend img1 and img 2 (of CV_8UC3) with mask (CV_8UC1 or CV_8UC3) 
    """ 
    if mask.ndim==3 and mask.shape[-1] == 3: 
     alpha = mask/255.0 
    else: 
     alpha = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)/255.0 
    blended = cv2.convertScaleAbs(img1*(1-alpha) + img2*alpha) 
    return blended 

img = cv2.imread("test.png") 

H,W = img.shape[:2] 
mask = np.zeros((H,W), np.uint8) 
cv2.circle(mask, (325, 350), 40, (255,255,255), -1, cv2.LINE_AA) 
mask = cv2.GaussianBlur(mask, (21,21),11) 

blured = cv2.GaussianBlur(img, (21,21), 11) 

blended1 = alphaBlend(img, blured, mask) 
blended2 = alphaBlend(img, blured, 255- mask) 

cv2.imshow("blened1", blended1); 
cv2.imshow("blened2", blended2); 
cv2.waitKey();cv2.destroyAllWindows() 

---

Quelques liens utiles:

1. Alpha Blending dans OpenCV C++: Combining 2 images with transparent mask in opencv

2. Alpha Blending dans OpenCV Python: Gradient mask blending in opencv python