Entfernen Sie den weißen Hintergrund von einem Bild und machen Sie es transparent

In Mathematica versuchen wir Folgendes zu tun: RMagick entfernt den weißen Hintergrund aus dem Bild und macht es transparent .

Bei tatsächlichen Fotos sieht es jedoch mies aus (wie ein Heiligenschein um das Bild).

Folgendes haben wir bisher versucht:

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

Hier ist ein Beispiel dafür, was das bewirkt.

Original Bild:

Bild mit weißem Hintergrund ohne Hintergrund (oder zu Demonstrationszwecken hier mit rosa Hintergrund):

Irgendwelche Ideen, um diesen Heiligenschein loszuwerden? Wenn ich Dinge wie LevelPenalty optimiere, kann ich den Heiligenschein nur auf Kosten des Verlusts eines Teils des Bildes verschwinden lassen.

BEARBEITEN: Damit ich Lösungen für das Kopfgeld vergleichen kann, strukturieren Sie bitte Ihre Lösung wie oben beschrieben, nämlich eine in sich geschlossene Funktion namens unground - etwas, das ein Bild aufnimmt und ein Bild mit transparentem Hintergrund zurückgibt.

Je nach Kantenqualität benötigen Sie möglicherweise:

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]

Bearbeiten

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}}]

klicken um zu vergrößern

Bearbeiten 2

Nur um eine Vorstellung vom Ausmaß der Halo- und Hintergrundfehler im Bild zu bekommen:

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]

Diese Funktion implementiert die von Mark Ransom beschriebene umgekehrte Mischung für eine zusätzliche kleine, aber sichtbare Verbesserung:

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}]
  ]

Dies ist die Funktion zum Entfernen des Hintergrunds. Der thresholdParameter wird für die anfängliche Binärisierung des Bildes verwendet. Er minSizeCorrectiondient zum Optimieren der Größenbeschränkung für kleine Junk-Komponenten, die nach der Binärisierung entfernt werden sollen.

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]
  ]

Testen der Funktion:

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]

Kurze Erklärung, wie es funktioniert:

1. Wählen Sie Ihre bevorzugte Binariaztion-Methode, die relativ präzise scharfe Kanten erzeugt

2. Wenden Sie es auf ein maskvergrößertes Bild an und verkleinern Sie das erhaltene Bild auf die Originalgröße. Dies gibt uns Antialiasing. Der größte Teil der Arbeit ist erledigt.

3. Um eine kleine Verbesserung zu erzielen, mischen Sie das Bild mit der Helligkeit des Negativs als Alpha auf den Hintergrund und mischen Sie dann das erhaltene Bild in einem dünnen Bereich um die Kanten ( edgemask) über das Original , um die Sichtbarkeit weißer Pixel an den Kanten zu verringern. Der diesen Operationen entsprechende Alphakanal wird berechnet (der etwas kryptische ImageMultiply/AddAusdruck).

4. Jetzt haben wir eine Schätzung des Alphakanals, damit wir eine umgekehrte Mischung durchführen können.

Die Schritte 3 und 4 verbessern sich nicht so sehr, aber der Unterschied ist sichtbar.

Ich werde generisch sprechen, nicht speziell in Bezug auf Mathematica. Ich habe keine Ahnung, ob diese Operationen schwierig oder trivial sind.

Der erste Schritt besteht darin, einen Alpha-Pegel (Transparenzpegel) für die Pixel am Bildrand zu schätzen. Im Moment verwenden Sie einen strengen Schwellenwert, sodass das Alpha entweder zu 0% vollständig transparent oder zu 100% vollständig undurchsichtig ist. Sie sollten einen Bereich zwischen dem Gesamtweiß des Hintergrunds und den Farben definieren, die unbestreitbar Teil des Bildes sind, und einen angemessenen Anteil festlegen. Wenn die Farbe näher am Hintergrund liegt, ist das Alpha niedrig, und wenn sie näher am dunkleren Grenzwert liegt, ist dies der Fall ein hohes Alpha. Danach können Sie Anpassungen basierend auf den umgebenden Alpha-Werten vornehmen. Je mehr ein Pixel von Transparenz umgeben ist, desto wahrscheinlicher ist es, dass es selbst transparent ist.

Sobald Sie Alpha-Werte haben, müssen Sie eine umgekehrte Mischung durchführen, um die richtige Farbe zu erhalten. Wenn ein Bild über einem Hintergrund angezeigt wird, wird es gemäß dem Alpha-Wert unter Verwendung der Formel gemischt, c = bc*(1-a)+fc*awobei bcdie Hintergrundfarbe und fcdie Vordergrundfarbe verwendet werden. In Ihrem Fall ist der Hintergrund weiß (255,255,255) und die Vordergrundfarbe ist unbekannt, daher kehren wir die Formel um : fc = (c - bc*(1-a))/a. Wenn a=0die Formel eine Division durch Null erfordert, die Farbe jedoch keine Rolle spielt, verwenden Sie einfach Schwarz oder Weiß.

