Удалить белый фон с изображения и сделать его прозрачным

Возможно, в зависимости от качества кромки вам необходимо:

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]

Изменить

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

нажмите, чтобы увеличить

Изменить 2

Просто чтобы получить представление о степени гало и несовершенстве фона на изображении:

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]

Эта функция реализует обратное смешение, описанное Марком Рэнсомом, для дополнительного небольшого, но заметного улучшения:

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

Это функция удаления фона. Параметр threshold используется для начальной бинаризации изображения, minSizeCorrection — для настройки ограничения размера мелких ненужных компонентов, которые должны быть удалены после бинаризации.

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

Проверка функции:

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]

Я буду говорить в общем, а не конкретно в отношении Mathematica. Я понятия не имею, сложны ли эти операции или тривиальны.

Первым шагом является оценка уровня альфа-канала (прозрачности) для пикселей на краю изображения. Прямо сейчас вы используете строгий порог, поэтому альфа либо полностью прозрачна на 0%, либо полностью непрозрачна на 100%. Вы должны определить диапазон между общим белым фоном и цветами, которые бесспорно являются частью изображения, и установить соответствующую пропорцию - если он ближе по цвету к фону, это низкая альфа, а если он ближе к более темному отсечению, то это высокая альфа. После этого вы можете вносить коррективы на основе окружающих альфа-значений — чем больше пиксель окружен прозрачностью, тем больше вероятность того, что он сам будет прозрачным.

Когда у вас есть альфа-значения, вам нужно сделать обратное наложение, чтобы получить правильный цвет. Когда изображение отображается на фоне, оно смешивается в соответствии со значением альфа-канала по формуле c = bc*(1-a)+fc*a, где bc — цвет фона, а fc — цвет переднего плана. В вашем случае фон белый (255 255 255), а цвет переднего плана неизвестен, поэтому мы обращаем формулу: fc = (c - bc*(1-a))/a. Когда a=0 формула требует деления на ноль, но цвет в любом случае не имеет значения, поэтому просто используйте черный или белый.

Вот попытка реализовать подход Марка Рэнсома с некоторой помощью генерации маски Велизария:

Найдите границу объекта:

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]

Установите альфа-значения:

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

Обратная цветовая смесь:

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]

Обратите внимание, как на некоторых краях есть белый пушок? Сравните это с красным контуром на первом изображении. Нам нужен лучший детектор границ. Увеличение степени эрозии помогает с пушком, но тогда другие стороны становятся слишком прозрачными, поэтому возникает компромисс по ширине краевой маски. Тем не менее, это довольно хорошо, учитывая отсутствие операции размытия как таковой.

Было бы полезно запустить алгоритм на различных изображениях, чтобы проверить его надежность и увидеть, насколько он автоматизирован.

Просто играю как новичок - удивительно, как много инструментов доступно.

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

Я совершенно новичок в обработке изображений, но вот что я получаю после некоторой игры с новыми функциями морфологической обработки изображений версии 8:

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

Я рекомендую использовать Photoshop для этого и сохранить в формате PNG.

Возможные шаги, которые вы можете предпринять:

• расширить маску
• размыть это
• с помощью маски установить прозрачность по расстоянию от белого
• с помощью маски отрегулируйте насыщенность так, чтобы ранее более белые цвета были более насыщенными.

Просто замените любой пиксель, который «почти близок к белому», пикселем того же цвета RGB и сигмовидным градиентом в канале прозрачности. Вы можете применить линейный переход от сплошного к прозрачному, но Синусоида, Сигмоид или Тан выглядят более естественными, в зависимости от резкости края, который вы ищете, они быстро уходят от среды к сплошному или прозрачному, но не в ступенчатом/бинарном режиме. способ, который у вас есть сейчас.

Подумайте об этом так:

Предположим, что R, G, B равны 0,0-1,0, тогда давайте представим белый цвет как одно число, как R + G + B = 1,0 * 3 = 3,0.

Удаление небольшого количества каждого цвета делает его немного «не совсем белым», но удаление небольшого количества всех трех цветов делает его гораздо более грязным, чем удаление любого из них. Допустим, вы допускаете уменьшение на 10% для любого одного канала: 1,0 * 0,10 = 0,1. Теперь распределите эту потерю по всем трем и свяжите ее между 0 и 1 для альфа-канала, если она меньше 0,1, так что ( убыток=0,9)=>0 и (убыток=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];

Для справки:

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

Единственная опасность (или польза?), которая у вас есть в этом, заключается в том, что это не заботится о белых, которые на самом деле ЯВЛЯЮТСЯ частью фотографии. Он убирает все белые. Так что, если у вас есть фотография белой машины, на ней будут прозрачные пятна. Но из вашего примера это кажется желаемым эффектом.