Supprimer le fond blanc d'une image et la rendre transparente

Question

Nous essayons de faire ce qui suit dans Mathematica - RMagick supprime le fond blanc de l'image et le rend transparent .

Mais avec des photos réelles, cela finit par donner un mauvais résultat (comme un halo autour de l'image).

Voici ce que nous avons essayé jusqu'à présent :

unground0[img_] := With[{mask = ChanVeseBinarize[img, TargetColor->{1.,1.,1.}]},
  Rasterize[SetAlphaChannel[img, ImageApply[1-#&, mask]], Background->None]]]

Voici un exemple de ce que cela fait.

Image originale :

Image dont le fond blanc a été remplacé par un fond vide (ou, pour les besoins de la démonstration, un fond rose) :

Des idées pour se débarrasser de ce halo ? En modifiant des éléments comme LevelPenalty, je n'arrive à faire disparaître le halo qu'au prix d'une perte partielle de l'image.

EDIT : Afin que je puisse comparer les solutions pour la prime, veuillez structurer votre solution comme ci-dessus, à savoir une fonction autonome nommée unground-something qui prend une image et renvoie une image avec un fond transparent.

Answer 1

Cette fonction met en œuvre le mélange inverse décrit par Mark Ransom, pour une amélioration supplémentaire, petite mais visible :

reverseBlend[img_Image, alpha_Image, bgcolor_] :=
 With[
  {c = ImageData[img], 
   a = ImageData[alpha] + 0.0001, (* this is to minimize ComplexInfinitys and considerably improve performance *)
   bc = bgcolor},

  ImageClip@
   Image[Quiet[(c - bc (1 - a))/a, {Power::infy, 
       Infinity::indet}] /. {ComplexInfinity -> 0, Indeterminate -> 0}]
  ]

Il s'agit de la fonction de suppression de l'arrière-plan. Le site threshold est utilisé pour la binarisation initiale de l'image, le paramètre minSizeCorrection permet d'ajuster la taille limite des petites composantes indésirables à supprimer après la binarisation.

removeWhiteBackground[img_, threshold_: 0.05, minSizeCorrection_: 1] :=
  Module[
  {dim, bigmask, mask, edgemask, alpha},
  dim = ImageDimensions[img];
  bigmask = 
   DeleteSmallComponents[
    ColorNegate@
     MorphologicalBinarize[ColorNegate@ImageResize[img, 4 dim], threshold], 
    Round[minSizeCorrection Times @@ dim/5]];
  mask = ColorNegate@
    ImageResize[ColorConvert[bigmask, "GrayScale"], dim];
  edgemask = 
   ImageResize[
    ImageAdjust@DistanceTransform@Dilation[EdgeDetect[bigmask, 2], 6],
     dim];
  alpha = 
   ImageAdd[
    ImageSubtract[
     ImageMultiply[ColorNegate@ColorConvert[img, "GrayScale"], 
      edgemask], ImageMultiply[mask, edgemask]], mask];
  SetAlphaChannel[reverseBlend[img, alpha, 1], alpha]
  ]

Test de la fonction :

img = Import["http://i.stack.imgur.com/k7E1F.png"];

background = 
  ImageCrop[
   Import["http://cdn.zmescience.com/wp-content/uploads/2011/06/\
forest2.jpg"], ImageDimensions[img]];

result = removeWhiteBackground[img]

ImageCompose[background, result]
Rasterize[result, Background -> Red]
Rasterize[result, Background -> Black]

Brève explication de son fonctionnement :

1. Choisissez votre méthode de binarisation préférée qui produit des bords nets relativement précis.

2. Appliquez-le à une image à échelle supérieure, puis réduisez l'échelle de l'image obtenue. mask à la taille originale. Cela nous donne l'anticrénelage. Le gros du travail est fait.

3. Pour une petite amélioration, fusionnez l'image sur le fond en utilisant la luminosité de son négatif comme alpha, puis fusionnez l'image obtenue sur l'original dans une fine région autour des bords ( edgemask ) pour réduire la visibilité des pixels blancs sur les bords. Le canal alpha correspondant à ces opérations est calculé (l'option quelque peu cryptique ImageMultiply/Add expression).

4. Maintenant, nous avons une estimation du canal alpha et nous pouvons faire un mélange inversé.

Les étapes 3 et 4 n'améliorent pas tant que ça la situation, mais la différence est visible.

Answer 2

Peut-être, en fonction de la qualité des bords dont vous avez besoin :

img = Import@"http://i.stack.imgur.com/k7E1F.png";
mask = ChanVeseBinarize[img, TargetColor -> {1., 1., 1.}, "LengthPenalty" -> 10]
mask1 = Blur[Erosion[ColorNegate[mask], 2], 5]
Rasterize[SetAlphaChannel[img, mask1], Background -> None]

Modifier

Stealing a bit from @Szabolcs

img2 = Import@"http://i.stack.imgur.com/k7E1F.png";
(*key point:scale up image to smooth the edges*)
img = ImageResize[img2, 4 ImageDimensions[img2]];
mask = ChanVeseBinarize[img, TargetColor -> {1., 1., 1.}, "LengthPenalty" -> 10];
mask1 = Blur[Erosion[ColorNegate[mask], 8], 10];
f[col_] := Rasterize[SetAlphaChannel[img, mask1], Background -> col, 
                     ImageSize -> ImageDimensions@img2]
GraphicsGrid[{{f@Red, f@Blue, f@Green}}]

Cliquez pour agrandir

Edit 2

Juste pour avoir une idée de l'étendue de la halo et les imperfections de l'arrière-plan de l'image :

img = Import@"http://i.stack.imgur.com/k7E1F.png";
Join[{img}, MapThread[Binarize, {ColorSeparate[img, "HSB"], {.01, .01, .99}}]]

ColorNegate@ImageAdd[EntropyFilter[img, 1] // ImageAdjust, ColorNegate@img]

Answer 3

Je vais parler de manière générale, sans me référer spécifiquement à Mathematica. Je n'ai aucune idée si ces opérations sont difficiles ou triviales.

La première étape consiste à estimer un niveau alpha (transparence) pour les pixels du bord de l'image. Pour l'instant, vous utilisez un seuil strict, donc l'alpha est soit 0% totalement transparent, soit 100% totalement opaque. Vous devriez définir une plage entre le blanc total de l'arrière-plan et les couleurs qui font indiscutablement partie de l'image, et définir une proportion appropriée - si la couleur est plus proche de celle de l'arrière-plan, il s'agit d'un alpha faible, et si elle est plus proche du seuil le plus sombre, il s'agit d'un alpha élevé. Ensuite, vous pouvez effectuer des ajustements en fonction des valeurs alpha environnantes : plus un pixel est entouré de transparence, plus il est susceptible d'être lui-même transparent.

Une fois que vous avez les valeurs alpha, vous devez faire un mélange inversé pour obtenir la bonne couleur. Lorsqu'une image est affichée sur un fond, elle est mélangée en fonction de la valeur alpha à l'aide de la formule suivante c = bc*(1-a)+fc*a donde bc est la couleur de fond et fc est la couleur d'avant-plan. Dans votre cas, l'arrière-plan est blanc (255,255,255) et la couleur d'avant-plan est inconnue, nous inversons donc la formule : fc = (c - bc*(1-a))/a . Quand a=0 la formule prévoit une division par zéro, mais la couleur n'a pas d'importance de toute façon, alors utilisez simplement le noir ou le blanc.

Answer 4

Voici un essai de mise en œuvre de l'approche de Mark Ransom, avec l'aide de la génération de masques de belisarius :

Localisez la limite de l'objet :

img1 = SetAlphaChannel[img, 1];
erosionamount=2;
mb = ColorNegate@ChanVeseBinarize[img, TargetColor -> {1., 1., 1}, 
      "LengthPenalty" -> 10];
edge = ImageSubtract[Dilation[mb, 2], Erosion[mb, erosionamount]];

ImageApply[{1, 0, 0} &, img, Masking ->edge]

Définissez les valeurs alpha :

edgealpha = ImageMultiply[ImageFilter[(1 - Mean[Flatten[#]]^5) &, 
   ColorConvert[img, "GrayScale"], 2, Masking -> edge], edge];
imagealpha = ImageAdd[edgealpha, Erosion[mb, erosionamount]];
img2 = SetAlphaChannel[img, imagealpha];

Mélange de couleurs inversé :

img3 = ImageApply[Module[{c, \[Alpha], bc, fc},
   bc = {1, 1, 1};
   c = {#[[1]], #[[2]], #[[3]]};
   \[Alpha] = #[[4]];
   If[\[Alpha] > 0, Flatten[{(c - bc (1 - \[Alpha]))/\[Alpha], \[Alpha]}], {0., 0., 
   0., 0}]] &, img2];

Show[img3, Background -> Pink]

Vous avez remarqué que certains des bords ont un duvet blanc ? Comparez cela avec le contour rouge de la première image. Nous avons besoin d'un meilleur détecteur de bords. L'augmentation de la quantité d'érosion aide à réduire le flou, mais les autres côtés deviennent trop transparents, il y a donc un compromis sur la largeur du masque de bord. C'est assez bon, cependant, considérant qu'il n'y a pas d'opération de flou, en soi.

Il serait instructif d'exécuter l'algorithme sur une variété d'images pour tester sa robustesse, pour voir dans quelle mesure il est automatique.

Answer 5

Je m'amuse juste en tant que débutant - c'est incroyable le nombre d'outils disponibles.

b = ColorNegate[
    GaussianFilter[MorphologicalBinarize[i, {0.96, 0.999}], 6]];
c = SetAlphaChannel[i, b];
Show[Graphics[Rectangle[], Background -> Orange, 
     PlotRangePadding -> None], c]