Извлечение файла инициализации памяти (MIF) из фото BMP

Question

Я работаю над микропроцессором DE12-115 от Altera с использованием Quartus. Чтобы отобразить изображение BMP на мониторе с помощью встроенных VGA-соединений, я должен сначала преобразовать изображение BMP в его формат MIF. Формат MIF будет ничем иным, как таблицей поиска, которая указывает адрес каждого пикселя и псевдоним каждого цвета с использованием кода цвета RGB. Образец MIF файла будет иметь следующий вид

DEPTH = 32;     -- The size of data in bits 
WIDTH = 8;     -- The size of memory in words 
ADDRESS_RADIX = HEX;   -- The radix for address values 
DATA_RADIX = BIN;    -- The radix for data values 
CONTENT      -- start of (address : data pairs) 
BEGIN 

00 : 00000000;    -- memory address : data 
01 : 00000001; 
02 : 00000010; 
03 : 00000011; 
04 : 00000100; 
05 : 00000101; 
06 : 00000110; 
07 : 00000111; 
08 : 00001000; 
09 : 00001001; 
0A : 00001010; 
0B : 00001011; 
0C : 00001100; 

END; 

Я не нашел программное обеспечение, которое позволит мне трансформировать свои собственные изображения в формат выше. Тем не менее, я нашел код C, который это делает. Поскольку я не знаком с C, мне было интересно, сможет ли кто-нибудь помочь мне понять код, импортировать библиотеку и т. Д., Чтобы я мог преобразовать его в JAVA. Было бы здорово, если бы кто-то объяснил мне, как извлечь формат MIF с фотографии, и я мог бы написать свой собственный код с нуля. Код C ниже. Спасибо вам заблаговременно

// PicTest.cpp : Defines the entry point for the console application. 
// 

#include "stdafx.h" 
#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 

//#ifndef LaserMaze_Bitmap_h 
//#define LaserMaze_Bitmap_h 


#pragma pack(2) // Add this 

typedef struct 
{ 
    unsigned short bfType; 
    unsigned int bfSize; 
    unsigned short bfReserved1; 
    unsigned short bfReserved2; 
    unsigned int bfOffBits; 
} BITMAPFILEHEADER; 

#pragma pack() // and this 


# define BF_TYPE 0x4D42    /* "MB" */ 

typedef struct      /**** BMP file info structure ****/ 
{ 
    unsigned int biSize;   /* Size of info header */ 
    int   biWidth;   /* Width of image */ 
    int   biHeight;   /* Height of image */ 
    unsigned short biPlanes;   /* Number of color planes */ 
    unsigned short biBitCount;  /* Number of bits per pixel */ 
    unsigned int biCompression; /* Type of compression to use */ 
    unsigned int biSizeImage;  /* Size of image data */ 
    int   biXPelsPerMeter; /* X pixels per meter */ 
    int   biYPelsPerMeter; /* Y pixels per meter */ 
    unsigned int biClrUsed;  /* Number of colors used */ 
    unsigned int biClrImportant; /* Number of important colors */ 

    unsigned int RedMask;  /* Mask identifying bits of red component */ 
    unsigned int GreenMask;  /* Mask identifying bits of green component */ 
    unsigned int BlueMask;  /* Mask identifying bits of blue component */ 
    unsigned int AlphaMask;  /* Mask identifying bits of alpha component */ 
    unsigned int CSType;  /* Color space type */ 
    long RedX;   /* X coordinate of red endpoint */ 
    long RedY;   /* Y coordinate of red endpoint */ 
    long RedZ;   /* Z coordinate of red endpoint */ 
    long GreenX;  /* X coordinate of green endpoint */ 
    long GreenY;  /* Y coordinate of green endpoint */ 
    long GreenZ;  /* Z coordinate of green endpoint */ 
    long BlueX;   /* X coordinate of blue endpoint */ 
    long BlueY;   /* Y coordinate of blue endpoint */ 
    long BlueZ;   /* Z coordinate of blue endpoint */ 
    unsigned int GammaRed;  /* Gamma red coordinate scale value */ 
    unsigned int GammaGreen; /* Gamma green coordinate scale value */ 
    unsigned int GammaBlue;  /* Gamma blue coordinate scale value */ 
} BITMAPINFOHEADER; 

