Immagine analogica e discreta. Immagini discrete

Di norma, i segnali entrano nel sistema di elaborazione delle informazioni in forma continua. Per elaborazione informatica i segnali continui devono prima essere convertiti in digitali. Per fare ciò vengono eseguite operazioni di campionamento e quantizzazione.

Campionamento di immagini

Campionamento– questa è la trasformazione di un segnale continuo in una sequenza di numeri (campioni), cioè la rappresentazione di questo segnale secondo una base a dimensione finita. Questa rappresentazione consiste nel proiettare un segnale su una base data.

Il più conveniente dal punto di vista dell'organizzazione dell'elaborazione e in modo naturale il campionamento è la rappresentazione dei segnali sotto forma di un campione dei loro valori (campioni) in punti individuali, regolarmente distanziati. Questo metodo si chiama rasterizzazione e la sequenza di nodi in cui vengono prelevati i campioni è raster. Viene chiamato l'intervallo attraverso il quale vengono presi i valori di un segnale continuo fase di campionamento. Si chiama il reciproco del passo frequenza di campionamento,

Una domanda essenziale che sorge durante il campionamento: a quale frequenza dovremmo prelevare campioni di segnale per poterlo ricostruire a partire da questi campioni? Ovviamente, se i campioni vengono prelevati troppo raramente, non conterranno informazioni su un segnale in rapido cambiamento. La velocità di variazione di un segnale è caratterizzata dalla frequenza superiore del suo spettro. Pertanto, l'ampiezza minima consentita dell'intervallo di campionamento è correlata alla frequenza più alta dello spettro del segnale (inversamente proporzionale ad essa).

Nel caso del campionamento uniforme vale quanto segue: Il teorema di Kotelnikov, pubblicato nel 1933 nell'opera “On larghezza di banda etere e filo nelle telecomunicazioni”. Dice: se un segnale continuo ha uno spettro limitato dalla frequenza, allora può essere ricostruito completamente e inequivocabilmente dai suoi campioni discreti presi con un periodo, ad es. con frequenza.

Il ripristino del segnale viene effettuato utilizzando la funzione . Kotelnikov ha dimostrato che un segnale continuo che soddisfa i criteri di cui sopra può essere rappresentato come una serie:

.

Questo teorema è anche chiamato teorema del campionamento. Viene anche chiamata la funzione funzione di campionamento o Kotelnikov, sebbene una serie di interpolazioni di questo tipo sia stata studiata da Whitaker nel 1915. La funzione di conteggio ha estensione infinita nel tempo e raggiunge il suo massimo valore, uguale a uno, nel punto rispetto al quale è simmetrico.

Ognuna di queste funzioni può essere considerata come una risposta ad un ideale filtro basse frequenze (filtro passa-basso) all'impulso delta che arriva all'istante . Pertanto, per ripristinare un segnale continuo dai suoi campioni discreti, è necessario farli passare attraverso un filtro passa-basso appropriato. Va notato che un tale filtro è non causale e fisicamente irrealizzabile.

Il rapporto di cui sopra significa la possibilità di ricostruire accuratamente segnali con uno spettro limitato dalla sequenza dei loro campioni. Segnali a spettro limitato– si tratta di segnali il cui spettro di Fourier differisce da zero solo entro una porzione limitata dell'area di definizione. I segnali ottici possono essere classificati come uno di questi, perché Lo spettro di Fourier delle immagini ottenute nei sistemi ottici è limitato a causa delle dimensioni limitate dei loro elementi. La frequenza viene chiamata Frequenza di Nyquist. Questa è la frequenza limite al di sopra della quale non dovrebbero essere presenti componenti spettrali nel segnale di ingresso.

Quantizzazione dell'immagine

A elaborazione digitale Nelle immagini, una gamma dinamica continua di valori di luminosità è suddivisa in un numero di livelli discreti. Questa procedura si chiama quantizzazione. La sua essenza sta nella trasformazione di una variabile continua in una variabile discreta che assume un insieme finito di valori. Questi valori sono chiamati livelli di quantizzazione. IN caso generale la trasformazione è espressa da una funzione a gradino (Fig. 1). Se l'intensità dell'immagine campione appartiene all'intervallo (ovvero, quando ), quindi il campione originale viene sostituito dal livello di quantizzazione, dove – soglie di quantizzazione. Si presuppone che l'intervallo dinamico dei valori di luminosità sia limitato e pari a .

