private unsafe void testoweToolStripMenuItem_Click(object sender, EventArgs e)
{
FolderBrowserDialog fsb = new FolderBrowserDialog();
if (fsb.ShowDialog() == DialogResult.OK)
{
DirectoryInfo ds = new DirectoryInfo(fsb.SelectedPath);
FileInfo[] fi = ds.GetFiles("*.jpg");
if (fsb.ShowDialog() == DialogResult.OK)
{
for (int i = 0; i < fi.Length; i++)
{
Bitmap f = new Bitmap(fi[i].FullName);
f = new Bitmap(f, f.Size.Skaluj((float)1 / RozpoznawanieKuponu.StopieńZmiejszenia));
byte *Mon = OperacjeNaStrumieniu.PonierzMonohormatyczny(f);
bool *Bin = ProgowanieAdaptacyjne.ProgowanieZRamką(Mon, f.Size, Otsu.ZnajdywanieRóźnicyŚrednich(Mon, f.Size), 6, -20, true);
int * Mapa;
//var Obszary= WstepnePrzygotowanie.ZnajdźOpszary(ref Bin, f.Size.Width, f.Size.Height,out Mapa);
//Obszary.Sort();
//var Najwiekszy = Obszary[0];
//Zw = WstepnePrzygotowanie.PobierzObszar(Bin, Najwiekszy.Miejsce, f.Size);
f = WstepnePrzygotowanie.WskaźnikNaObraz(Bin, f.Size);
f.Save(fsb.SelectedPath + "\\" + i.ToString() + "zap.bmp");
//Marshal.FreeHGlobal((IntPtr)Zw);
Marshal.FreeHGlobal((IntPtr)Bin);
GC.Collect();
}
}
}
}
public void Naładuj(Bitmap bp, Size s)
{
byte *z = OperacjeNaStrumieniu.PonierzMonohormatyczny(new Bitmap(bp, s));
Naładuj(z, s);
Marshal.FreeHGlobal((IntPtr)z);
}
public static unsafe void FiltMedianowyWieleRdzeni(Size Obraz, byte *DoPrzypisywania, int WIelkośćMaski, int ZbytWysuniety = 2, int Zamiana = 5)
{
IntPtr ip = Marshal.AllocHGlobal(Obraz.WielkoścWPix());
OperacjeNaStrumieniu.Kopiuj((byte *)ip, DoPrzypisywania, Obraz.WielkoścWPix());
bool[] Wykonane = new bool[StałeGlobalne.IlośćRdzeni];
int[] tb = new int[StałeGlobalne.IlośćRdzeni];
for (int i = 0; i < StałeGlobalne.IlośćRdzeni; i++)
{
WeźDelikatnyMedianowy(i, Obraz, DoPrzypisywania, WIelkośćMaski, ZbytWysuniety, Zamiana, ip, Wykonane);
}
int WielkośćY = Obraz.Height / StałeGlobalne.IlośćRdzeni;
bool PetlaTrwa = true;
while (PetlaTrwa)
{
PetlaTrwa = false;
for (int i = 0; i < Wykonane.Length; i++)
{
PetlaTrwa |= !Wykonane[i];
}
Thread.Sleep(10);
}
Marshal.FreeHGlobal(ip);
}
public void Naładuj(Bitmap bp)
{
byte *z = OperacjeNaStrumieniu.PonierzMonohormatyczny(bp);
Naładuj(z, bp.Size);
Marshal.FreeHGlobal((IntPtr)z);
}
unsafe private void otwórzToolStripMenuItem_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
działajToolStripMenuItem.Enabled = true;
Dana = new Bitmap(openFileDialog1.FileName);
//Dana = new Bitmap(new Bitmap(openFileDialog1.FileName), 3264, 2448);
bool *c = Otsu.OtsuGlobalneNaTablice(OperacjeNaStrumieniu.PonierzMonohormatyczny(Dana), new Size(Dana.Width, Dana.Height));
pictureBox1.Image = new Bitmap(WstepnePrzygotowanie.WskaźnikNaObraz(c, Dana.Width, Dana.Height), new Size(1000, 1000));
}
}
public static Linika[] PodzielNaLiniki(ref bool *c, ref Size SamLoto, out ZdjecieZPozycją Logo, bool UżywanieZlepianiaRzutem = false, bool UżywanieRozdzielaniaLiter = true)
{
Logo = null;
int Długość = SamLoto.Width * SamLoto.Height;
bool *ObrazKopis = (bool *)Marshal.AllocHGlobal(Długość);
OperacjeNaStrumieniu.Kopiuj(ObrazKopis, c, Długość);
GC.Collect();
List <ZdjecieZPozycją> ListaZdjęć = new List <ZdjecieZPozycją>();
ObszaryNaZdzieciaZPozycją(ref c, SamLoto, ObrazKopis, ListaZdjęć, out Logo, UżywanieZlepianiaRzutem);
Marshal.FreeHGlobal((IntPtr)ObrazKopis);
Linika[] z = null;
if (UstalKieróne(ref z, ref c, ref SamLoto, ref Logo))
{
return(z);
}
if (UżywanieRozdzielaniaLiter)
{
RozdzielanieLiter rk = new RozdzielanieLiter(ZbytSzeroki, Sieć);
rk.Rodzielaj(ListaZdjęć, c, SamLoto, UżywanieZlepianiaRzutem);
}
int PrógMimalnejOdległośc = Convert.ToInt32(MaksymalneOdalenie * SamLoto.Width);
//w tym momencie lotek powinien być w odpowiedniej pozycji
List <Linika> ZwracanePrzedPrzemianą = PrzydzielanieDoLinik(ListaZdjęć, PrógMimalnejOdległośc);
ScalajLiniki(ZwracanePrzedPrzemianą);
ZlepianieLinijek zl = null;
zl = new ZlepianieLinijek(Sieć);
zl.ZlepPeknieteLitery(ZwracanePrzedPrzemianą, c, SamLoto.Width);
ListaZdjęć = Rozczep(ZwracanePrzedPrzemianą);
UsuńNaPoczątku(SamLoto.Width, ListaZdjęć);
//PrzypiszPrzesóniecia(ZwracanePrzedPrzemianą);
//Przesón(ZwracanePrzedPrzemianą);
ZwracanePrzedPrzemianą = PrzydzielanieDoLinik(ListaZdjęć, PrógMimalnejOdległośc);
Przesón(ZwracanePrzedPrzemianą);
ZwracanePrzedPrzemianą = PrzydzielanieDoLinik(ListaZdjęć, PrógMimalnejOdległośc, true);
UsuńSzumy(ZwracanePrzedPrzemianą);
ScalajLiniki(ZwracanePrzedPrzemianą, true);
PosortujY(ZwracanePrzedPrzemianą);
ZlepianieLiterMetodąY(ZwracanePrzedPrzemianą, SamLoto.Width, c, Sieć);
ObliczPodobieństwoStworzonychZNeuronową(Sieć, SiećNeuronowa, SamLoto.Width, ZwracanePrzedPrzemianą, c);
return(ZwracanePrzedPrzemianą.ToArray());
//return StaryPodziałNaLiniki(SamLoto, ListaZdjęć, sklaerY, TBY);
}
unsafe static void Main(string[] arg)
{
Size s = new Size(200, 200);
bool *m = (bool *)Marshal.AllocHGlobal(10000000);
OperacjeNaStrumieniu.Czyść(m, s.WielkoścWPix());
SprawdzanieWypełnienia sp = new SprawdzanieWypełnienia(3, m, s);
sp.MalujLinie(new Point(80, 30), new Point(30, 30));
sp.MalujLinie(new Point(10, 10), new Point(30, 30));
sp.MalujLinie(new Point(80, 30), new Point(10, 10));
WstepnePrzygotowanie.WskaźnikNaObraz(m, s).Save("ta2.jpg");
}
public byte *ZamianaWMonohromatyczny(Bitmap b)
{
byte *z = OperacjeNaStrumieniu.PonierzMonohormatyczny(b);
if (MnożnikY == null || b.Width == MnożnikX.Length && b.Height == MnożnikY.Length)
{
if (MnożnikX == null)
{
Naładuj(z, b.Size);
}
Zastosuj(z, MnożnikX, MnożnikY);
}
else
{
Zastosuj(z, Matematyka.RozciągnijTablice(MnożnikY, b.Height), Matematyka.RozciągnijTablice(MnożnikX, b.Width));
}
return(z);
}
public static unsafe void FiltrMedianowyOcenaZaszumienia(Size Obraz, byte *ov)
{
byte *c = ov;
int S = Obraz.Width;
int SN = Obraz.Width - 1;
int SP = Obraz.Width + 1;
byte[] a = new byte[9];
IntPtr ir = Marshal.AllocHGlobal(Obraz.WielkoścWPix());
byte * obsugiwana = (byte *)ir;
OperacjeNaStrumieniu.Kopiuj(obsugiwana, ov, Obraz.WielkoścWPix());
ov += SP;
obsugiwana += SP;
for (int i = 1; i < Obraz.Height - 1; i++)
{
for (int x = 1; x < SN; x++, obsugiwana++, ov++)
{
a[0] = obsugiwana[-SN];
a[1] = obsugiwana[-S];
a[2] = obsugiwana[-SP];
a[3] = obsugiwana[-1];
a[4] = obsugiwana[0];
a[5] = obsugiwana[1];
a[6] = obsugiwana[SN];
a[7] = obsugiwana[S];
a[8] = obsugiwana[SP];
Array.Sort(a);
if (*obsugiwana == a[0])
{
*ov = a[1];
}
if (*obsugiwana == a[8])
{
*ov = a[7];
}
}
obsugiwana += 2;
ov += 2;
}
Marshal.FreeHGlobal(ir);
}
private static bool UstalKieróne(ref Linika[] z, ref bool *c, ref Size samLoto, ref ZdjecieZPozycją logo)
{
Point Sierodek = new Point(samLoto.Width, samLoto.Height).Razy(0.5f);
Point WielkoścL = new Point(logo.Obszar.Width, logo.Obszar.Height).Razy(0.5f);
Sierodek = logo.Obszar.Location.Dodaj(WielkoścL).Odejmij(Sierodek);
double XDoY = samLoto.Width; XDoY /= samLoto.Height;
double d = (Math.PI + Math.Atan2(Sierodek.X, Sierodek.Y * XDoY));
double Pi4 = Math.PI / 4;
double Pi2 = Math.PI / 2;
if (d < Pi4 || d > (Math.PI * 2) - Pi4)
{
WykonanyObrót = RodzajObrotu.Brak;
return(false);
}
else if (d < Pi2 + Pi4)
{
WykonanyObrót = RodzajObrotu.ObrótPlus90;
OperacjeNaStrumieniu.ObrótPlus90((byte *)c, ref samLoto);
}
else if (d < Pi4 + 2 * Pi2)
{
WykonanyObrót = RodzajObrotu.Obrót180;
OperacjeNaStrumieniu.Obrót180((byte *)c, samLoto);
}
else if (d < Pi4 + 3 * Pi2)
{
WykonanyObrót = RodzajObrotu.obrótMin90;
OperacjeNaStrumieniu.ObrótMin90((byte *)c, ref samLoto);
}
else
{
throw new NotImplementedException("coś poszło nie tak ");
}
z = PodzielNaLiniki(ref c, ref samLoto, out logo);
return(true);
}
unsafe public static List <ObiektNaMapie> ZnajdźOpszary(ref bool *ws, int x, int y, out int *Mapa)
{
int l = x * y;
bool *kopia = (bool *)Marshal.AllocHGlobal(l);
Mapa = (int *)Marshal.AllocHGlobal(l * 4);
GrafyShp.Icer.OperacjeNaStrumieniu.Czyść((bool *)Mapa, l * 4);
OperacjeNaStrumieniu.Kopiuj(kopia, ws, l);
IntPtr DoZwolnienia = (IntPtr)ws;
List <ObiektNaMapie> obiekt = new List <ObiektNaMapie>();
bool *Początek = ws;
Point Miejsce = new Point();
int Numer = 0;
while (--l >= 0)
{
if (*ws)
{
Numer++;
obiekt.Add(Zlicz(Początek, Miejsce, x, y, Numer, Mapa));
}
ws++;
Miejsce.X++;
if (Miejsce.X == x)
{
Miejsce.X = 0;
Miejsce.Y++;
}
}
Marshal.FreeHGlobal(DoZwolnienia);
ws = kopia;
return(obiekt);
}
public static byte *SkalujMax(this Bitmap b, Size sz)
{
Stopwatch s = Stopwatch.StartNew();
byte * obraz = (byte *)Marshal.AllocHGlobal(sz.Width * sz.Height);
OperacjeNaStrumieniu.Czyść((bool *)obraz, sz.Width * sz.Height);
float XS = (float)(sz.Width - 1); XS /= b.Width - 1;
float YS = (float)(sz.Height - 1); YS /= b.Height - 1;
int[] PodmianyX;
PodmianyX = TablicaSkalująca(b.Width, XS);
BitmapData bc = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
for (int i = 0; i < b.Height; i++)
{
int y = Convert.ToInt32(i * YS);
RGB *rl = (RGB *)((byte *)bc.Scan0 + (i * bc.Stride));
byte *WskaźnikWyjściaLiniki = obraz + sz.Width * y;
for (int j = 0; j < b.Width; j++, rl++)
{
RGB r = *rl;
int jasność = r.R + r.G + r.B;
jasność /= 3;
byte *wsWyjścia = WskaźnikWyjściaLiniki + PodmianyX[j];
byte jasnośćpix = *wsWyjścia;
if (jasność > (*wsWyjścia))
{
*wsWyjścia = (byte)jasność;
}
}
}
Debug.WriteLine(s.ElapsedMilliseconds);
b.UnlockBits(bc);
return(obraz);
}
/// <summary>
/// W przypadku gdy cały obszar jest taki sam próg nie jest progiem gloablnym ale 0
/// </summary>
/// <param name="mr"></param>
/// <param name="Wielkość"></param>
/// <param name="IlośćKratek"></param>
/// <param name="Odwrócenie"></param>
unsafe public static bool *ProgowanieRegionalne(byte *mr, Size Wielkość, Size IlośćKratek, bool Odwrócenie = false)
{
int Długość = Wielkość.Width * Wielkość.Height;
bool *Zw = (bool *)Marshal.AllocHGlobal(Długość);
OperacjeNaStrumieniu.Czyść(Zw, Długość);
bool Prawda = true, Fałsz = false;
if (Odwrócenie)
{
Prawda = false;
Fałsz = true;
}
int[] histogram = new int[256];
int[,] tabhist = new int[IlośćKratek.Height, IlośćKratek.Width];
bool[,] CzyFalse = new bool[IlośćKratek.Height, IlośćKratek.Width];
int DzielnikiX = Wielkość.Width / IlośćKratek.Width;
int DzielnikiY = Wielkość.Height / IlośćKratek.Height;
DzielnikiX += Wielkość.Width % DzielnikiX != 0 ? 1 : 0;
DzielnikiY += Wielkość.Height % DzielnikiY != 0 ? 1 : 0;
int PdzielnikX = DzielnikiX / 2;
int PDzielnikY = DzielnikiY / 2;
PobierzHistogram(Wielkość, mr, histogram);
int PrógGlobalny = MetodaOtsu(histogram);
int IlośćXMinus1 = IlośćKratek.Width - 1;
int IlośćYMinus1 = IlośćKratek.Height - 1;
for (int i = 0; i < IlośćKratek.Height; i++)
{
for (int j = 0; j < IlośćKratek.Width; j++)
{
histogram = new int[256];
for (int ix = 0; ix < DzielnikiY; ix++)
{
byte *Miejsce = mr + Wielkość.Width * (i * DzielnikiY + ix) + j * DzielnikiX;
if (i * DzielnikiY + ix >= Wielkość.Height)
{
break;
}
for (int jx = 0; jx < DzielnikiX; jx++, Miejsce++)
{
if (j * DzielnikiX + jx >= Wielkość.Width)
{
break;
}
histogram[*Miejsce]++;
}
}
if (CzyPrógGlobalny(histogram, 0.1f, 15))
{
tabhist[i, j] = PrógGlobalny;
CzyFalse[i, j] = true;
}
else
{
//int[] HistKopia = (int[])histogram.Clone();
tabhist[i, j] = MetodaOtsu(histogram);
}
}
}
int Dzielnik = 0, Suma, tmp;
for (int i = 0; i < IlośćKratek.Height; i++)
{
for (int j = 0; j < IlośćKratek.Width; j++)
{
histogram = new int[256];
for (int ix = 0; ix < DzielnikiY; ix++)
{
int Zmiana = Wielkość.Width * (i * DzielnikiY + ix) + j * DzielnikiX;
byte *Miejsce = mr + Zmiana;
bool *MiejsceWyjścia = Zw + Zmiana;
if (i * DzielnikiY + ix >= Wielkość.Height)
{
break;
}
for (int jx = 0; jx < DzielnikiX; jx++, Miejsce++, MiejsceWyjścia++)
{
if (j * DzielnikiX + jx >= Wielkość.Width)
{
break;
}
if (CzyFalse[i, j])
{
*MiejsceWyjścia = false;
}
int OdległośćX = Math.Abs(PdzielnikX - jx);
int OdległośćY = Math.Abs(PDzielnikY - ix);
tmp = DzielnikiX - OdległośćX;
Suma = tmp * tabhist[i, j];
Dzielnik = tmp;
tmp = DzielnikiY - OdległośćY;
Suma += tmp * tabhist[i, j];
Dzielnik += tmp;
if (PdzielnikX > jx)
{
if (j > 0)
{
tmp = OdległośćX;
Dzielnik += tmp;
Suma += tmp * tabhist[i, j - 1];
}
}
else
{
if (j < IlośćXMinus1)
{
tmp = OdległośćX;
Dzielnik += tmp;
Suma += tmp * tabhist[i, j + 1];
}
}
if (PDzielnikY > ix)
{
if (i > 0)
{
tmp = OdległośćY;
Dzielnik += tmp;
Suma += tmp * tabhist[i - 1, j];
}
}
else
{
if (i < IlośćYMinus1)
{
tmp = OdległośćY;
Dzielnik += tmp;
Suma += tmp * tabhist[i + 1, j];
}
}
int Próg = Suma / Dzielnik;
* MiejsceWyjścia = *Miejsce < Próg ? Prawda : Fałsz;
}
}
}
}
return(Zw);
}
