Questa pagina è stata tradotta con la traduzione automatica. Fai clic qui per vedere l’originale in inglese.

buffer

Convertitore del vettore del segnale in una matrice di frame di dati

Sintassi

y = buffer(x,n)

y = buffer(x,n,p)

y = buffer(x,n,p,opt)

[y,z] = buffer(___)

[y,z,opt] = buffer(___)

Descrizione

y = buffer(x,n) suddivide un segnale di lunghezza L x in segmenti di dati (frame) non sovrapposti di lunghezza n.

y = buffer(x,n,p) sovrappone o sottopone i frame successivi nella matrice di output di p campioni.

y = buffer(x,n,p,opt) specifica un vettore di campioni da far precedere a x(1) in un buffer con sottosovrapposizione, oppure il numero di campioni iniziali da saltare in un buffer sottosovrapposto.

[y,z] = buffer(___) suddivide un segnale di lunghezza L, ovvero x, in frame di lunghezza n e produce in uscita solo i frame completi in y. Il vettore z contiene i campioni rimanenti. Questa sintassi può includere qualsiasi combinazione di argomenti di input provenienti dalle sintassi precedenti.

[y,z,opt] = buffer(___) restituisce gli ultimi p campioni di un buffer con sottosovrapposizione nell'output opt.

Esempi

Buffer continui sovrapposti

Crea un buffer contenente 100 frame, ciascuno con 10 campioni.

data = buffer(1:1000,10);

Si considerino i frame (colonne) nella matrice data come le uscite sequenziali di una scheda di acquisizione dati che campiona un segnale fisico: data(:,1) è la prima uscita A/D, contenente i primi 11 campioni del segnale, data(:,2) è la seconda uscita, contenente i successivi 11 campioni del segnale, e così via.

Si desidera ribufferare questo segnale dalla dimensione del frame acquisito di 11 a una dimensione del frame di 4 con una sovrapposizione di 1. Chiamare buffer per operare su ogni frame di input successivo, utilizzando il parametro opt per mantenere la coerenza nella sovrapposizione da un buffer all'altro.

Imposta i parametri del buffer. Specificare un valore di –5 per y(1). Il vettore di riporto è inizialmente vuoto.

n = 4;
p = 1;
opt = -5;
z = [];

Ora chiama ripetutamente buffer, passando ogni volta un nuovo frame di segnale (colonna) da data. I campioni in eccesso (restituiti in z) vengono trasferiti e anteposti all'input nella successiva chiamata a buffer.

Per le prime quattro iterazioni, mostra il frame di input [z;x]', i valori di input e output di opt, il buffer di output y e l'overflow z. La dimensione della matrice di output, y, può variare di una singola colonna da un'iterazione all'altra. Questo è tipico delle operazioni di buffering con sovrapposizione o sottosquadro.

for i = 1:size(data,2)
    x = data(:,i);
    [y,z,oppt] = buffer([z;x],n,p,opt);
    if i <= 4
        disp("Iteration " + i)
        ifrm = [z;x]'
        opts = [opt oppt]
        y
        z
        disp("-----------")
    end
    opt = oppt;
end

Iteration 1

ifrm = 1×11

    10     1     2     3     4     5     6     7     8     9    10

opts = 1×2

    -5     9

y = 4×3

    -5     3     6
     1     4     7
     2     5     8
     3     6     9

z = 
10

-----------

Iteration 2

ifrm = 1×12

    19    20    11    12    13    14    15    16    17    18    19    20

opts = 1×2

     9    18

y = 4×3

     9    12    15
    10    13    16
    11    14    17
    12    15    18

z = 2×1

    19
    20

-----------

Iteration 3

ifrm = 1×10

    21    22    23    24    25    26    27    28    29    30

opts = 1×2

    18    30

y = 4×4

    18    21    24    27
    19    22    25    28
    20    23    26    29
    21    24    27    30

z =

  0×1 empty double column vector

-----------

Iteration 4

ifrm = 1×11

    40    31    32    33    34    35    36    37    38    39    40

opts = 1×2

    30    39

y = 4×3

    30    33    36
    31    34    37
    32    35    38
    33    36    39

z = 
40

-----------

Buffer continui con sottosovrapposizione

Crea un buffer contenente 100 frame, ciascuno con 9 campioni.

data = buffer(1:900,9);

Prendi data(:,1) come prima uscita A/D, contenente i primi 11 campioni del segnale, data(:,2) come seconda uscita, contenente i successivi 11 campioni del segnale, e così via.

Si desidera ribufferare questo segnale dalla dimensione del frame acquisito di 11 a una dimensione del frame di 4 con un underlap di 2. Per fare ciò, richiamerai ripetutamente buffer per operare su ogni frame di input successivo, utilizzando il parametro opt per mantenere la coerenza nella sovrapposizione tra un buffer e l'altro.

Imposta i parametri del buffer. Specificare una nuova dimensione del frame pari a 4 e una sovrapposizione inferiore di –2. Salta il primo elemento di input, x(1), impostando opt a 1. Il vettore di riporto è inizialmente vuoto.

n = 4;
p = -2;
opt = 1;
z = [];

Ora chiama ripetutamente buffer, passando ogni volta un nuovo frame di segnale (colonna) da data. I campioni in eccesso (restituiti in z) vengono trasferiti e anteposti all'input nella successiva chiamata a buffer.

Per le prime tre iterazioni, mostra il frame di input [z';x]', i valori di input e output di opt, il buffer di output y e l'overflow z. La dimensione della matrice di output, y, può variare di una singola colonna da un'iterazione all'altra. Questo è tipico delle operazioni di buffering con sovrapposizione o sottosquadro.

for i = 1:size(data,2)
   x = data(:,i);
   [y,z,oppt] = buffer([z';x],n,p,opt);
   if i <= 3
       disp("Iteration "+ i)
       ifrm = [z';x]'
       opts = [opt oppt]
       y
       z
       disp("-----------")
   end
   opt = oppt;
end

Iteration 1

ifrm = 1×11

     8     9     1     2     3     4     5     6     7     8     9

opts = 1×2

     1     0

y = 4×1

     2
     3
     4
     5

z = 1×2

     8     9

-----------

Iteration 2

ifrm = 1×9

    10    11    12    13    14    15    16    17    18

opts = 1×2

     0     1

y = 4×2

     8    14
     9    15
    10    16
    11    17

z =

  1×0 empty double row vector

-----------

Iteration 3

ifrm = 1×11

    26    27    19    20    21    22    23    24    25    26    27

opts = 1×2

     1     0

y = 4×1

    20
    21
    22
    23

z = 1×2

    26    27

-----------

Argomenti di input

x — Segnale di input

vettore

Segnale di ingresso, specificato come vettore.

n — Lunghezza del frame

scalare intero positivo

Lunghezza del frame, specificata come uno scalare intero positivo.

p — Numero di campioni sovrapposti o sottostanti

0 (predefinito) | scalare intero

Numero di campioni sovrapposti o sottosquadrati, specificato come scalare intero.

• Per 0 < p < n (sovrapposizione), buffer ripete gli ultimi p campioni di ogni frame all'inizio del frame successivo. Ad esempio, se x = 1:30 e n = 7, una sovrapposizione di p = 3 appare in questo modo.

  Il primo frame inizia con p zeri (la condizione iniziale predefinita) e il numero di colonne in y è ceil(L/(n-p)).

• Per p < 0 (underlap), buffer salta p campioni tra fotogrammi consecutivi. Ad esempio, se x = 1:30 e n = 7, un buffer con sottosquadro di p = -3 ha questo aspetto.

  Il numero di colonne in y è ceil(L/(n-p)).

opt — Opzione

zeros(p,1) (predefinito) | "nodelay" | vettore | intero

Opzione, specificata come vettore o numero intero.

• Per 0 < p < n (sovrapposizione), opt specifica un vettore di lunghezza p da inserire prima di x(1) nel buffer. Questo vettore può essere considerato una condizione iniziale, necessaria quando l'operazione di buffering corrente è una di una sequenza di operazioni di buffering consecutive. Per mantenere la sottosovrapposizione dei frame da un buffer all'altro, opt deve contenere gli ultimi p campioni del buffer precedente nella sequenza. Vedi Buffering continuo qui sotto.

  Per impostazione predefinita, opt è zeros(p,1) per un buffer con sottosovrapposizione. Imposta opt su "nodelay" per saltare la condizione iniziale e iniziare subito a riempire il buffer con x(1). In questo caso, L deve essere length(p) o più lungo. Ad esempio, se x = 1:30 e n = 7, un buffer con sovrapposizione di p = 3 ha questo aspetto.

• Per p < 0 (underlap), opt è un valore intero nell'intervallo [0,-p] che specifica il numero di campioni di input iniziali, x(1:opt), da saltare prima di aggiungere campioni al buffer. Il primo valore nel buffer è quindi x(opt+1). Per impostazione predefinita, opt è zero per un buffer con sottosovrapposizione.

  Questa opzione è particolarmente utile quando l'operazione di buffering corrente fa parte di una sequenza di operazioni di buffering consecutive. Per mantenere la sottosovrapposizione dei frame da un buffer all'altro, opt deve essere uguale alla differenza tra il numero totale di punti da saltare tra i frame (p) e il numero di punti che erano disponibili da saltare nell'input precedente a buffer. Se l'input precedente conteneva meno di p punti che potevano essere saltati dopo aver riempito l'ultimo frame di quel buffer, i restanti opt punti devono essere rimossi dal primo frame del buffer corrente. Per un esempio pratico, consultare Buffering continuo.

Argomenti di output

y — Frame dei dati

matrice

Data frame, restituito come matrice. Ogni data frame occupa una colonna di y, che ha n righe e ceil(L/n) colonne. Se L non è divisibile per n, l'ultima colonna viene riempita con zeri fino a raggiungere la lunghezza n.

• Se y è un buffer con sottosovrapposizione, ha n righe e m colonne, dove m = floor(L/(n-p)) quando length(opt) = p o m = ceil((L-p)/(n-p)) quando opt = "nodelay".

• Se y è un buffer con sottosovrapposizione, ha n righe e m colonne, dove m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p)) >= n).

z — Campioni rimanenti

vettore

I campioni rimanenti vengono restituiti come vettore. Se il numero di campioni nel vettore di input (dopo le opportune operazioni di sovrapposizione o sottosquadro) supera il numero di posizioni disponibili nel buffer n-per-m, i campioni rimanenti in x vengono inviati nel vettore z, che per un buffer di sovrapposizione ha lunghezza L - m*(n-p) quando length(opt) = p o L - ((m-1)*(n-p)+n) quando opt = "nodelay", e per un buffer di sottosquadro ha lunghezza (L-opt) - m*(n-p).

• Se y è un buffer con sottosovrapposizione o un buffer non sovrapposto, allora z ha lo stesso orientamento (riga o colonna) di x.

• Se y è un buffer con sottosovrapposizione, allora z viene restituito come vettore riga.

Se dopo aver riempito il buffer con la sovrapposizione o la sottosovrapposizione specificata non rimangono campioni nell'input, z è un vettore vuoto.

opt — Ultimi campioni p

vettore

Ultimi campioni p, restituiti come vettore. In un buffer con sottosovrapposizione, opt è la differenza tra il numero totale di punti da saltare tra i frame (-p) e il numero di punti in x che erano disponibili per essere saltati dopo aver riempito l'ultimo frame. In una sequenza di operazioni di buffering, l'output opt di ciascuna operazione deve essere utilizzato come input opt per l'operazione di buffering successiva. Ciò garantisce che la sovrapposizione o la sottosquadratura desiderata dei fotogrammi venga mantenuta da un buffer all'altro, nonché da un fotogramma all'altro all'interno dello stesso buffer. Per un esempio pratico, consultare Buffering continuo.

• Per 0 < p < n (sovrapposizione), opt (come output) contiene i campioni finali p nell'ultimo frame del buffer. Questo vettore può essere utilizzato come condizione iniziale per una successiva operazione di buffering in una sequenza di operazioni di buffering consecutive. Ciò consente di mantenere la sovrapposizione dei frame desiderata da un buffer all'altro.

• Per p < 0 (sottoscorrimento), opt (come output) è la differenza tra il numero totale di punti da saltare tra i frame (p) e il numero di punti in x che erano disponibili per essere saltati dopo aver riempito l'ultimo frame: opt = m*(n-p) + opt - L, dove opt a destra è l'argomento di input per buffer e opt a sinistra è l'argomento di output. z è il vettore vuoto. Qui m è il numero di colonne nel buffer, con m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p))>=n).

  Si noti che per un'uscita buffer sovrapposta, opt è sempre zero quando l'uscita z contiene dati.

  L'output opt per un buffer con sottosovrapposizione è particolarmente utile quando l'operazione di buffering corrente è una di una sequenza di operazioni di buffering consecutive. L'output opt di ogni operazione di buffering specifica il numero di campioni che devono essere saltati all'inizio dell'operazione di buffering successiva per mantenere la sottosovrapposizione dei frame desiderata da un buffer all'altro. Se dopo aver riempito l'ultimo frame del buffer corrente sono disponibili meno di p punti da saltare, i restanti opt punti devono essere rimossi dal primo frame del buffer successivo.

Diagnostica

Vengono visualizzati messaggi di errore quando p ≥ n o length(opt) ≠ length(p) in un caso di buffer sovrapposto:

La sovrapposizione dei frame P deve essere inferiore alla dimensione del buffer N.<xid="1"></x>Le condizioni iniziali devono essere specificate come un vettore di lunghezza P.

Ulteriori informazioni

Buffering continuo

In un'operazione di buffering continuo, il vettore di input della funzione buffer rappresenta un frame in una sequenza di frame che costituiscono un segnale discreto. Questi frame di segnale possono avere origine in un processo di acquisizione dati basato su frame, oppure all'interno di un algoritmo basato su frame come la FFT.

Ad esempio, è possibile acquisire dati da una scheda A/D in frame da 64 campioni. Nel caso più semplice, si potrebbero riorganizzare i dati in frame da 16 campioni; buffer con n = 16 crea un buffer di quattro frame da ogni frame di input a 64 elementi. Il risultato è che il segnale di dimensione 64 è stato convertito in un segnale di dimensione 16; non sono stati aggiunti né rimossi campioni.

Nel caso generale in cui la dimensione originale del frame del segnale, L, non sia divisibile in modo uniforme per la nuova dimensione del frame, n, l'overflow dell'ultimo frame deve essere catturato e riciclato nel buffer successivo. È possibile farlo chiamando iterativamente buffer sull'input x con la sintassi a due argomenti di output:

[y,z] = buffer([z;x],n)     % x is a column vector.
[y,z] = buffer([z,x],n)     % x is a row vector.

Questo semplicemente cattura qualsiasi overflow del buffer in z e antepone i dati all'input successivo nella successiva chiamata a buffer. Anche in questo caso, il segnale di ingresso, x, di dimensione del frame L, è stato convertito in un segnale di dimensione del frame n senza alcuna inserzione o cancellazione di campioni.

Si noti che il buffering continuo non può essere effettuato con la sintassi a uscita singola y = buffer(...), perché l'ultimo frame di y in questo caso è riempito con zeri, il che aggiunge nuovi campioni al segnale.

Il buffering continuo in presenza di sovrapposizione e sottoscorrimento viene gestito tramite il parametro opt, che funge sia da input che da output per buffer. I due esempi presenti in questa pagina dimostrano come utilizzare il parametro opt.

Funzionalità estese

Generazione di codice C/C++

Genera codice C e C++ con MATLAB® Coder™.

Note sull'utilizzo e limitazioni:

• L'input p deve essere costante in fase di compilazione.

Generazione di codice GPU

Genera codice CUDA® per GPU NVIDIA® con GPU Coder™.

Consultare le note d'uso e le limitazioni nella sezione Generazione di codice C/C++. Le stesse note d'uso e limitazioni si applicano alla generazione di codice GPU.

Array GPU

Accelera il codice mediante esecuzione su un’unità di elaborazione grafica (GPU) con Parallel Computing Toolbox™.

Questa funzione supporta pienamente gli GPU array. Per ulteriori informazioni, vedere Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Cronologia versioni

Introduzione prima di R2006a

R2023b: Utilizzare argomenti di input non doppi

La funzione buffer supporta argomenti di input non di tipo double.

R2023a: Genera codice C e C++

Generare codice C e C++ autonomo per la funzione buffer. È necessario disporre di MATLAB^® Coder™ per utilizzare questa funzionalità.

Vedi anche

reshape