Riso. 1. Funzione che descrive la quantizzazione

Il compito principale in questo caso è determinare i valori delle soglie e dei livelli di quantizzazione. Il modo più semplice la soluzione a questo problema consiste nel partizionamento gamma dinamica a intervalli uguali. Questa soluzione però non è la migliore. Se i valori di intensità della maggior parte dei conteggi delle immagini sono raggruppati, ad esempio, nella regione “scura” e il numero di livelli è limitato, è consigliabile una quantizzazione non uniforme. Nella regione “scura” è necessario quantizzare più spesso, mentre nella regione “chiara” meno spesso. Ciò ridurrà l'errore di quantizzazione.

Nei sistemi di elaborazione delle immagini digitali, si sforzano di ridurre il numero di livelli e soglie di quantizzazione, poiché la quantità di informazioni richieste per codificare un'immagine dipende dal loro numero. Tuttavia, con relativamente un piccolo numero livelli nell’immagine quantizzata, potrebbero apparire falsi contorni. Sorgono come risultato di un brusco cambiamento nella luminosità dell'immagine quantizzata e sono particolarmente evidenti nelle aree piatte del suo cambiamento. I falsi contorni degradano significativamente la qualità visiva dell'immagine, poiché la visione umana è particolarmente sensibile ai contorni. Quando si quantizzano uniformemente immagini tipiche, sono necessari almeno 64 livelli.

Nel capitolo precedente abbiamo studiato i sistemi lineari spazialmente invarianti in un dominio bidimensionale continuo. In pratica si tratta di immagini che hanno dimensioni limitate e allo stesso tempo si misurano in un insieme discreto di punti. Pertanto, i metodi sviluppati finora necessitano di essere adattati, estesi e modificati in modo da poter essere applicati in tale ambito. Emergono inoltre diversi nuovi punti che richiedono un’attenta considerazione.

Il teorema del campionamento dice in quali condizioni è possibile ricostruire accuratamente a partire da un insieme discreto di valori immagine continua. Impareremo anche cosa succede quando le sue condizioni di applicabilità non vengono soddisfatte. Tutto ciò ha un impatto diretto sullo sviluppo dei sistemi visivi.

Metodi che richiedono la transizione a dominio della frequenza, divenne popolare in parte grazie agli algoritmi per il calcolo veloce della trasformata discreta di Fourier. Tuttavia, è necessario prestare attenzione poiché questi metodi richiedono la presenza di segnale periodico. Discuteremo come soddisfare questo requisito e quali sono le conseguenze della sua violazione.

7.1. Limite dimensione immagine

In pratica le immagini hanno sempre dimensioni finite. Consideriamo un'immagine rettangolare con larghezza e altezza H. Ora non è necessario prendere integrali nella trasformata di Fourier su limiti infiniti:

È interessante notare che non abbiamo bisogno di conoscere tutte le frequenze per ripristinare la funzione. Sapere che rappresenta un vincolo difficile. In altre parole, una funzione che è diversa da zero solo in una regione limitata del piano dell'immagine contiene molte meno informazioni di una funzione che non ha questa proprietà.

Per vederlo, immagina che il piano dello schermo sia coperto di copie data immagine. In altre parole, espandiamo la nostra immagine a una funzione periodica in entrambe le direzioni

Ecco il più grande intero non superiore a x. La trasformata di Fourier di un'immagine così moltiplicata ha la forma

Usando in modo adeguato fattori di convergenza selezionati nell'Es. 7.1 è dimostrato che

Quindi,

da dove vediamo che è uguale a zero ovunque tranne che in un insieme discreto di frequenze, quindi per trovarlo è sufficiente conoscere questi punti. Tuttavia la funzione si ottiene semplicemente tagliando la sezione per la quale . Pertanto, per ripristinarlo, ci basta sapere solo per tutti Questo è un insieme numerabile di numeri.

