Metoda de codare analogică și discretă. Procesarea Fourier a imaginilor digitale

Imaginile formate din elemente discrete, fiecare dintre ele pot lua doar un număr finit de valori distinse care se schimbă într-un timp finit, sunt numite discrete. Trebuie subliniat faptul că elementele unei imagini discrete, în general, pot avea o suprafață inegală și fiecare dintre ele poate avea un număr inegal de gradații distinse.

După cum sa arătat în primul capitol, retina transmite imagini discrete către părțile superioare ale analizorului vizual.

Continuitatea lor aparenta este doar una dintre iluziile vederii. Această „cuantificare” a imaginilor inițial continue nu este determinată de limitările asociate rezoluției sistem optic ochi şi nici măcar morfologic elemente structurale sistemul vizual și organizare functionala rețele nervoase.

Imaginea este împărțită în elemente discrete prin câmpuri receptive care unesc unul sau altul număr de fotoreceptori. Câmpurile receptive produc selecția primară a utilului semnal luminos prin însumare spaţială şi temporală.

Partea centrală a retinei (fovea) este ocupată numai de conuri; la periferia din afara foveei există atât conuri, cât și bastonașe. În condiții de vedere pe timp de noapte, câmpurile conice din partea centrală a retinei au aproximativ aceeași dimensiune (aproximativ 5" în măsura unghiulară). Numărul de astfel de câmpuri din fovee, ale căror dimensiuni unghiulare sunt de aproximativ 90", este de aproximativ 200. Rolul principal în condițiile de vedere pe timp de noapte îl joacă câmpurile de bastonașe, care ocupă întreaga suprafață rămasă a retinei. Au o dimensiune unghiulară de aproximativ 1° pe întreaga suprafață a retinei. Numărul de astfel de câmpuri în retină este de aproximativ 3 mii. Nu numai detectarea, ci și vizualizarea obiectelor slab luminate în aceste condiții este efectuată de zonele periferice ale retinei.

Pe măsură ce iluminarea crește, un alt sistem de celule de stocare - câmpurile receptive conice - începe să joace un rol major. În fovee, o creștere a iluminării determină o scădere treptată a intensității efective a câmpului până când, la o luminozitate de aproximativ 100 asb, aceasta este redusă la un singur con. La periferie, odată cu creșterea iluminării, câmpurile de tije se sting treptat (încetinește) și intră în acțiune câmpurile conice. Câmpurile conice din periferie, ca și câmpurile foveale, au capacitatea de a scădea în funcție de energia luminoasă incidentă asupra lor. Cea mai mare cantitate conurile, pe care câmpurile receptive ale conurilor le pot avea odată cu creșterea iluminării, crește de la centru până la marginile retinei și la o distanță unghiulară de 50-60° față de centru ajunge la aproximativ 90.

Se poate calcula ca in conditii bune lumina zilei numărul de câmpuri receptive ajunge la aproximativ 800 mii. Această valoare corespunde aproximativ numărului de fibre din nervul optic uman. Discriminarea (rezoluția) obiectelor în vederea diurnă este efectuată în principal de fovee, unde câmpul receptiv poate fi redus la un singur con, iar conurile în sine sunt localizate cel mai dens.

Dacă numărul de celule de stocare ale retinei poate fi determinat la o aproximare satisfăcătoare, atunci nu există încă date suficiente pentru a determina numărul de stări posibile ale câmpurilor receptive. Doar unele estimări pot fi făcute pe baza studiului pragurilor diferențiale ale câmpurilor receptive. Contrastul de prag în câmpurile receptive foveale într-un anumit domeniu de iluminare de funcționare este de ordinul 1. În acest caz, numărul de gradații distinse este mic. Pe întreaga gamă de restructurare a câmpului receptiv con foveal, diferă 8-9 gradații.

Perioada de acumulare în câmpul receptiv - așa-numita durată critică - este determinată în medie de o valoare de aproximativ 0,1 secunde, dar la niveluri înalte aparent, iluminarea poate fi redusă semnificativ.

De fapt, modelul care descrie structura discretă imagini transmise, ar trebui să fie și mai dificil. Ar trebui să se ia în considerare relația dintre dimensiunile câmpului receptiv, praguri și durata critică, precum și natura statistică a pragurilor vizuale. Dar deocamdată nu este nevoie de asta. Este suficient să ne imaginăm ca model de imagine un set de elemente de suprafață egală, ale căror dimensiuni unghiulare sunt mai mici decât dimensiunile unghiulare ale celui mai mic detaliu rezolvat cu ochiul, al căror număr de stări distinse este mai mare decât număr maxim gradații distinse ale luminozității, iar timpul de schimbare discretă este mai mic decât perioada de pâlpâire la frecvența critică a fuziunii de pâlpâire.

Dacă înlocuiți imaginile unor obiecte reale continue ale lumii exterioare cu astfel de imagini discrete, ochiul nu va observa înlocuirea.* În consecință, imaginile discrete de acest fel conțin macar nu mai puține informații decât le percepe sistemul vizual. **

* Imaginile color și volum pot fi, de asemenea, înlocuite cu un model discret.
** Problema înlocuirii imaginilor continue cu unele discrete este importantă pentru tehnologia filmului și a televiziunii. Cuantizarea timpului este baza acestei tehnici. În sistemele de televiziune cu coduri de impulsuri, imaginea este, de asemenea, împărțită în elemente discrete și cuantificată prin luminozitate.

Spune și arată cu un exemplu Pascal: 1) Ce este absolut și pentru ce este? 2) Ce este asm și pentru ce este? 3) Ce este