/* 
* Constants for the biCompression field... 
*/ 

# define BI_RGB  0    /* No compression - straight BGR data */ 
# define BI_RLE8  1    /* 8-bit run-length compression */ 
# define BI_RLE4  2    /* 4-bit run-length compression */ 
# define BI_BITFIELDS 3    /* RGB bitmap with RGB masks */ 

typedef struct      /**** Colormap entry structure ****/ 
{ 
    unsigned char rgbBlue;   /* Blue value */ 
    unsigned char rgbGreen;   /* Green value */ 
    unsigned char rgbRed;   /* Red value */ 
    unsigned char rgbReserved;  /* Reserved */ 
} RGBQUAD; 


unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader) 
{ 
    FILE *filePtr; //our file pointer 
    BITMAPFILEHEADER bitmapFileHeader; //our bitmap file header 
    unsigned char *bitmapImage; //store image data int imageIdx=0; //image index counter 
    unsigned char tempRGB; //our swap variable 

    //open filename in read binary mode 
    filePtr = fopen(filename,"rb"); 
    if (filePtr == NULL) 
     return NULL; 

    //read the bitmap file header 
    fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER),1,filePtr); 

    //verify that this is a bmp file by check bitmap id 
    if (bitmapFileHeader.bfType !=0x4D42) 
    { 
     fclose(filePtr); 
     return NULL; 
    } 

    //read the bitmap info header 
    fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER),1,filePtr); 

    //move file point to the begging of bitmap data 
    fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET); 

    //allocate enough memory for the bitmap image data 
    bitmapImage = (unsigned char*)malloc(bitmapInfoHeader->biSizeImage); 

    //verify memory allocation 
    if (!bitmapImage) 
    { 
     free(bitmapImage); 
     fclose(filePtr); 
     return NULL; 
    } 

    //read in the bitmap image data 
    fread(bitmapImage,bitmapInfoHeader->biSizeImage,1,filePtr); 

    //make sure bitmap image data was read 
    if (bitmapImage == NULL) 
    { 
     fclose(filePtr); 
     return NULL; 
    } 

    //swap the r and b values to get RGB (bitmap is BGR) 
    /*for (imageIdx = 0,imageIdx < bitmapInfoHeader->biSizeImage;imageIdx+=3) 
    { 
     tempRGB = bitmapImage[imageIdx]; 
     bitmapImage[imageIdx] = bitmapImage[imageIdx + 2]; 
     bitmapImage[imageIdx + 2] = tempRGB; 
    }*/ 
    //close file and return bitmap iamge data 
    fclose(filePtr); 
    return bitmapImage; 
} 
double round(double d) 
{ 
    return floor(d + 0.5); 
} 


bool generateMIF(unsigned char *bitmapData, long tSize, char *file) 
{ 
    FILE * pFile; 
    pFile = fopen (file,"w"); 
    if (pFile==NULL) 
    { 
     printf("Unable to Open file to write \n"); 
     return 0; 
    } 
    char buff[40]; 
    sprintf(buff,"DEPTH = %d;\n",tSize/3); 
    fputs("WIDTH = 8;\n",pFile); 
    fputs(buff,pFile); 
    fputs("ADDRESS_RADIX = HEX;\n",pFile); 
    fputs("DATA_RADIX = HEX;\n",pFile); 
    fputs("CONTENT BEGIN\n",pFile); 
    long ind=0; 
    long addr=0; 
    for (ind=tSize-1;ind>=0; ind-=3) 
    { 

     unsigned char R=round(bitmapData[ind]/255.0*7.0); 
     unsigned char G=round(bitmapData[ind-1]/255.0*7.0); 
     unsigned char B=round(bitmapData[ind-2]/255.0*3.0); 

     unsigned char Var = R *32 + G *4 + B; 

     sprintf(buff,"%X : %X ;\n",addr,Var); 
     fputs(buff,pFile); 
     addr++; 
    } 
    fputs("END;\n",pFile); 
    fclose (pFile); 

} 