Si noti che la trasformazione di una funzione periodica risulta essere discreta. Conversione inversa può essere rappresentato come una serie, poiché

Una persona è in grado di percepire e immagazzinare informazioni sotto forma di immagini (visive, sonore, tattili, gustative e olfattive). Immagini visive possono essere salvati sotto forma di immagini (disegni, fotografie, ecc.) e quelli sonori possono essere registrati su dischi, nastri magnetici, dischi laser e così via.

Le informazioni, inclusi grafica e audio, possono essere presentate in forma analogica o discreta. Con la rappresentazione analogica, una grandezza fisica assume un numero infinito di valori, ed i suoi valori cambiano continuamente. Con una rappresentazione discreta, una grandezza fisica assume un insieme finito di valori e il suo valore cambia bruscamente.

Un esempio di rappresentazione analogica di informazioni grafiche è, ad esempio, un dipinto il cui colore cambia continuamente, e una rappresentazione discreta è un'immagine stampata utilizzando una stampante a getto d'inchiostro e composta da singoli punti Colore diverso. Esempio di memorizzazione analogica informazioni sull'audioÈ disco in vinile(la traccia audio cambia forma continuamente) e discreto – un compact disc audio (la cui traccia audio contiene aree con diversa riflettività).

La conversione delle informazioni grafiche e sonore dalla forma analogica a quella discreta viene effettuata mediante campionamento, ovvero dividendo un'immagine grafica continua e un segnale sonoro continuo (analogico) in singoli elementi. Il processo di campionamento prevede la codifica, ovvero l'assegnazione a ciascun elemento di un valore specifico sotto forma di codice.

Campionamento è la trasformazione di immagini e suoni continui in un insieme di valori discreti sotto forma di codici.

Codifica delle immagini

Crea e archivia oggetti grafici in un computer ci sono due modi: come raster o come vettore Immagine. Ogni tipo di immagine utilizza il proprio metodo di codifica.

Codifica bitmap

Un'immagine raster è una raccolta di punti (pixel) di diversi colori. Un pixel è l'area più piccola di un'immagine il cui colore può essere impostato in modo indipendente.

Durante il processo di codifica, un'immagine viene discretizzata spazialmente. Il campionamento spaziale di un'immagine può essere paragonato alla costruzione di un'immagine da un mosaico (un gran numero di piccoli vetri multicolori). L'immagine è divisa in piccoli frammenti separati (punti) e a ciascun frammento viene assegnato un valore di colore, ovvero un codice colore (rosso, verde, blu e così via).

Per un'immagine in bianco e nero, il volume di informazioni di un punto è uguale a un bit (bianco o nero - 1 o 0).

Per quattro colori – 2 bit.

Per 8 colori sono necessari 3 bit.

Per 16 colori – 4 bit.

Per 256 colori – 8 bit (1 byte).

La qualità dell'immagine dipende dal numero di punti (minore è la dimensione dei punti e, di conseguenza, maggiore è il loro numero, migliore è la qualità) e dal numero di colori utilizzati (più colori, migliore è la qualità dell'immagine codificata ).

Per rappresentare il colore come codice numerico vengono utilizzati due modelli di colore inversi: RGB O CMYK. Il modello RGB viene utilizzato in televisori, monitor, proiettori, scanner, fotocamere digitali... I colori principali in questo modello sono: rosso (Rosso), verde (Verde), blu (Blu). Colore Modello CMYK utilizzato nella stampa quando si formano immagini destinate alla stampa su carta.

Le immagini a colori possono avere diverse profondità di colore, determinate dal numero di bit utilizzati per codificare il colore di un punto.

Se codifichiamo il colore di un pixel in un'immagine con tre bit (un bit per ogni colore RGB), otteniamo tutti gli otto colori diversi.

			Colore
			Viola