constructor și destructor și pentru ce este?

4) Ce este implementarea și pentru ce este aceasta?

5) Denumiți modulele Pascal (în linia Utilizări, de exemplu crt) și ce capacități oferă acest modul?

6) Ce tip de variabilă este: pointer

7) Și în sfârșit: ce înseamnă simbolul @, #, $, ^?

1. Ce este un obiect?2. Ce este un sistem?3. Care este numele comun al unui obiect? Dați un exemplu.4. Care este numele unui singur obiect? Dați un exemplu.5.

Dați un exemplu de sistem natural.6. Dați un exemplu de sistem tehnic.7. Dați un exemplu de sistem mixt.8. Dați un exemplu de sistem intangibil.9. Ce este clasificarea?10. Ce este o clasă de obiecte?

1. Întrebarea 23 - enumerați modurile de funcționare ale bazei de date de acces:

Crearea unui tabel în modul design;
-crearea unui tabel cu ajutorul vrăjitorului;
-crearea unui tabel prin introducerea datelor.

2. ce este format vectorial?

3. Următoarele pot fi clasificate ca programe de servicii:
a) programe de întreținere a discului (copiere, dezinfectare, formatare etc.)
b) comprimarea fișierelor de pe discuri (arhive)
c) lupta împotriva virușilor informatici și multe altele.
Eu însumi cred că răspunsul aici este B - corect sau greșit?

4. în ceea ce privește proprietățile algoritmului (a. discretitate, b. eficacitate c. caracter de masă, d. certitudine, d. fezabilitate și înțelegere) - aici cred că toate opțiunile sunt corecte. Corect sau greșit?

testează 7 întrebări ușoare cu răspunsuri multiple

13. Viteza de ceas a procesorului este:

A. numărul de operaţii binare efectuate de procesor pe unitatea de timp

B. numărul de impulsuri generate pe secundă care sincronizează funcționarea nodurilor computerului

C. numărul de accesări posibile de procesor la memorie cu acces aleator pe unitatea de timp

D. viteza schimbului de informații între procesor și dispozitivele de intrare/ieșire

14. Specificați minimul set necesar dispozitive concepute pentru funcționarea computerului:

O imprimantă, unitate de sistem, tastatură

B. procesor, RAM, monitor, tastatură

C. procesor, streamer, hard disk

D. monitor, unitate de sistem, tastatură

15. Ce este un microprocesor?

A. circuit integrat, care execută comenzile primite la intrarea și controalele sale

Operarea calculatorului

B. un dispozitiv pentru stocarea datelor care este adesea folosit la locul de muncă

C. un dispozitiv de afișare a textului sau a informațiilor grafice

D. dispozitiv pentru ieșirea datelor alfanumerice

16.Interacțiunea utilizatorului cu mediu software realizat folosind:

A. sistem de operare

B. sistem de fișiere

C. Aplicații

D. manager de fişiere

17.Control direct software utilizatorul poate efectua cu

De:

A. sistem de operare

B. GUI

C. Interfata utilizator

