Binaryzacja obrazu

[TMh...@gmail.com]

Czesc,

Mam takie male pytanie, czy jest jakis sposob aby za pomoca
kilku komend zamienic obraz wieloodcieniowy na zbinaryzowany?
Zbinaryzowany to znaczy taki ktory ma tylko czarne i biale pixele.
Gdyby jeszcze dalo sie prog binaryzacji ustalac recznie to bylbym
wniebowziety.

Pozdrawiam,
Tomasz Moroz

[Mateusz [PEYN] Adamus]

TMh...@gmail.com napisał(a):

Hmm, nie sadze aby to byla kilka komend ale na pewno sie da. Poszukaj w
necie. Ja tam kiedys znalazlem jakas procedure zamieniajaca kolorowy
obraz na obraz w skali szarosci - to jest w sumie to co Ty chcesz.

Podejrzewam ze wystarczy taka procedure troszke zmienic i bedzie Ci
idealnie pasowala.

--
pozdrawiam
Mateusz [PEYN] Adamus
http://adamus.home.pl

[TMh...@gmail.com]

Niestety mam juz zamiane obrazu kolorowego na wieloodcieniowy
jednak nie da sie tam zastosowac binaryzacji. Zdaje sobie sprawe
ze bedzie to nieco dluzszy program mimo wszystko i tak bardzo sie
przyda.

Pozdrawiam,
Tomasz Moroz
Mateusz [PEYN] Adamus napisał(a):

[Peri]

http://tinyurl.com/hjg36 - moze to ci pomoze.

Generalnie to chyba wystarczy przejsc po kazdym punkcie i i wykonac

obrazek[piksel] = obrazek[piksel] > prog

jeszcze tylko for dookoła i masz to w jednej instrukcji.

--
Peri

[Artur Borecki]

"Peri" <em...@server.net> wrote in message
news:op.tdwws...@at-piotrpe.atena.pl...

dziekuje za design. ;-)

impelmentacja ktora przez chwila zakodzilem:

using System.Drawing;
(...)
Bitmap b2 = (Bitmap)Bitmap.FromFile(@"c:\grafaIn.gif");

//mozliwe wartosci 2(czarno bialy),3 (czarno-szaro-bialy),4,5, ... , 256
(nie zmieniony)
int ile_kolorow_zostawic = 2; // ustawinie 1 spowoduje dzielenie przez 0

for (int x = 0; x < b2.Width; x++)
{
for (int y = 0; y < b2.Height; y++)
{
Color oldcolor = b2.GetPixel(x,y);
byte r = oldcolor.R;
byte g = oldcolor.G;
byte b = oldcolor.B;
//usrednienie - powoduje ze obraz staje sie czarnobialy
byte us = (byte)((r + g + b) / 3.0);

// troche matematyki ;-)
double R = (double)us / (255.0 / (ile_kolorow_zostawic-1));
us = (byte)(Math.Round(R) * (255.0/(ile_kolorow_zostawic-1)));

b2.SetPixel(x,y,Color.FromArgb(us,us,us));
}
}
b2.Save(@"c:\grafaOut.gif");

ten programik dodatkowo niejako zamienia kolorowy obraz w skale szarosci.
Oczywiscie mozna tego nie robic, czyli nie usredniac na poczatku wartosci
piksela, i kazda skladowa liczyc osobna, wtedy powstaja tez dosc ciekawe
efekty.

[Przemyslaw Osmanski]

Artur Borecki napisał(a):

> Color oldcolor = b2.GetPixel(x,y);
> byte r = oldcolor.R;
> byte g = oldcolor.G;
> byte b = oldcolor.B;
> //usrednienie - powoduje ze obraz staje sie czarnobialy
> byte us = (byte)((r + g + b) / 3.0);

to powyzej zrobi cos podobnego jednak nie jest przeksztalceniem do
skali szarosci, poprawniej bylby:
byte us = (byte) (0.299 * r + 0.587 * g + 0.114 * b);

pozdrawiam,
Przemek O.

[Sebastian Nibisz]

//--------------------------------------------------------------------------------------------------------------------------------------
private void Convert(System.Drawing.Bitmap bmp, bool binary)
{
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
System.Drawing.Imaging.BitmapData bmpData =
bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite,
bmp.PixelFormat);

IntPtr ptr = bmpData.Scan0;
int bytes = bmp.Width * bmp.Height * 3;
byte[] rgbValues = new byte[bytes];

System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);

System.Random random = new System.Random();
for (int c = 0; c < rgbValues.Length; c += 3)
{
float g = 0.3f * (float)rgbValues[c] + 0.59f * (float)rgbValues[c +
1] + 0.11f * (float)rgbValues[c + 2];
if (g > 255) g = 255;
if (binary)
{
int r = random.Next(256);
byte b = 255;
if (r > g) b = 0;
rgbValues[c] = rgbValues[c + 1] = rgbValues[c + 2] = b;
}
else rgbValues[c] = rgbValues[c + 1] = rgbValues[c + 2] = (byte)g;
}
System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
bmp.UnlockBits(bmpData);
}

//--------------------------------------------------------------------------------------------------------------------------------------
public GrayBitmap()
{
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap( [plikzrodlowy] );
Convert(bmp, false);
bmp.Save( [plikdocelowy] );
}

//--------------------------------------------------------------------------------------------------------------------------------------
public BinaryBitmap()
{
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap( [plikzrodlowy] );
Convert(bmp, true);
bmp.Save( [plikdocelowy] );
}

//--------------------------------------------------------------------------------------------------------------------------------------

Pozdrawiam.

- Bastek -

[Sebastian Nibisz]

> //--------------------------------------------------------------------------------------------------------------------------------------
> public GrayBitmap()
> {
> System.Drawing.Bitmap bmp = new System.Drawing.Bitmap( [plikzrodlowy] );
> Convert(bmp, false);
> bmp.Save( [plikdocelowy] );
> }
>
>
> //--------------------------------------------------------------------------------------------------------------------------------------
> public BinaryBitmap()
> {
> System.Drawing.Bitmap bmp = new System.Drawing.Bitmap( [plikzrodlowy] );
> Convert(bmp, true);
> bmp.Save( [plikdocelowy] );
> }
>
> //--------------------------------------------------------------------------------------------------------------------------------------
>

Oczywiście powinno być:

public void GrayBitmap()
public void BinaryBitmap()

jakoś nie dopisałem typu zwracanego.

[Artur Borecki]

"Przemyslaw Osmanski" <prze...@cos.gdzies.net.pl> wrote in message
news:eb7dqv$bum$1...@nemesis.news.tpi.pl...

dzieki,
poza tym sobie uswiadomilem ze zaimpelementowalem nie to co chcial pytajacy,
sory.
Binaryzazja to nie kwantyzacja ;-)