In pratica, per memorizzare informazioni sul colore di ciascun punto di un'immagine a colori nel modello RGB, vengono solitamente allocati 3 byte (ovvero 24 bit) - 1 byte (ovvero 8 bit) per il valore del colore di ciascun componente . Pertanto, ciascuna componente RGB può assumere un valore compreso tra 0 e 255 (28 = 256 valori in totale) e ciascun punto dell'immagine, con tale sistema di codifica, può essere colorato in uno dei 16.777.216 colori. Questo insieme di colori viene solitamente chiamato True Color, perché l'occhio umano non è ancora in grado di distinguere una varietà maggiore.

Affinché si formi un'immagine sullo schermo del monitor, le informazioni su ciascun punto (codice colore del punto) devono essere archiviate nella memoria video del computer. Calcoliamo la quantità di memoria video richiesta per uno dei modalità grafiche. Nei computer moderni, la risoluzione dello schermo è solitamente di 1280x1024 pixel. Quelli. totale 1280 * 1024 = 1310720 punti. Con una profondità di colore di 32 bit per pixel, la quantità di memoria video richiesta è: 32 * 1310720 = 41943040 bit = 5242880 byte = 5120 KB = 5 MB.

Le immagini raster sono molto sensibili al ridimensionamento (ingrandimento o riduzione). Quando un'immagine raster viene ridotta, diversi punti vicini vengono convertiti in uno solo, quindi si perde la visibilità dei dettagli più fini dell'immagine. Quando si ingrandisce l'immagine, la dimensione di ciascun punto aumenta e appare un effetto scalino visibile ad occhio nudo.

Fotografia digitale o altro immagine rasterè una serie di numeri registrati dai sensori del livello di luminosità su un piano bidimensionale. Sapendo che, da un punto di vista matematico, una lente sottile esegue una trasformata di Fourier di immagini poste su piani focali, è possibile creare algoritmi di elaborazione delle immagini analoghi all'elaborazione delle immagini da parte di un sistema ottico classico.

La formula per tali algoritmi sarà simile alla seguente:

1. Z=FFT(X) – trasformata di Fourier bidimensionale diretta
2. Z′=T(Z) – applicazione di una funzione o trasparenza alla trasformata di Fourier di un'immagine
3. Y=BFT(Z′) – trasformata di Fourier bidimensionale inversa

Per calcolare le trasformate di Fourier vengono utilizzati algoritmi di trasformata di Fourier discreti veloci. Sebbene il sistema di lenti ottiche esegua la trasformata di Fourier su una gamma continua di argomenti e per spettro continuo, ma quando si passa all'elaborazione digitale dei dati, le formule della trasformata di Fourier possono essere sostituite con formule della trasformata di Fourier discreta.

Esempi di implementazione

• Algoritmo di sfocatura dell'immagine

Gli algoritmi implementati fanno parte di una libreria open source codice sorgente Strumenti FFT. Indirizzo Internet: github.com/dprotopopov/FFTTools

Algoritmo di sfocatura dell'immagine