D. manager de fişiere

18. Metode de stocare a datelor pe medii fizice defineste:

A. sistem de operare

B. software aplicativ

C. sistem de fișiere

D. manager de fişiere

19. Mediu grafic în care sunt afișate obiectele și controalele sisteme Windows,

Creat pentru confortul utilizatorului:

A. interfaţă hardware

B. interfata utilizator

C. desktop

D. interfata software

20. Viteza unui computer depinde de:

A. frecvența ceasului procesor

B. prezența sau absența unei imprimante conectate

C. organizarea interfeţei sistemului de operare

D. capacitatea de stocare externă

Imagine analogă și discretă. Informații grafice poate fi reprezentat în formă analogă sau discretă. Exemplu imagine analogică poate fi un tablou a cărui culoare se schimbă continuu și un exemplu de imagine discretă imprimată folosind imprimanta cu jet de cerneala desen format din puncte individuale culoare diferita. Analog (pictură în ulei). Discret.

Slide 11 din prezentare „Codificarea și prelucrarea informațiilor”. Dimensiunea arhivei cu prezentarea este de 445 KB.

Informatica clasa a IX-a

rezumat alte prezentări

„Algoritmi de ramificare a structurii” - condiție IF, acțiune THEN. Ce știm? Structura lecției. Algoritm de ramificare. Completați algoritmul și completați tabelul. Elevul care înscrie de la 85 la 100 de puncte, inclusiv, trece în turul doi al competiției. Introduceți numărul de puncte și stabiliți dacă a ajuns în a doua rundă. Găsiți cel mai mare număr între a și b. Scrieți un program într-un limbaj de programare. Un algoritm de ramificare este un algoritm în care, în funcție de condiție, se realizează fie una, fie alta secvență de acțiuni.

„Crearea inteligenței artificiale” - Abordare prin simulare. Abordări ale construirii sistemelor de inteligență artificială. Abordare evolutivă. Inteligenţă artificială. Poate conviețui cu mulți oameni, ajutând să facă față probleme personale. Abordare structurală. Abordare logică. Probleme în timpul dezvoltării. Perspective de dezvoltare și domenii de aplicare.

„Programe ciclice” - Digital. Buclă cu precondiție. Găsiți suma. Bucla cu postcondiție. Buclă cu un parametru. algoritmul lui Euclid. Programe ciclice. Găsiți suma numere naturale. Conceptul de ciclu. O taxă inițială. Tabularea funcțiilor. Calculati. Exemplu. Divizoare. Informatică. Aflați numărul de numere. Găsi. Aflați numărul de numere naturale din trei cifre. Numere din trei cifre. Găsiți setul de valori ale funcției. Tabel de conversie a dolarului.

„Ce este e-mailul” - Expeditorul. Adresa de e-mail. Istoricul e-mailurilor. Întrebarea apariției e-mailului. Structura literei. Dirijarea corespondenței. Scrisoare. E-mail. Copie. Data de. X-mailer. E-mail. Cum functioneazã E-mail.

„Lucrul cu e-mailul” - Adresă de e-mail. Cutie poștală. Protocolul de e-mail. Rețea de partajare a fișierelor. Separarea adreselor. Beneficiile emailului. Clienții de corespondență. Inventatorul e-mailului. Abordare. E-mail. Software pentru lucrul cu e-mailul. Cum funcționează e-mailul. Teleconferinta. Server de mail. Distribuire a unui fisier.

„Se procesează în Photoshop” - Băieți cool. Cum să distingem un fals. Raster și imagini vectoriale. Introducere. Locuri de top. programul Adobe Photoshop. Retușare. Concursuri pentru lucrul cu Photoshop. Reglarea luminozității. Prietenii mei. Partea practică. Programe similare. Parte principală. Proiecta. Animale neobișnuite. Montaj de mai multe imagini.

În capitolul anterior am studiat sisteme liniare spațial invariante într-un domeniu bidimensional continuu. În practică, avem de-a face cu imagini care au dimensiuni limitate și în același timp sunt măsurate într-un set discret de puncte. Prin urmare, metodele dezvoltate până acum trebuie adaptate, extinse și modificate astfel încât să poată fi aplicate într-o astfel de zonă. Apar și câteva puncte noi care necesită o analiză atentă.