bool generateLUTMIF(char *file) 
{ 
    FILE * pFile; 
    pFile = fopen (file,"w"); 
    if (pFile==NULL) 
    { 
     printf("Unable to Open file to write \n"); 
     return 0; 
    } 
    char buff[40]; 
    fputs("WIDTH = 24;\n",pFile); 
    fputs("DEPTH = 256;\n",pFile); 
    fputs("ADDRESS_RADIX = HEX;\n",pFile); 
    fputs("DATA_RADIX = HEX;\n",pFile); 
    fputs("CONTENT BEGIN\n",pFile); 
    long ind=0; 
    long addr=0; 
    for (ind=0;ind<256; ind++) 
    { 
     unsigned char C=ind; 
     unsigned char R=C >> 5; 
     R = R* 255/7; 
     unsigned char G= (C >> 2)&0x07; 
     G= G* 255/7; 

     unsigned char B=C & 0x3; 
     B=B*255/3; 


     sprintf(buff,"%X : %02X%02X%02X ;\n",ind,R,G,B); 
     fputs(buff,pFile); 
     addr++; 
    } 
    fputs("END;\n",pFile); 
    fclose (pFile); 

} 



int _tmain(int argc, _TCHAR* argv[]) 
{ 
    printf("Reading Image... \n"); 
    BITMAPINFOHEADER bitmapInfoHeader; 

    unsigned char *bitmapData; 
    bitmapData = LoadBitmapFile("d:\\back_24.bmp",&bitmapInfoHeader); 
    long tSize= bitmapInfoHeader.biHeight *bitmapInfoHeader.biWidth * 3 ;//24 bps 
    generateMIF(bitmapData,tSize,"D:\\backMIF.txt"); 
    generateLUTMIF("D:\\lutMIF.mif"); 
    printf("Done !"); 
    return 0; 
} 

Answer 1

Попробуйте использовать Matlab. Это станет так просто. Если вы используете c, вы должны определить некоторую структуру, попробуйте пересканировать заголовок изображения. это бессмысленно. Но если вы используете Matlab, вы курите, просто откройте изображение и получите данные! Это мой Matlab код, Надежда, чтобы помочь вам:

%mcode to create a mif file 
    src = imread('lena.jpg'); 
    gray = rgb2gray(src); 
    [m,n] = size(gray); %size od your picture 

    N = m*n; %your ram or rom depth。 
    word_len = 8; 
    data = reshape(gray, 1, N);% reshape you picture's data 

    fid=fopen('gray_image.mif', 'w'); % open mif file 
    fprintf(fid, 'DEPTH=%d;\n', N); 
    fprintf(fid, 'WIDTH=%d;\n', word_len); 

    fprintf(fid, 'ADDRESS_RADIX = UNS;\n'); 
    fprintf(fid, 'DATA_RADIX = HEX;\n'); 
    fprintf(fid, 'CONTENT\t'); 
    fprintf(fid, 'BEGIN\n'); 
    for i = 0 : N-1 
    fprintf(fid, '\t%d\t:\t%x;\n',i, data(i+1)); 
    end 
    fprintf(fid, 'END;\n'); % prinf the end 
    fclose(fid); % close your file 

Answer 2

Я работаю над проектом о настройке Altera FPGA на монитор, так что мне нужен генератор MIF файлов. Я видел, что их не много, и некоторые даже не компилируются.

Итак, я решил написать свой собственный на Java, он работает и обрабатывает почти все возможные ошибки. Инструмент, однако, сначала преобразует изображение в оттенки серого, и только тогда будет создан файл MIF.

Вы можете найти мой инструмент на моей странице по адресу GitHub.