Nei sistemi ottici il diaframma, situato nel piano focale, è un semplice foro sullo schermo. Come risultato del passaggio flusso luminoso attraverso il diaframma, le onde ad alta frequenza (lunghezze d'onda più corte) passano attraverso l'ostruzione e le onde a bassa frequenza (lunghezze d'onda più lunghe) vengono tagliate dallo schermo. Ciò aumenta la nitidezza dell'immagine risultante. Se sostituisci un buco nello schermo con un ostacolo nello schermo, il risultato sarà immagine sfocata, poiché sarà formato da frequenze di lunghe lunghezze d'onda.

Algoritmo:

1. Calcolare l'array Z′=T(Z), dove T è l'azzeramento delle righe e delle colonne situate nelle aree interne date della matrice degli argomenti corrispondenti alle 5. frequenze alte (ovvero l'azzeramento dei coefficienti di espansione di Fourier corrispondenti alte frequenze)

Algoritmo di nitidezza delle immagini

Nei sistemi ottici il diaframma, situato nel piano focale, è un semplice foro sullo schermo. Come risultato del passaggio della luce attraverso il diaframma, le onde ad alta frequenza (con lunghezze d'onda più corte) attraversano l'ostacolo e le onde a bassa frequenza (con lunghezze d'onda più lunghe) vengono tagliate dallo schermo. Ciò aumenta la nitidezza dell'immagine risultante.

Algoritmo:

1. Sia X(N1,N2) un array di luminosità dei pixel dell'immagine.
2. Calcola Px = luminosità media (rms) dei pixel nell'array X
3. Calcola l'array Z=FT(X) – trasformata di Fourier discreta bidimensionale diretta
4. Salva il valore L=Z(0,0) – corrispondente alla luminosità media dei pixel dell'immagine originale
5. Calcolare l'array Z′=T(Z), dove T è l'azzeramento delle righe e delle colonne situate nelle aree esterne date della matrice degli argomenti corrispondenti alle 6. frequenze basse (ovvero l'azzeramento dei coefficienti di espansione di Fourier corrispondenti alle basse frequenze )
6. Ripristina il valore Z’(0,0)=L – corrispondente alla luminosità media dei pixel dell'immagine originale
7. Calcola l'array Y=RFT(Z′) – trasformata di Fourier discreta bidimensionale inversa
8. Calcola Py = luminosità media (rms) dei pixel nell'array Y
9. Normalizza l'array Y(N1,N2) in base al livello di luminosità medio Px/Py

Algoritmo di ridimensionamento delle immagini

Nei sistemi ottici, il flusso luminoso nel piano focale del sistema è una trasformata di Fourier dell'immagine originale. Dimensioni dell'uscita sistema ottico l'immagine è determinata dal rapporto tra le lunghezze focali dell'obiettivo e dell'oculare.

Algoritmo:

1. Sia X(N1,N2) un array di luminosità dei pixel dell'immagine.
2. Calcola Px = luminosità media (rms) dei pixel nell'array X
3. Calcola l'array Z=FT(X) – trasformata di Fourier discreta bidimensionale diretta
4. Calcola l'array Z′=T(Z), dove T aggiunge zero righe e colonne della matrice corrispondenti alle alte frequenze o rimuove righe e colonne della matrice corrispondenti alle alte frequenze per ottenere la dimensione richiesta dell'immagine finale
5. Calcola l'array Y=RFT(Z′) – trasformata di Fourier discreta bidimensionale inversa
6. Calcola Py = luminosità media (rms) dei pixel nell'array Y
7. Normalizza l'array Y(M1,M2) in base al livello di luminosità medio Px/Py

Software utilizzato

• Microsoft Studio visivo 2013 C# - ambiente e linguaggio di programmazione
• EmguCV/OpenCV – Libreria C++ di strutture e algoritmi per l'elaborazione delle immagini
• FFTWSharp/FFTW – Libreria C++ che implementa algoritmi di trasformata di Fourier discreti veloci

Algoritmo di sfocatura dell'immagine

Codice dell'algoritmo

///

/// Cancella la regione interna dell'array ///

/// Matrice di valori /// Dimensioni della regione cieca interna vuoto statico privato Blind(Complesso[,] dati, Taglia taglia) ( int n0 = dati.GetLength(0); int n1 = dati.GetLength(1); int n2 = dati.GetLength(2); int s0 = Math.Max(0, (n0 - size.Height)/2 ); int s1 = Math.Max(0, (n1 - dimensione.Larghezza)/2); int e0 = Math.Min((n0 + dimensione.Altezza)/2, n0); int e1 = Math.Min(( n1 + size.Width)/2, n1); for (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); } } ///

/// Sfoca la bitmap con il Trasformata di Fourier più veloce ///

/// Bitmap blu public Bitmap Blur(Bitmap bitmap) ( utilizzando (var image = new Image (bitmap)) ( int length = image.Data.Length; int n0 = image.Data.GetLength(0); int n1 = image.Data.GetLength(1); int n2 = image.Data.GetLength(2); var doubles = nuovo 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(length); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction. Avanti, fftw_flags.Estimate).Execute(); Complesso complesso = output.GetData_Complex(); var data = nuovo Complesso; var buffer = nuovo double; GCHandle complexHandle = GCHandle.Alloc(complesso, GCHandleType.Pinned); GCHandle dataHandle = GCHandle .Alloc(dati, GCHandleType.Pinned); IntPtr complexPtr = complexHandle.AddrOfPinnedObject(); IntPtr dataPtr = dataHandle.AddrOfPinnedObject(); Marshal.Copy(complexPtr, buffer, 0, buffer.Length); Marshal.Copy(buffer, 0 , 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(complesso); 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(); doppia potenza2 = Math.Sqrt(array2.Average(x => x*x)); raddoppia = array2.Select(x =>

Algoritmo di nitidezza delle immagini

Codice dell'algoritmo

///

/// Cancella la regione esterna dell'array ///

/// Matrice di valori /// Dimensioni della regione cieca esterna private static void Blind(Complex[,] data, Size size) ( int n0 = data.GetLength(0); int n1 = data.GetLength(1); int n2 = data.GetLength(2); int s0 = Math. Max(0, (n0 - dimensione.Altezza)/2); int s1 = Math.Max(0, (n1 - dimensione.Larghezza)/2); int e0 = Math.Min((n0 + dimensione.Altezza)/ 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); } } ///

/// Bitmap nitida con la trasformata di Fourier più veloce ///

/// bitmap nitida public Bitmap Sharp(Bitmap bitmap) ( utilizzando (var image = new Image (bitmap)) ( int length = image.Data.Length; int n0 = image.Data.GetLength(0); int n1 = image.Data.GetLength(1); int n2 = image.Data.GetLength(2); var doubles = nuovo 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(length); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction. Avanti, fftw_flags.Estimate).Execute(); Complesso complesso = output.GetData_Complex(); Livello complesso = complesso; var data = nuovo Complesso; var buffer = nuovo doppio; GCHandle complexHandle = GCHandle.Alloc(complesso, GCHandleType.Pinned) ; GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned); IntPtr complexPtr = complexHandle.AddrOfPinnedObject(); IntPtr dataPtr = dataHandle.AddrOfPinnedObject(); Marshal.Copy(complexPtr, buffer, 0, buffer.Length); Marshal. Copia(buffer, 0, dataPtr, buffer.Lunghezza); Cieco(dati, _blinderSize); Marshal.Copy(dataPtr, buffer, 0, buffer.Length); Marshal.Copy(buffer, 0, complexPtr, buffer.Length); complexHandle.Free(); dataHandle.Free(); complesso = livello; input.SetData(complesso); 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(); doppia potenza2 = Math.Sqrt(array2.Average(x => x*x)); raddoppia = array2.Select(x => x*power/power2).ToArray(); Buffer.BlockCopy(doubles, 0, image.Data, 0, length*sizeof (double)); restituisce immagine.Bitmap; ) )

Algoritmo di ridimensionamento delle immagini

Codice dell'algoritmo

///

/// Copia gli array ///

/// Matrice di input /// Matrice di output private static void Copia(Complesso[,] input, Complesso[,] 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; } } } } ///

/// Ridimensiona la bitmap con la trasformata di Fourier più veloce ///

/// Bitmap ridimensionata public Bitmap Stretch(Bitmap bitmap) ( utilizzando (var image = new Image (bitmap)) ( int length = image.Data.Length; int n0 = image.Data.GetLength(0); int n1 = image.Data.GetLength(1); int n2 = image.Data.GetLength(2); var doubles = nuovo 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(length); fftw_plan.dft_3d(n0, n1, n2, input, output, fftw_direction. Avanti, fftw_flags.Estimate).Execute(); Complesso complesso = output.GetData_Complex(); utilizzando (var image2 = new Image (_newSize)) ( int length2 = image2.Data.Length; int m0 ​​= image2.Data.GetLength(0); int m1 = image2.Data.GetLength(1); int m2 = image2.Data.GetLength(2 ); var complex2 = nuovo complesso; var data = nuovo complesso; var data2 = nuovo complesso; var buffer = nuovo 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, buffer, 0, buffer.Length); Marshal.Copy(buffer, 0, dataPtr, buffer.Length) ); complexHandle.Free(); dataHandle.Free(); Copy(dati, dati2); buffer = nuovo 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.Length); complexHandle.Free(); dataHandle.Free(); var input2 = new fftw_complexarray(complex2); var output2 = new fftw_complexarray(length2); 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(); doppia potenza2 = 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)); restituisce immagine2.Bitmap; ) ) )

Spiega e mostra con un esempio Pascal: 1) Cos'è l'assoluto e a cosa serve? 2) Cos'è l'ASM e a cosa serve? 3) Cos'è

costruttore e distruttore e a cosa serve?

4) Cos'è l'implementazione e a cosa serve?

5) Assegna un nome ai moduli Pascal (nella riga Uses, ad esempio crt) e quali funzionalità fornisce questo modulo?

6) Che tipo di variabile è: puntatore

7) E infine: cosa significa il simbolo @, #, $, ^?

1. Cos'è un oggetto?2. Cos'è un sistema?3. Qual è il nome comune di un oggetto? Fai un esempio.4. Qual è il nome di un singolo oggetto? Fai un esempio.5.

Fornisci un esempio di sistema naturale.6. Fornire un esempio di sistema tecnico.7. Fornisci un esempio di sistema misto.8. Fornire un esempio di sistema immateriale.9. Cos'è la classificazione?10. Cos'è una classe di oggetti?

1. Domanda 23 - elencare le modalità operative del database di accesso:

Creazione di una tabella in modalità progettazione;
-creare una tabella utilizzando la procedura guidata;
-creare una tabella inserendo i dati.

2. cos'è formato vettoriale?

3. Possono essere classificati come programmi di servizio:
a) programmi di manutenzione del disco (copia, disinfezione, formattazione, ecc.)
b) compressione di file su dischi (archiviatori)
c) lotta ai virus informatici e molto altro ancora.
Personalmente penso che la risposta qui sia B: giusto o sbagliato?

4. per quanto riguarda le proprietà dell'algoritmo (a. discrezione, b. efficacia c. carattere di massa, d. certezza, d. fattibilità e comprensibilità) - qui penso che tutte le opzioni siano corrette. Giusto o sbagliato?