Teorema de eșantionare spune în ce condiții este posibil să se reconstruiască cu precizie dintr-un set discret de valori imagine continuă. De asemenea, vom afla ce se întâmplă atunci când nu sunt îndeplinite condițiile de aplicabilitate ale acestuia. Toate acestea au o legătură directă cu dezvoltarea sistemelor vizuale.

Metode care necesită trecerea la domeniul de frecventa, a devenit popular parțial datorită algoritmilor de calcul rapid transformare discretă Fourier. Cu toate acestea, trebuie avut grijă deoarece aceste metode necesită prezența semnal periodic. Vom discuta cum poate fi îndeplinită această cerință și care sunt consecințele încălcării acesteia.

7.1. Limită de dimensiune a imaginii

În practică, imaginile au întotdeauna dimensiuni finite. Luați în considerare o imagine dreptunghiulară cu lățimea și înălțimea H. Acum nu este nevoie să luați integrale în transformarea Fourier peste limite infinite:

Este interesant că nu trebuie să știm deloc frecvențele pentru a restabili funcția. A ști că la reprezintă o constrângere dură. Cu alte cuvinte, o funcție care este diferită de zero doar într-o regiune limitată a planului imaginii conține mult mai puține informații decât o funcție care nu are această proprietate.

Pentru a vedea acest lucru, imaginați-vă că planul ecranului este acoperit cu copii imaginea dată. Cu alte cuvinte, ne extindem imaginea la o funcție care este periodică în ambele direcții

Aici este cel mai mare număr întreg care nu depășește x. Transformata Fourier a unei astfel de imagini multiplicate are forma

Prin utilizarea într-un mod adecvat factori de convergență selectați în Ex. 7.1 se demonstrează că

Prin urmare,

de unde vedem ca este egal cu zero peste tot cu exceptia unui set discret de frecvente.Astfel, pentru a-l gasi, este suficient sa stim in aceste puncte. Cu toate acestea, funcția este obținută prin simpla tăiere a secțiunii pentru care . Prin urmare, pentru a-l restabili, este suficient să știm numai pentru toată lumea Acesta este un set numărabil de numere.

Rețineți că transformarea unei funcții periodice se dovedește a fi discretă. Conversie inversă poate fi reprezentat ca o serie, deoarece

Fotografie digitală sau altele imagine raster este o serie de numere înregistrate de senzorii de nivel de luminozitate într-un plan bidimensional. Știind că, din punct de vedere matematic, o lentilă subțire realizează o transformată Fourier a imaginilor plasate în planuri focale, este posibil să se creeze algoritmi de procesare a imaginii care sunt analogi procesării imaginii de către un sistem optic clasic.

Formula pentru astfel de algoritmi va arăta astfel:

1. Z=FFT(X) – transformată Fourier bidimensională directă
2. Z′=T(Z) – aplicarea unei funcții sau transparență la transformarea Fourier a unei imagini
3. Y=BFT(Z′) – transformată Fourier bidimensională inversă

Pentru a calcula transformatele Fourier, sunt utilizați algoritmi rapidi de transformare Fourier. Deși sistemul optic de lentile efectuează transformarea Fourier pe domeniul continuu al argumentului și pentru spectrul continuu, dar când treceți la prelucrare digitală date, formulele de transformare Fourier pot fi înlocuite cu formulele de transformare Fourier discrete.

Exemple de implementare

• Algoritmul de estompare a imaginii

Algoritmii implementați fac parte dintr-o bibliotecă open source cod sursa FFTTools. Adresă de internet: github.com/dprotopopov/FFTTools

Algoritmul de estompare a imaginii

În sistemele optice, diafragma, situată în planul focal, este un simplu orificiu în ecran. Ca urmare a trecerii flux luminos prin diafragmă, undele de înaltă frecvență (lungimi de undă mai scurte) trec prin obstacol, iar undele de frecvență joasă (lungimi de undă mai lungi) sunt tăiate de ecran. Acest lucru crește claritatea imaginii rezultate. Dacă înlocuiți o gaură din ecran cu un obstacol în ecran, rezultatul va fi imagine neclară, deoarece se va forma din frecvențe de lungimi de undă mari.

Algoritm:

1. Calculați tabloul Z′=T(Z), unde T este repunerea la zero a rândurilor și coloanelor situate în zonele interne date ale matricei argumentelor corespunzătoare frecvențelor înalte (adică punerea la zero a coeficienților de expansiune Fourier corespunzătoare). frecvente inalte)

Algoritm de clarificare a imaginii

În sistemele optice, diafragma, situată în planul focal, este un simplu orificiu în ecran. Ca urmare a trecerii luminii prin diafragmă, undele de înaltă frecvență (cu lungimi de undă mai scurte) trec prin obstacol, iar undele de joasă frecvență (cu lungimi de undă mai mari) sunt tăiate de ecran. Acest lucru crește claritatea imaginii rezultate.

Algoritm:

1. Fie X(N1,N2) o matrice de luminozități ale pixelilor imaginii.
2. Calculați Px = luminozitatea medie (rms) a pixelilor din matricea X
3. Calculați tabloul Z=FT(X) – transformată Fourier discretă bidimensională directă
4. Salvați valoarea L=Z(0,0) – corespunzătoare luminozității medii a pixelilor imaginii originale
5. Calculați matricea Z′=T(Z), unde T este repunerea la zero a rândurilor și coloanelor situate în zonele externe date ale matricei argumentelor corespunzătoare frecvențelor joase (adică reducerea la zero a coeficienților de expansiune Fourier corespunzători frecvențelor joase). )
6. Restabiliți valoarea Z’(0,0)=L – corespunzătoare luminozității medii a pixelilor imaginii originale
7. Calculați tabloul Y=RFT(Z′) – transformată Fourier discretă bidimensională inversă
8. Calculați Py = luminozitatea medie (rms) a pixelilor din matricea Y
9. Normalizați matricea Y(N1,N2) cu nivelul mediu de luminozitate Px/Py

Algoritm de scalare a imaginii

În sistemele optice, fluxul luminos în planul focal al sistemului este o transformată Fourier a imaginii originale. Dimensiunea imaginii obtinute la iesirea sistemului optic este determinata de raportul dintre distantele focale ale obiectivului si ocularului.

Algoritm:

1. Fie X(N1,N2) o matrice de luminozități ale pixelilor imaginii.
2. Calculați Px = luminozitatea medie (rms) a pixelilor din matricea X
3. Calculați tabloul Z=FT(X) – transformată Fourier discretă bidimensională directă
4. Calculați matricea Z′=T(Z), unde T fie adaugă zero rânduri și coloane ale matricei corespunzătoare frecvențelor înalte, fie elimină rândurile și coloanele matricei corespunzătoare frecvențelor înalte pentru a obține dimensiunea necesară a imaginii finale
5. Calculați tabloul Y=RFT(Z′) – transformată Fourier discretă bidimensională inversă
6. Calculați Py = luminozitatea medie (rms) a pixelilor din matricea Y
7. Normalizați matricea Y(M1,M2) cu nivelul mediu de luminozitate Px/Py

Software utilizat

• Microsoft Studio vizual 2013 C# - mediu și limbaj de programare
• EmguCV/OpenCV – Biblioteca C++ de structuri și algoritmi pentru procesarea imaginilor
• FFTWSharp/FFTW – Bibliotecă C++ care implementează algoritmi rapidi de transformare Fourier

Algoritmul de estompare a imaginii

Cod algoritm

///

/// Ștergeți regiunea internă a matricei ///

/// Matrice de valori /// Dimensiunea regiunii oarbe interne private static void Blind(Date complexe[,], Dimensiune dimensiune) ( int n0 = data.GetLength(0); int n1 = data.GetLength(1); int n2 = data.GetLength(2); int s0 = Math.Max(0, (n0 - size.Height)/2 ); int s1 = Math.Max(0, (n1 - dimensiune.Latime)/2); int e0 = Math.Min((n0 + dimensiune.Inaltime)/2, n0); int e1 = Math.Min(( n1 + dimensiune.Lățimea)/2, n1); pentru (int i = s0; i< e0; i++) { Array.Clear(data, i*n1*n2, n1*n2); } for (int i = 0; i < s0; i++) { Array.Clear(data, i*n1*n2 + s1*n2, (e1 - s1)*n2); } for (int i = e0; i < n0; i++) { Array.Clear(data, i*n1*n2 + s1*n2, (e1 - s1)*n2); } } ///

/// Blur bitmap cu Cea mai rapidă transformată Fourier ///