Hier ist ein Versuch, Mark Ransoms Ansatz mit Hilfe der Maskengenerierung von Belisarius umzusetzen:

Suchen Sie die Grenze des Objekts:

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]

Stellen Sie die Alpha-Werte ein:

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

Umgekehrte Farbmischung:

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]

Beachten Sie, wie einige der Kanten weiße Flaum haben? Vergleichen Sie das mit dem roten Umriss im ersten Bild. Wir brauchen einen besseren Kantendetektor. Das Erhöhen der Erosionsmenge hilft beim Flaum, aber dann werden andere Seiten zu transparent, sodass die Breite der Kantenmaske beeinträchtigt wird. Es ist jedoch ziemlich gut, wenn man bedenkt, dass es per se keine Unschärfeoperation gibt.

Es wäre lehrreich, den Algorithmus auf einer Vielzahl von Bildern auszuführen, um seine Robustheit zu testen und festzustellen, wie automatisch er ist.

Nur als Anfänger herumspielen - es ist erstaunlich, wie viele Tools verfügbar sind.

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

Ich bin völlig neu in der Bildverarbeitung, aber hier ist, was ich nach einigem Spielen mit neuen morphologischen Bildverarbeitungsfunktionen von Version 8 bekomme:

mask = DeleteSmallComponents[
   ColorNegate@
    Image[MorphologicalComponents[ColorNegate@img, .062, 
      Method -> "Convex"], "Bit"], 10000];
Show[Graphics[Rectangle[], Background -> Red, 
  PlotRangePadding -> None], SetAlphaChannel[img, ColorNegate@mask]]

Ich empfehle, dafür Photoshop zu verwenden und als PNG zu speichern.

Mögliche Schritte, die Sie unternehmen könnten:

• die Maske erweitern
• verwischen Sie es
• Stellen Sie mit der Maske die Transparenz anhand des Abstands von Weiß ein
• Stellen Sie die Sättigung mithilfe der Maske so ein, dass die zuvor weißeren Farben gesättigter sind.

Ersetzen Sie einfach jedes Pixel, das "fast weiß" ist, durch ein Pixel mit derselben RGB-Farbe und einem Sigmoid-Farbverlauf auf dem Transparenzkanal. Sie können einen linearen Übergang von fest zu transparent anwenden, aber Sinus oder Sigmoid oder Tanh sehen natürlicher aus. Abhängig von der Schärfe der gesuchten Kante bewegen sie sich schnell vom Medium zu fest oder transparent, jedoch nicht schrittweise / binär Art und Weise, was Sie jetzt haben.

Denk darüber so:

Nehmen wir an, R, G, B sind jeweils 0,0-1,0, dann stellen wir Weiß als einzelne Zahl als R + G + B = 1,0 * 3 = 3,0 dar.

Wenn Sie ein wenig von jeder Farbe herausnehmen, wird es ein wenig "cremefarben", aber wenn Sie ein wenig von allen 3 herausnehmen, wird es viel mehr entfernt als ein wenig von irgendjemandem. Angenommen, Sie erlauben eine Reduzierung um 10% auf einen Kanal: 1.0 * .10 = .1. Verteilen Sie diesen Verlust nun auf alle drei und binden Sie ihn für den Alpha-Kanal zwischen 0 und 1, wenn er kleiner als .1 ist, so dass ( Verlust = 0,9) => 0 und (Verlust = 1,0) => 1:

threshold=.10;
maxLoss=1.0*threshold;
loss=3.0-(R+G+B);
alpha=If[loss>maxLoss,0,loss/maxLoss];
(* linear scaling is used above *)
(* or use 1/(1 + Exp[-10(loss - 0.5maxLoss)/maxLoss]) to set sigmoid alpha *)
(* Log decay: Log[maxLoss]/Log[loss]
      (for loss and maxLoss <1, when using RGB 0-255, divide by 255 to use this one *)

setNewPixel[R,G,B,alpha];

Als Referenz:

maxLoss = .1;
Plot[{ 1/(1 + Exp[-10(loss - 0.5maxLoss)/maxLoss]),
       Log[maxLoss]/Log[loss],
       loss/maxLoss
     }, {loss, 0, maxLoss}]

Die einzige Gefahr (oder der einzige Nutzen?), Die Sie dabei haben, besteht darin, dass es nicht um Weiße geht, die tatsächlich Teil des Fotos sind. Es entfernt alle Weißen. Wenn Sie also ein Bild von einem weißen Auto haben, werden transparente Flecken darin sein. Aber aus Ihrem Beispiel scheint dies ein gewünschter Effekt zu sein.