ChinaAET "aplicações eletrônicas" publicou uma referência valiosa "baseada em FPGA implementação de hardware de tempo real do filtro mediano", este trabalho utiliza FPGA + SRAM filtragem mediana permite em tempo real, é também pensamento útil (é claro, só em tempo real implementação que Bingo baste) com Shift_RAM. Ok, mudar de assunto, nosso foco agora é como obter rapidamente a média de nove valores, o documento apresenta algum tipo rápida, como mostrado abaixo:
A partir da figura, em primeiro lugar, três tipos de pixels por linha, seguido por extracção com três valores máximos do mínimo, o valor mínimo do valor máximo, e uma mediana do mediano; finalmente obtidos em três valor, o valor intermediário é extraído para se obter o resultado final. 3 para calcular o custo de todo o CLK, sem a necessidade de conseguir um método de borbulhar é muito poupança de tempo.
Em frente ao módulo foi projetado VIP_Matrix_Generate_3X3_8Bit, enormes esforços passados, finalmente conseguimos o pixel variedade sonho 3 * 3, cada pixel é 8Bit profundidade. Em seguida, começou a projetar e algoritmo de implementação do filtro médio.
(1) Em primeiro lugar, cada fileira de três pixels de cada classificação, Verilog HDL para alcançar devido ao paralelismo, precisamos apenas de um relógio, para alcançar o seguinte:
módulo Sort3
(
CLK entrada,
rst_n entrada,
dados 1 de entrada, dados 2, dados3,
saída reg max_data, mid_data, min_data
);
// -----------------------------------
// Classificar de 3 datas
sempre @ (posedge clk ou rst_n negedge)
começar
if (! rst_n)
começar
max_data < = 0;
mid_data < = 0;
min_data < = 0;
final
mais
começar
// obter o valor máximo
if (data1 > = Data2 && dados1 > = Data3)
max_data < = Dados1;
else if (data2 > = Dados1 && dados2 > = Data3)
max_data < = Data2;
else // (data3 > = Dados1 && dados3 > = Data2)
max_data < = Data3;
// obter o valor médio
if ((data1 > = Data2 && dados1 < = Data3) || (dados1 > = Data3 && dados1 < = Data2))
mid_data < = Dados1;
else if ((data2 > = Dados1 && dados2 < = Data3) || (dados2 > = Data3 && dados2 < = Dados1))
mid_data < = Data2;
else // ((data3 > = Dados1 && dados3 < = Data2) || (dados3 > = Data2 && dados3 < = Dados1))
mid_data < = Data3;
// ge o valor min
if (data1 < = Data2 && dados1 < = Data3)
min_data < = Dados1;
else if (data2 < = Dados1 && dados2 < = Data3)
min_data < = Data2;
else // (data3 < = Dados1 && dados3 < = Data2)
min_data < = Data3;
final
final
O circuito para atingir o primeiro passo do cálculo, a nova Median_Filter_3X3.v, formas de realização da Sort3 segue:
// Passo 1
fio max_data1, mid_data1, min_data1;
Sort3 u_Sort3_1
(
.clk (RCL),
.rst_n (rst_n),
.data1 (data11),
.data2 (data12),
.data3 (dados13),
.max_data (max_data1),
.mid_data (mid_data1),
.min_data (min_data1)
);
(2) Em seguida, três linhas de pixels do processamento tipo adquirido, isto é, um valor mínimo do máximo três, o valor mínimo do máximo três, valor médio e o valor intermédio de três. Aqui forma de realização do módulo Sort3 directamente, como mostrado abaixo:
// Passo 2
fio max_min_data, mid_mid_data, min_max_data;
Sort3 u_Sort3_4
(
.clk (RCL),
.rst_n (rst_n),
.data1 (max_data1),
.data2 (max_data2),
.data3 (max_data3),
.max_data,
.mid_data,
.min_data (max_min_data)
);
Sort3 u_Sort3_5
(
.clk (RCL),
.rst_n (rst_n),
.data1 (mid_data1),
.data2 (mid_data2),
.data3 (mid_data3),
.max_data,
.mid_data (mid_mid_data),
.min_data
);
Sort3 u_Sort3_6
(
.clk (RCL),
.rst_n (rst_n),
.data1 (min_data1),
.data2 (min_data2),
.data3 (min_data3),
.max_data (min_max_data),
.mid_data,
.min_data
);
(3) Finalmente, os três valores (2) obtido, novamente tomando o valor, determinado nas nove valores finais de pixel como se segue:
// step3
Sort3 u_Sort3_7
(
.clk (RCL),
.rst_n (rst_n),
.data1 (max_min_data),
.data2 (mid_mid_data),
.data3 (min_max_data),
.max_data,
.mid_data (target_data),
.min_data
);
Ok, a partir de (1) - (3), que levou 3 Relógio, acabado matriz de pixel média 3 * 3 extraído. FIG RTL estes três passos, como mostrado abaixo, nove pixels de entrada, de saída do valor alvo do pixel:
Finalmente, os valores de extracção Exemplo VIP_Gray_Median_Filter.v como se segue:
// filtro mediano de 3X3 datas, precisamos 3 relógio
mid_value fio;
Median_Filter_3X3 u_Median_Filter_3X3
(
.clk (RCL),
.rst_n (rst_n),
// ROW1
.data11 (matrix_p11),
.data12 (matrix_p12),
.data13 (matrix_p13),
// ROW2
.data21 (matrix_p21),
.data22 (matrix_p22),
.data23 (matrix_p23),
// row3
.data31 (matrix_p31),
.data32 (matrix_p32),
.data33 (matrix_p33),
.target_data (mid_value)
);
Desde que leva três relógios, o campo de linha, pixels necessário habilitar o movimento do respectivo três relógio, sincronização é mantida, o que é muito importante, como segue:
// ------------------------------------------
// lag 3 relógios de sinal de sincronismo
reg per_frame_vsync_r;
reg per_frame_href_r;
sempre @ (posedge clk ou rst_n negedge)
começar
if (! rst_n)
começar
per_frame_vsync_r < = 0;
per_frame_href_r < = 0;
final
mais
começar
per_frame_vsync_r < = {Per_frame_vsync_r, matrix_frame_vsync};
per_frame_href_r < = {Per_frame_href_r, matrix_frame_href};
final
final
Atribuir post_frame_vsync = per_frame_vsync_r;
Atribuir post_frame_href = per_frame_href_r;
Atribuir post_img_Gray = post_frame_href mid_value: 8'd0 ;?
Finalmente, a simulação FIG Modelsim dá a filtragem de média, como se mostra em (nova arquitectura faz _clken *) como mostrado abaixo:
Tem que chegar na frente da base 3 * 3 sobre a realização de um filtro de mediana tem sido muito fácil, é claro, a premissa é que você domina estes conteúdos design. Na forma de realização de VIP_Image_Processor VIP_Gray_Median_Filter, como segue:
// --------------------------------------
// Grey filtro mediano de imagem para melhor qualidade de imagem.
post3_frame_vsync fio; // Os dados de imagem processados vsync sinal válido
post3_frame_href fio; // Os dados de imagem processados href sinal vaild
fio post3_img_Gray; // imagem processada saída de Grey
VIP_Gray_Median_Filter
# (
.IMG_HDISP (IMG_HDISP), // 640 * 480
.IMG_VDISP (IMG_VDISP)
)
u_VIP_Gray_Median_Filter
(
// relógio mundial
.clk (RCL), // relógio CMOS de pixel vídeo
.rst_n (rst_n), // redefinição mundial
// Os dados de imagem prepred ser processd
.per_frame_vsync (post2_frame_vsync), // sinal válido dados imagem preparada vsync
.per_frame_href (post2_frame_href), // Os dados de imagem preparadas href sinal vaild
.per_img_Gray (post2_img_Gray), // input O brilho da imagem Prepared
// Os dados de imagem tem sido processd
.post_frame_vsync (post3_frame_vsync), // sinal válido dados imagem processada vsync
.post_frame_href (post3_frame_href), // Os dados de imagem processados href sinal vaild
.post_img_Gray (post3_img_Gray) // saída de brilho Imagem Processada
);
`Else
Atribuir post3_frame_vsync = post2_frame_vsync;
Atribuir post3_frame_href = post2_frame_href;
Atribuir post3_img_Gray = post2_img_Gray;
Finalmente, uma compilação completa, para gerar o JIC download do arquivo observado no vídeo processados ou computador host PC VGA, como segue:
FIG à esquerda na imagem em escala de cinza original, a imagem do lado direito representa a mediana de filtragem, a imagem visível depois do filtro médio é relativamente escura, porque o valor máximo é descartado. No entanto, em relação ao filtro de média, o filtro mediano para filtrar o ruído sobre a base da preservação eficaz dos detalhes.
Além disso, pela maneira filtro mediano e efeito de filtro média da diferença, comparar aqui abaixo:
FIG filtragem média à esquerda é uma imagem, a imagem à direita é a filtragem mediana. A partir da análise FIG, a filtragem média imagem visível, a imagem que representa o processo de filtro mediano, o pormenor difusa mas falta. Para o tratamento de sal e pimenta ruído categoria, pontos fortes de filtragem medianos do que o filtro de média grande.
Isto, como disse anteriormente, há uma série de algoritmo de filtro de processamento de imagem, mas o objetivo original, para dominar os algoritmos mais básicos de processamento de imagem manipulada mais modelos, ou seja, a migração questões e implementação. Bingo apresentada neste mais básico de FPGA mediana algoritmo de filtragem para conseguir mais típico, muito apropriado, o algoritmo de filtragem é mais NB, enquanto se aguarda o leitor para estudo de conseguir!
processamento de imagem VIP, para tornar o mundo mais emocionante!
Declaramos solenemente: Apenas 100 por cento dominado este capítulo, a fim de entender a essência do Bingo VIP algoritmo, vamos continuar a olhar para baixo o significado! ! !