/// Bitmap încețoșat public Bitmap Blur(Bitmap bitmap) (folosind (var imagine = imagine nouă (bitmap)) ( int lungime = imagine.Data.Length; int n0 = imagine.Data.GetLength(0); int n1 = imagine.Data.GetLength(1); int n2 = imagine.Data.GetLength(2); var doubles = new double; Buffer.BlockCopy(image.Data, 0, doubles, 0, length*sizeof (double)); double power = Math.Sqrt(doubles.Average(x => x*x)); var input = new fftw_complexarray(doubles.Select(x => new Complex(x, 0)).ToArray()); var output = new fftw_complexarray(lungime); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction. Înainte, fftw_flags.Estimate).Execute(); Complex complex = output.GetData_Complex(); var data = new Complex; var buffer = new double; GCHandle complexHandle = GCHandle.Alloc(complex, GCHandleType.Pinned); GCHandle dataHandle = GCHandle .Alloc(data, GCHandleType.Pinned); IntPtr complexPtr = complexHandle.AddrOfPinnedObject(); IntPtr dataPtr = dataHandle.AddrOfPinnedObject(); Marshal.Copy(complexPtr, bufferhal,.Copy, 0th); , dataPtr, buffer.Length);Blind(data, _blinderSize); Marshal.Copy(dataPtr, buffer, 0, buffer.Length); Marshal.Copy(buffer, 0, complexPtr, buffer.Length); complexHandle.Free(); dataHandle.Free(); input.SetData(complex); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction.Backward, fftw_flags.Estimate).Execute(); double array2 = output.GetData_Complex().Select(x => x.Magnitude).ToArray(); putere dublă2 = Math.Sqrt(array2.Average(x => x*x)); dublează = array2.Select(x =>

Algoritm de clarificare a imaginii

Cod algoritm

///

/// Ștergeți regiunea externă a matricei ///

/// Matrice de valori /// Dimensiunea regiunii oarbe externe private static void Blind(Complex[,] date, Size size) ( int n0 = data.GetLength(0); int n1 = data.GetLength(1); int n2 = data.GetLength(2); int s0 = Math. Max(0, (n0 - dimensiune.Înălțime)/2); int s1 = Math.Max(0, (n1 - dimensiune.Lățime)/2); int e0 = Math.Min((n0 + dimensiune.Înălțime)/ 2, n0); int e1 = Math.Min((n1 + size.Width)/2, n1); for (int i = 0; i< s0; i++) { Array.Clear(data, i*n1*n2, s1*n2); Array.Clear(data, i*n1*n2 + e1*n2, (n1 - e1)*n2); } for (int i = e0; i < n0; i++) { Array.Clear(data, i*n1*n2, s1*n2); Array.Clear(data, i*n1*n2 + e1*n2, (n1 - e1)*n2); } } ///

/// Hartă de biți clară cu cea mai rapidă transformată Fourier ///

/// bitmap ascuțit public Bitmap Sharp(Bitmap bitmap) (folosind (var imagine = imagine nouă (bitmap)) ( int lungime = imagine.Data.Length; int n0 = imagine.Data.GetLength(0); int n1 = imagine.Data.GetLength(1); int n2 = imagine.Data.GetLength(2); var doubles = new double; Buffer.BlockCopy(image.Data, 0, doubles, 0, length*sizeof (double)); double power = Math.Sqrt(doubles.Average(x => x*x)); var input = new fftw_complexarray(doubles.Select(x => new Complex(x, 0)).ToArray()); var output = new fftw_complexarray(lungime); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction. Înainte, fftw_flags.Estimate).Execute(); Complex complex = output.GetData_Complex(); Complex level = complex; var data = new Complex; var buffer = new double; GCHandle complexHandle = GCHandle.Alloc(complex, GCHandleType.Pinned) ; GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); IntPtr complexPtr = complexHandle.AddrOfPinnedObject(); IntPtr dataPtr = dataHandle.AddrOfPinnedObject(); Marshal,bufferplex.0fPinnedObject(); Marshal. . Copiere(buffer, 0, dataPtr, buffer.Length); Blind(date, _blinderSize); Marshal.Copy(dataPtr, buffer, 0, buffer.Length); Marshal.Copy(buffer, 0, complexPtr, buffer.Length); complexHandle.Free(); dataHandle.Free(); complex = nivel; input.SetData(complex); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction.Backward, fftw_flags.Estimate).Execute(); double array2 = output.GetData_Complex().Select(x => x.Magnitude).ToArray(); putere dublă2 = Math.Sqrt(array2.Average(x => x*x)); dublează = array2.Select(x => x*power/power2).ToArray(); Buffer.BlockCopy(double, 0, image.Data, 0, length*sizeof (double)); imagine returnată.Bitmap; ) )

Algoritm de scalare a imaginii

Cod algoritm

///

/// Copiați matrice ///

/// Matrice de intrare /// Matrice de ieșire private static void Copy(Complex[,] input, Complex[,] output) ( int n0 = input.GetLength(0); int n1 = input.GetLength(1); int n2 = input.GetLength(2); int m0 = output.GetLength(0); int m1 = output.GetLength(1); int m2 = output.GetLength(2); int ex0 = Math.Min(n0, m0)/2; int ex1 = Math.Min(n1) , m1)/2; int ex2 = Math.Min(n2, m2); Debug.Assert(n2 == m2); for (int k = 0; k< ex2; k++) { for (int i = 0; i <= ex0; i++) { for (int j = 0; j <= ex1; j++) { int ni = n0 - i - 1; int nj = n1 - j - 1; int mi = m0 - i - 1; int mj = m1 - j - 1; output = input; output = input; output = input; output = input; } } } } ///

/// Redimensionați bitmap cu cea mai rapidă transformată Fourier ///

/// Bitmap redimensionat public Bitmap Stretch(Bitmap bitmap) (folosind (var imagine = imagine nouă (bitmap)) ( int lungime = imagine.Data.Length; int n0 = imagine.Data.GetLength(0); int n1 = imagine.Data.GetLength(1); int n2 = imagine.Data.GetLength(2); var doubles = new double; Buffer.BlockCopy(image.Data, 0, doubles, 0, length*sizeof (double)); double power = Math.Sqrt(doubles.Average(x => x*x)); var input = new fftw_complexarray(doubles.Select(x => new Complex(x, 0)).ToArray()); var output = new fftw_complexarray(lungime); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction. Înainte, fftw_flags.Estimate).Execute(); Complex complex = output.GetData_Complex(); folosind (var image2 = new Image (_newSize)) ( int lungime2 = imagine2.Data.Length; int m0 ​​​​= imagine2.Data.GetLength(0); int m1 = imagine2.Data.GetLength(1); int m2 = imagine2.Data.GetLength(2) ); var complex2 = complex nou; var data = complex nou; var data2 = complex nou; var buffer = dublu nou; GCHandle complexHandle = GCHandle.Alloc(complex, GCHandleType.Pinned); GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType .Pinned ); IntPtr complexPtr = complexHandle.AddrOfPinnedObject(); IntPtr dataPtr = dataHandle.AddrOfPinnedObject(); Marshal.Copy(complexPtr, buffer, 0, buffer.Length);(databuffer,.Copy, buffer.Length); Marshal.Copy(complexPtr, buffer, 0, buffer.Length); ); complexHandle.Free(); dataHandle.Free(); Copy(date, data2); buffer = new double; complexHandle = GCHandle.Alloc(complex2, GCHandleType.Pinned); dataHandle = GCHandle.Alloc(data2, GCHandleType.Pinned ); complexPtr = complexHandle.AddrOfPinnedObject(); dataPtr = dataHandle.AddrOfPinnedObject(); Marshal.Copy(dataPtr, buffer, 0, buffer.Length); Marshal.Copy(buffer, 0, complexPtr, buffer.Leng); complexHandle.Free(); dataHandle.Free(); var input2 = new fftw_complexarray(complex2); var output2 = new fftw_complexarray(lungime2); fftw_plan.dft_3d(m0, m1, m2, input2, output2, fftw_direction.Backward, fftw_flags.Estimate).Execute(); double array2 = output2.GetData_Complex().Select(x => x.Magnitude).ToArray(); putere dublă2 = Math.Sqrt(array2.Average(x => x*x)); double doubles2 = array2.Select(x => x*power/power2).ToArray(); Buffer.BlockCopy(doubles2, 0, image2.Data, 0, length2*sizeof (double)); returnează imaginea2.Bitmap; ) ) )