?? image.c
字號:
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyImage(PIMAGE pimageDest, PIMAGE pimageSrc)
{
assert((pimageDest->xsize == pimageSrc->xsize) &&
(pimageDest->ysize == pimageSrc->ysize));
memcpy(pimageDest->pixel[0], pimageSrc->pixel[0],
(pimageDest->xsize)*(pimageDest->ysize));
return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyLImage(PLIMAGE plimageDest, PLIMAGE plimageSrc)
{
assert((plimageDest->xsize == plimageSrc->xsize) &&
(plimageDest->ysize == plimageSrc->ysize));
memcpy(plimageDest->pixel[0], plimageSrc->pixel[0],
(plimageDest->xsize)*(plimageDest->ysize)*sizeof(int));
return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyFImage(PFIMAGE pfimageDest, PFIMAGE pfimageSrc)
{
assert((pfimageDest->xsize == pfimageSrc->xsize) &&
(pfimageDest->ysize == pfimageSrc->ysize));
memcpy(pfimageDest->pixel[0], pfimageSrc->pixel[0],
(pfimageDest->xsize)*(pfimageDest->ysize)*sizeof(double));
return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyImageToFImage(PFIMAGE pfimageDest, PIMAGE pimageSrc)
{
int i, j;
assert((pfimageDest->xsize == pimageSrc->xsize) &&
(pfimageDest->ysize == pimageSrc->ysize));
for (j=0; j<pfimageDest->ysize; j++){
for (i=0; i<pfimageDest->xsize; i++){
pfimageDest->pixel[j][i] = (double)pimageSrc->pixel[j][i];
}
}
return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyFImageToImage(PIMAGE pimageDest, PFIMAGE pfimageSrc)
{
int i, j;
assert((pimageDest->xsize == pfimageSrc->xsize) &&
(pimageDest->ysize == pfimageSrc->ysize));
for (j=0; j<pimageDest->ysize; j++){
for (i=0; i<pimageDest->xsize; i++){
pimageDest->pixel[j][i] = (int)( (pfimageSrc->pixel[j][i]+0.5) < 0.0 ? 0 :
( (pfimageSrc->pixel[j][i]+0.5) > 255.0 ?
255 : (pfimageSrc->pixel[j][i]+0.5)));
}
}
return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
* Average2x2Image
* Return a floating point image by 2x2
* averaging the source image
*/
PFIMAGE Average2x2Image(PIMAGE pimageSrc, int type)
{
PFIMAGE pfimage;
int ii, jj, i, j, XLimit, YLimit;
/* allocate the memory */
pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
pfimage->xsize=pimageSrc->xsize/2;
pfimage->ysize=pimageSrc->ysize/2;
if (FImageBufferAlloc(pfimage)){
switch (type){
case 0: ii = 0; jj = 0; break;
case 1: ii = 1; jj = 0; break;
case 2: ii = 0; jj = 1; break;
case 3: ii = 1; jj = 1; break;
}
XLimit = (pimageSrc->xsize - ii) / 2;
YLimit = (pimageSrc->ysize - jj) / 2;
for (j=0; j<YLimit; j++){
for (i=0; i<XLimit; i++){
pfimage->pixel[j][i]= (double)
0.25*(pimageSrc->pixel[(j<<1) + jj][(i<<1) + ii] +
pimageSrc->pixel[(j<<1) + jj][(i<<1) + ii + 1] +
pimageSrc->pixel[(j<<1) + jj + 1][(i<<1) + ii] +
pimageSrc->pixel[(j<<1) + jj + 1][(i<<1) + ii + 1]);
}
}
return pfimage;
}
else{
return NULL;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
* Average3x3Image
* Return a floating point image by 3x3
* averaging the source image
*/
PFIMAGE Average3x3Image(PIMAGE pimageSrc, int type)
{
PFIMAGE pfimage;
int ii, jj, i, j, XLimit, YLimit;
/* allocate the memory */
pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
pfimage->xsize=pimageSrc->xsize/3;
pfimage->ysize=pimageSrc->ysize/3;
if (FImageBufferAlloc(pfimage)){
switch (type){
case 0: ii = 0; jj = 0; break;
case 1: ii = 1; jj = 0; break;
case 2: ii = 2; jj = 0; break;
case 3: ii = 0; jj = 1; break;
case 4: ii = 1; jj = 1; break;
case 5: ii = 2; jj = 1; break;
case 6: ii = 0; jj = 2; break;
case 7: ii = 1; jj = 2; break;
case 8: ii = 2; jj = 2; break;
}
XLimit = (pimageSrc->xsize - ii) / 3;
YLimit = (pimageSrc->ysize - jj) / 3;
for (j=0; j<YLimit; j++){
for (i=0; i<XLimit; i++){
pfimage->pixel[j][i] = (double)
( pimageSrc->pixel[3*j + jj ][3*i + ii ] +
pimageSrc->pixel[3*j + jj ][3*i + ii + 1] +
pimageSrc->pixel[3*j + jj ][3*i + ii + 2] +
pimageSrc->pixel[3*j + jj + 1][3*i + ii ] +
pimageSrc->pixel[3*j + jj + 1][3*i + ii + 1] +
pimageSrc->pixel[3*j + jj + 1][3*i + ii + 2] +
pimageSrc->pixel[3*j + jj + 2][3*i + ii ] +
pimageSrc->pixel[3*j + jj + 2][3*i + ii + 1] +
pimageSrc->pixel[3*j + jj + 2][3*i + ii + 2])/(double)9.0;
}
}
return pfimage;
}
else{
return NULL;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
* Average3x3ImageFilter0
* Return a floating point image by 3x3 with filter
* averaging the source image
*/
PFIMAGE Average3x3ImageFilter0(PIMAGE pimageSrc, int type)
{
PFIMAGE pfimage;
int ii, jj, i, j, XLimit, YLimit;
double FilterCoeff[9] = {0.25, 0.50, 0.25,
0.50, 1.00, 0.50,
0.25, 0.50, 0.25};
/* allocate the memory */
pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
pfimage->xsize=pimageSrc->xsize/3;
pfimage->ysize=pimageSrc->ysize/3;
if (FImageBufferAlloc(pfimage)){
switch (type){
case 0: ii = 0; jj = 0; break;
case 1: ii = 1; jj = 0; break;
case 2: ii = 2; jj = 0; break;
case 3: ii = 0; jj = 1; break;
case 4: ii = 1; jj = 1; break;
case 5: ii = 2; jj = 1; break;
case 6: ii = 0; jj = 2; break;
case 7: ii = 1; jj = 2; break;
case 8: ii = 2; jj = 2; break;
}
XLimit = (pimageSrc->xsize - ii) / 3;
YLimit = (pimageSrc->ysize - jj) / 3;
for (j=0; j<YLimit; j++){
for (i=0; i<XLimit; i++){
pfimage->pixel[j][i] = (double)
( FilterCoeff[0]*pimageSrc->pixel[3*j + jj ][3*i + ii ] +
FilterCoeff[1]*pimageSrc->pixel[3*j + jj ][3*i + ii + 1] +
FilterCoeff[2]*pimageSrc->pixel[3*j + jj ][3*i + ii + 2] +
FilterCoeff[3]*pimageSrc->pixel[3*j + jj + 1][3*i + ii ] +
FilterCoeff[4]*pimageSrc->pixel[3*j + jj + 1][3*i + ii + 1] +
FilterCoeff[5]*pimageSrc->pixel[3*j + jj + 1][3*i + ii + 2] +
FilterCoeff[6]*pimageSrc->pixel[3*j + jj + 2][3*i + ii ] +
FilterCoeff[7]*pimageSrc->pixel[3*j + jj + 2][3*i + ii + 1] +
FilterCoeff[8]*pimageSrc->pixel[3*j + jj + 2][3*i + ii + 2])/(double)4.0;
}
}
return pfimage;
}
else{
return NULL;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int ImageInitialize(int XSize, int YSize, PIMAGE pimage)
{
assert(XSize>0 && YSize>0);
pimage->xsize=XSize;
pimage->ysize=YSize;
/* Allocate memory */
if(!ImageBufferAlloc(pimage)){
return 0;
}
else{
return 1;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int LImageInitialize(int XSize, int YSize, PLIMAGE plimage)
{
assert(XSize>0 && YSize>0);
plimage->xsize=XSize;
plimage->ysize=YSize;
/* Allocate memory */
if(!LImageBufferAlloc(plimage)){
return 0;
}
else{
return 1;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int FImageInitialize(int XSize, int YSize, PFIMAGE pfimage)
{
assert(XSize>0 && YSize>0);
pfimage->xsize=XSize;
pfimage->ysize=YSize;
/* Allocate memory */
if(!FImageBufferAlloc(pfimage)){
return 0;
}
else{
return 1;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PIMAGE ImageAlloc(int XSize, int YSize)
{
PIMAGE pimage;
assert(XSize>0 && YSize>0);
pimage = (PIMAGE)malloc(sizeof(IMAGE));
pimage->xsize=XSize;
pimage->ysize=YSize;
/* Allocate memory */
if(!ImageBufferAlloc(pimage)){
return NULL;
}
else{
return pimage;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PLIMAGE LImageAlloc(int XSize, int YSize)
{
PLIMAGE plimage;
assert(XSize>0 && YSize>0);
plimage = (PLIMAGE)malloc(sizeof(LIMAGE));
plimage->xsize=XSize;
plimage->ysize=YSize;
/* Allocate memory */
if(!LImageBufferAlloc(plimage)){
return NULL;
}
else{
return plimage;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PFIMAGE FImageAlloc(int XSize, int YSize)
{
PFIMAGE pfimage;
assert(XSize>0 && YSize>0);
pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
pfimage->xsize=XSize;
pfimage->ysize=YSize;
/* Allocate memory */
if(!FImageBufferAlloc(pfimage)){
return NULL;
}
else{
return pfimage;
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* Adapted from G.Davis Baseline Wavelet Transform Coder Construction Kit */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
PIMAGE ReadPGM(char *PGMFileName)
{
FILE *fp; //圖像的文件名
PIMAGE pimage; //pgm圖像的數(shù)據(jù)存放空間
unsigned char ch=' ';
char ftype; //pgm的類型
int MaxG; //圖像的最大灰度值
//分配圖像數(shù)據(jù)的內(nèi)存空間
pimage=(PIMAGE)malloc(sizeof(IMAGE));
if (pimage==NULL){
return NULL;
}
//打開指定路徑的pgm圖像
if ((fp=fopen(PGMFileName, "rb"))==NULL){
free(pimage);
return NULL;
}
//處理文件頭信息
while ((ch != 'P') && (ch != '#')){
ch = fgetc(fp);
}
//跳過圖像信息部分
PGMSkipComments(fp, &ch);
//提取所支持的文件類型：這里僅支持P5類型
ftype = fgetc(fp);
//異常處理
if (ftype != '5'){
ImageWarning("Only binary PGM is supported.\n");
free(pimage);
fclose(fp);
return NULL;
}
//獲取圖像的寬、高數(shù)值
pimage->xsize=(int)PGMGetVal(fp);
pimage->ysize=(int)PGMGetVal(fp);
//獲取圖像灰度值的最大值
MaxG=(int)PGMGetVal(fp);
//分配圖像數(shù)據(jù)的內(nèi)存空間
if(!ImageBufferAlloc(pimage)){
free(pimage);
return NULL;
}
//從文件尾開始的指針偏移，以避免讀取無用的圖像附加信息
fseek(fp, -1*pimage->xsize * pimage->ysize, SEEK_END);
//加載圖像數(shù)據(jù)
if (fread(pimage->pixel[0], sizeof(unsigned char),
pimage->xsize*pimage->ysize, fp) != (unsigned int)pimage->xsize*pimage->ysize){
fclose(fp);
ImageBufferFree(pimage);
free(pimage);
return NULL;
}
else{
fclose(fp);
return pimage;
}
}
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
PFIMAGE ReadPGMToFloat(char *PGMFileName)
{
FILE *fp; //圖像的文件名
PIMAGE pimage; //pgm圖像的數(shù)據(jù)存放空間
PFIMAGE pfimage; //圖像數(shù)據(jù)的浮點存放空間
unsigned char ch=' ';
char ftype; //pgm的類型
int MaxG,i; //圖像的最大灰度值
//分配圖像數(shù)據(jù)的內(nèi)存空間
pimage=(PIMAGE)malloc(sizeof(IMAGE));
if (pimage==NULL){
return NULL;
}
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -