please explain me that : HDL Coder does not support matrices for code generation. You will need to convert your frame-based design into a pixel-based design suitable for embedding on an FPGA.

HDL Coder does not support matrices for code generation. You will need to convert your frame-based design into a pixel-based design suitable for embedding on an FPGA.

coder.extrinsic('dctmtx'); 
I= reshape(ImgVector, 330, 500,3);
%dctmtx - Compute discrete cosine transform matrix.
T = dctmtx(8);
coder.extrinsic('red');
 red = (I(:,:,1));       
coder.extrinsic('imred');
coder.extrinsic('blkproc');
imred=zeros(size(red));
        imred(:,:,1) = uint8(red);
        B = blkproc(imred,[8 8],'410*x*500',T,T');
mask = [16 11 10 16 24  40  51  61;
        12 12 14 19 26  58  60  55;
        14 13 16 24 40  57  69  56;
        14 17 22 29 51  87  80  62;
        18 22 37 56 68  109 103 77;
        24 35 55 64 81  104 113 92;
        49 64 78 87 103 121 120 101;
        72 92 95 98 112 100 103 99];
B2 = blkproc(B,[8 8],'410.*x',mask);
I2 = blkproc(B2,[8 8],'410*x*500',T',T);
%figure, imshow(I2)
%composante vert
%red = double(I(:,:,1));
%coder.extrinsic('imred');
%coder.extrinsic('blkproc');
%imred=zeros(size(red));
% imred(:,:,1) = uint8(red);
green =(I(:,:,2));
coder.extrinsic('imgreen');
imgreen=zeros(size(green));
imgreen(:,:,1) = uint8(green);
C = blkproc(imgreen,[8 8],'410*x*500',T,T');
mask = [16 11 10 16 24  40  51  61;
    12 12 14 19 26  58  60  55;
    14 13 16 24 40  57  69  56;
    14 17 22 29 51  87  80  62;
    18 22 37 56 68  109 103 77;
    24 35 55 64 81  104 113 92;
    49 64 78 87 103 121 120 101;
    72 92 95 98 112 100 103 99 ];
C2 = blkproc(C,[8 8],'410.*x',mask);
I3 = blkproc(C2,[8 8],'410*x*500',T',T);
 %figure, imshow(I3);
%composante bleu
%red = double(I(:,:,1));
%coder.extrinsic('imred');
%coder.extrinsic('blkproc');
%imred=zeros(size(red));
% imred(:,:,1) = uint8(red);
   blue = (I(:,:,3));
  coder.extrinsic('imblue');
  imblue=zeros(size(blue));
   imblue(:,:,1) = uint8(blue);
   D = blkproc(imblue,[8 8],'410*x*500',T,T');
  mask = [16 11 10 16 24  40  51  61;
      12 12 14 19 26  58  60  55;
      14 13 16 24 40  57  69  56;
      14 17 22 29 51  87  80  62;
      18 22 37 56 68  109 103 77;
      24 35 55 64 81  104 113 92;
      49 64 78 87 103 121 120 101;
      72 92 95 98 112 100 103 99];
  D2 = blkproc(D,[8 8],'410.*x',mask);
  I4 = blkproc(D2,[8 8],'410*x*500',T',T);
   %figure, imshow(I4);
  coder.extrinsic('image');
  image=zeros(size(red,1),size(red,2),3);
   image(:,:,1)=I2;
   image(:,:,2)=I3;
   image(:,:,3)=I4;
   %imshow(image);
   %figure,

Answer 1

[Walter Roberson]

You should use a "frame to pixels" block. I explain that a bit more at https://www.mathworks.com/matlabcentral/answers/314276-frame_to_pixel-and-pixel_to_frame-blocks-blocks#answer_245076

The basic issue is that using matrices implies that the entire matrix is passed at the same time, which requires one pin per bit per matrix element, or at the very least one pin per matrix element strobed once per bit to get the data in simultaneously. FPGA seldom have enough pins for that. The cure is to essentially vectorize the matrix for transfer into the FPGA, and then reshape it inside the FPGA if need be. The "frame to pixels" block provides tools to do that vectorization in a structured way that allows the matrix to be recreated easily.

[jebli med]

sir where i use this in my code matlab or where ?? sorry that was my first time i use that