prova 7 semplici domande a scelta multipla

13. La velocità di clock del processore è:

A. il numero di operazioni binarie eseguite dal processore per unità di tempo

B. il numero di impulsi generati al secondo che sincronizzano il funzionamento dei nodi del computer

C. il numero di possibili accessi al processore memoria ad accesso casuale per unità di tempo

D. velocità di scambio delle informazioni tra il processore e i dispositivi di input/output

14. Specificare il minimo insieme necessario dispositivi progettati per il funzionamento del computer:

Una stampante, unità di sistema, tastiera

B. processore, RAM, monitor, tastiera

C. processore, streamer, disco rigido

D. monitor, unità di sistema, tastiera

15. Cos'è un microprocessore?

UN. circuito integrato, che esegue i comandi ricevuti al suo ingresso e controlla

Funzionamento del computer

B. un dispositivo per la memorizzazione dei dati che viene spesso utilizzato al lavoro

C. un dispositivo per visualizzare informazioni testuali o grafiche

D. dispositivo per l'emissione di dati alfanumerici

16.Interazione dell'utente con ambiente software effettuato utilizzando:

A. sistema operativo

B. file system

C. Applicazioni

D. file manager

17.Controllo diretto Software l'utente può eseguire con

Di:

A. sistema operativo

B. GUI

C. Interfaccia utente

D. file manager

18. Modalità di conservazione dei dati su supporto fisico definisce:

A. sistema operativo

B. software applicativo

C.file system

D. file manager

19. Ambiente grafico su cui vengono visualizzati oggetti e controlli Sistemi Windows,

Creato per comodità dell'utente:

A. interfaccia hardware

B. interfaccia utente

C. desktop

D. interfaccia software

20. La velocità di un computer dipende da:

UN. frequenza dell'orologio processore

B. presenza o assenza di una stampante collegata

C. organizzazione dell'interfaccia del sistema operativo

D. capacità di archiviazione esterna