关于TIF图片处理问题

cxnet

下面的代码可以将bmp24位图片进行膨胀处理，但仅限于bmp格式和24位色彩模式，请问怎样修改它才能让它直接处理TIF格式的1位色彩模式，或者8位色彩模式的二值图，因为图片比较大的时侯 photoshop没办法保存为bmp格式，只能保存为TIF格式

1. 
   
2. #include "pch.h"
   
3. #include "framework.h"
   
4. #include "TTS.h"
   
5. #include "TTSDlg.h"
   
6. #include "afxdialogex.h"
   
7. 
   
8. #ifdef _DEBUG
   
9. #define new DEBUG_NEW
   
10. #endif
    
11. #pragma warning(disable:4996);//出现fopen错误使用此代码
    
12. 
    
13. void CTTSDlg::OnBnClickedButton1()
    
14. {
    
15.         int        m_nWidth;                //图像实际宽度
    
16.         int        m_nHeight;                //图像实际高度
    
17.         int        m_nDrawWidth;        //图像显示宽度
    
18.         int        m_nDrawHeight;        //图像显示高度
    
19.         DWORD m_nImage;                //图像数据的字节数 只含位图
    
20.         DWORD m_nSize;      //图像文件大小
    
21.         int m_nLineByte;    //图像一行所占字节数
    
22.         int        m_nBitCount;    //图像每个像素所占位数
    
23.         int        m_nPalette;     //位图实际使用的颜色表中的颜色数
    
24.         CBitmap m_bitmaplin;   //创建临时位图对象进行处理
    
25.         CString BmpNameLin;    //保存图像副本文件
    
26. 
    
27.         BYTE* m_pImage;         //读入图片数据后的指针
    
28.         BITMAPFILEHEADER bfh;   //全局变量文件头
    
29.         BITMAPINFOHEADER bih;   //全局变量信息头
    
30. 
    
31.         FILE* fp = fopen("test1.bmp", "rb");
    
32.         if (fp == 0)
    
33.         {
    
34.                 AfxMessageBox(_T("无法打开文件!"), MB_OK, 0);
    
35.                 return;
    
36.         }
    
37.         //读取文件头 解决BMP格式倒置的方法
    
38.         fread(&bfh.bfType, sizeof(WORD), 1, fp);
    
39.         fread(&bfh.bfSize, sizeof(DWORD), 1, fp);
    
40.         fread(&bfh.bfReserved1, sizeof(WORD), 1, fp);
    
41.         fread(&bfh.bfReserved2, sizeof(WORD), 1, fp);
    
42.         fread(&bfh.bfOffBits, sizeof(DWORD), 1, fp);
    
43.         //图像文件的总字节数
    
44.         m_nSize = bfh.bfSize;
    
45.         //判断是否是bmp格式图片
    
46.         if (bfh.bfType != 0x4d42)   //'BM'
    
47.         {
    
48.                 AfxMessageBox(_T("不是BMP格式图片!"), MB_OK, 0);
    
49.                 return;
    
50.         }
    
51.         //读取信息头
    
52.         fread(&bih.biSize, sizeof(DWORD), 1, fp);
    
53.         fread(&bih.biWidth, sizeof(LONG), 1, fp);
    
54.         fread(&bih.biHeight, sizeof(LONG), 1, fp);
    
55.         fread(&bih.biPlanes, sizeof(WORD), 1, fp);
    
56.         fread(&bih.biBitCount, sizeof(WORD), 1, fp);
    
57.         fread(&bih.biCompression, sizeof(DWORD), 1, fp);
    
58.         fread(&bih.biSizeImage, sizeof(DWORD), 1, fp);
    
59.         fread(&bih.biXPelsPerMeter, sizeof(LONG), 1, fp);
    
60.         fread(&bih.biYPelsPerMeter, sizeof(LONG), 1, fp);
    
61.         fread(&bih.biClrUsed, sizeof(DWORD), 1, fp);
    
62.         fread(&bih.biClrImportant, sizeof(DWORD), 1, fp);
    
63.         if (bih.biSize != sizeof(bih))
    
64.         {
    
65.                 AfxMessageBox(_T("本结构所占用字节数出现错误"));
    
66.                 return;
    
67.         }
    
68.         //位图压缩类型，必须是 0（不压缩） 1（BI_RLE8压缩类型）或2（BI_RLE压缩类型）之一
    
69.         if (bih.biCompression == BI_RLE8 || bih.biCompression == BI_RLE4)
    
70.         {
    
71.                 AfxMessageBox(_T("位图被压缩!"));
    
72.                 return;
    
73.         }
    
74.         //获取图像高宽和每个像素所占位数
    
75.         m_nHeight = bih.biHeight;
    
76.         m_nWidth = bih.biWidth;
    
77.         m_nDrawHeight = bih.biHeight;
    
78.         m_nDrawWidth = bih.biWidth;
    
79.         m_nBitCount = bih.biBitCount;   //每个像素所占位数
    
80.         //计算图像每行像素所占的字节数（必须是32的倍数）
    
81.         m_nLineByte = (m_nWidth * m_nBitCount + 31) / 32 * 4;
    
82.         //图片大小 调用系统自带的文件头 BITMAPFILEHEADER bfh; BITMAPINFOHEADER bih;
    
83.         //否则用 BITMAPFILEHEADER_ bfh; BITMAPINFOHEADER_ bih;要 m_nImage = m_nLineByte * m_nHeight - 2;
    
84.         m_nImage = m_nLineByte * m_nHeight;
    
85.         //位图实际使用的颜色表中的颜色数 biClrUsed
    
86.         m_nPalette = 0;                       //初始化
    
87.         if (bih.biClrUsed)
    
88.                 m_nPalette = bih.biClrUsed;
    
89.         //申请位图空间 大小为位图大小 m_nImage
    
90.         //malloc只能申请4字节的空间 （未知）
    
91.         m_pImage = (BYTE*)malloc(m_nImage);
    
92. 
    
93.         int num;//记录每一行需要填充的字节
    
94.         if (m_nWidth * 3 % 4 != 0)
    
95.         {
    
96.                 num = 4 - m_nWidth * 3 % 4;
    
97.         }
    
98.         else
    
99.         {
    
100.                 num = 0;
     
101.         }
     
102. 
     
103.         //打开临时的图片  
     
104.         FILE* fpw = fopen("output.bmp", "wb+");
     
105.         fwrite(&bfh, sizeof(BITMAPFILEHEADER), 1, fpw);
     
106.         fwrite(&bih, sizeof(BITMAPINFOHEADER), 1, fpw);
     
107.         fread(m_pImage, m_nImage, 1, fp);
     
108.         unsigned char* ImageSize;
     
109.         ImageSize = new unsigned char[m_nImage];
     
110.         int x, y, val, xx, yy, temp;
     
111.         for (y = 1; y < m_nHeight - 1; y++)
     
112.         {
     
113.                 for (x = 1; x < m_nWidth - 1; x++)//由于使用3*3的结构元素，防止越界，不处理最左边和最右边的的像素
     
114.                 {
     
115.                         val = 0;
     
116.                         for (int j = 0; j < 2; j++)
     
117.                         {
     
118.                                 yy = y + j - 1;
     
119.                                 for (int i = 0; i < 2; i++)
     
120.                                 {
     
121.                                         xx = x + i - 1;
     
122.                                         if (m_pImage[(xx + yy * m_nWidth) * 3 + yy * num] > val)//因为结构元素都是0，所以原图像中各点与对应结构元素想加还是原图像本身，
     
123.                                                 //找和的最大值作为点（x，y）的灰度
     
124.                                         {
     
125.                                                 val = m_pImage[(xx + yy * m_nWidth) * 3 + yy * num];
     
126.                                         }
     
127.                                 }
     
128.                         }
     
129.                         ImageSize[(x + y * m_nWidth) * 3 + y * num] = unsigned char(val);
     
130.                         ImageSize[(x + y * m_nWidth) * 3 + y * num + 1] = unsigned char(val);
     
131.                         ImageSize[(x + y * m_nWidth) * 3 + y * num + 2] = unsigned char(val);
     
132.                 }
     
133.         }
     
134. 
     
135.         fwrite(ImageSize, m_nImage, 1, fpw);
     
136. 
     
137.         fclose(fp);
     
138.         fclose(fpw);
     
139. }
     

复制代码

FishC

要修改代码以处理TIF格式的1位或8位色彩模式的二值图，可以使用OpenCV库来简化操作。主要思路是通过OpenCV读取TIF文件并进行膨胀处理，最终将结果保存回TIF文件。以下是修改后的代码：

首先，确保在项目中配置了OpenCV库。

1. #include <opencv2/opencv.hpp>
   
2. #include <iostream>
   
3. 
   
4. void processTif() {
   
5.     // 使用OpenCV读取TIF图像
   
6.     cv::Mat image = cv::imread("input.tif", cv::IMREAD_UNCHANGED);
   
7. 
   
8.     if(image.empty()) {
   
9.         std::cout << "无法打开文件!" << std::endl;
   
10.         return;
    
11.     }
    
12. 
    
13.     // 确保图像是8位或1位二值图
    
14.     if(image.type() != CV_8UC1 && image.type() != CV_8UC3) {
    
15.         std::cout << "图像类型不兼容!" << std::endl;
    
16.         return;
    
17.     }
    
18. 
    
19.     // 创建一个膨胀操作的结构元素 (3x3)
    
20.     cv::Mat element = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
    
21. 
    
22.     cv::Mat result;
    
23.     // 对图像进行膨胀操作
    
24.     cv::dilate(image, result, element);
    
25. 
    
26.     // 保存处理后的图像
    
27.     if(!cv::imwrite("output.tif", result)) {
    
28.         std::cout << "保存图像失败!" << std::endl;
    
29.     }
    
30. }
    
31. 
    
32. int main() {
    
33.     processTif();
    
34.     return 0;
    
35. }

复制代码

### 说明：

1. **OpenCV库**: 使用OpenCV可以方便地处理多种格式的图像，包括TIF，并支持对一位或八位图像进行处理。

2. **cv::imread和cv::imwrite**: 分别用于读取和保存图像文件。`cv::IMREAD_UNCHANGED`确保读取的图像不受默认颜色转换的影响。

3. **cv::dilate**: 使用膨胀操作对图像进行处理，具体操作由`cv::getStructuringElement`函数定义的结构元素决定。

通过这种方式，处理图像的复杂度大大降低，并可以避免手动处理文件头、内存分配等低级细节。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cxnet

FishC 发表于 2024-11-17 11:42
要修改代码以处理TIF格式的1位或8位色彩模式的二值图，可以使用OpenCV库来简化操作。主要思路是通过OpenCV ...

排除opencv方法，因为opencv方式打开特别大的图片时很费时间，所以想使用现在这种方式

FishC

cxnet 发表于 2024-11-17 11:45
排除opencv方法，因为opencv方式打开特别大的图片时很 ...

如果你想通过现有的方式读取和处理TIF格式的图像，而不依赖OpenCV，可以考虑使用libtiff库。libtiff是一个专门用于处理TIFF文件格式的库，可以高效读取和写入TIFF图像。

下面是一个如何使用libtiff来读取和处理TIF文件的示例代码，假设你已经安装并配置了libtiff：

1. #include <tiffio.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. 
   
5. void processTIFF(const char* inputFileName, const char* outputFileName) {
   
6.     TIFF* tif = TIFFOpen(inputFileName, "r");
   
7.     if (tif) {
   
8.         uint32 width, height;
   
9.         size_t npixels;
   
10.         uint32* raster;
    
11. 
    
12.         TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
    
13.         TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
    
14.         npixels = width * height;
    
15.         raster = (uint32*)_TIFFmalloc(npixels * sizeof(uint32));
    
16. 
    
17.         if (raster != NULL) {
    
18.             if (TIFFReadRGBAImage(tif, width, height, raster, 0)) {
    
19.                 // 膨胀操作
    
20.                 for (uint32 y = 1; y < height - 1; y++) {
    
21.                     for (uint32 x = 1; x < width - 1; x++) {
    
22.                         // 获取像素值，进行膨胀
    
23.                         uint32 maxVal = 0;
    
24.                         for (int j = -1; j <= 1; j++) {
    
25.                             for (int i = -1; i <= 1; i++) {
    
26.                                 uint32 currentVal = raster[(y + j) * width + (x + i)];
    
27.                                 if (currentVal > maxVal) {
    
28.                                     maxVal = currentVal;
    
29.                                 }
    
30.                             }
    
31.                         }
    
32.                         raster[y * width + x] = maxVal;
    
33.                     }
    
34.                 }
    
35. 
    
36.                 // 将处理后的图像写入新文件
    
37.                 TIFF* out = TIFFOpen(outputFileName, "w");
    
38.                 if (out) {
    
39.                     TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
    
40.                     TIFFSetField(out, TIFFTAG_IMAGELENGTH, height);
    
41.                     TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 4);
    
42.                     TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
    
43.                     TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
    
44.                     TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    
45.                     TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
    
46. 
    
47.                     TIFFWriteEncodedStrip(out, 0, raster, npixels * sizeof(uint32));
    
48.                     TIFFClose(out);
    
49.                 }
    
50.             }
    
51.             _TIFFfree(raster);
    
52.         }
    
53.         TIFFClose(tif);
    
54.     } else {
    
55.         fprintf(stderr, "Could not open the specified TIFF file\n");
    
56.     }
    
57. }
    
58. 
    
59. int main() {
    
60.     processTIFF("input.tif", "output.tif");
    
61.     return 0;
    
62. }

复制代码

请注意，这是一个基础示例，处理的是32位RGBA TIFF图像。如果你要处理1位或8位的图像，你需要根据具体的TIFF图像格式更改读取和膨胀操作的方式。此外，为了成功编译和运行，你需要在编译时链接libtiff库。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cxnet

FishC 发表于 2024-11-17 11:45
如果你想通过现有的方式读取和处理TIF格式的图像，而不依赖OpenCV，可以考虑使用libtiff库。libtiff是 ...

这里面怎样将它修改成2*2的结构元素进行膨胀

FishC

cxnet 发表于 2024-11-17 11:48
这里面怎样将它修改成2*2的结构元素进行膨胀

要使用2x2的结构元素进行膨胀，你需要遍历每个像素，并检查该像素及其右、下、和右下区域的像素值（因为2x2结构元素在平面上意味着要检查这些位置）。如果其中任一像素有非零值，那么中央像素就设置为最大值。在二值图像的情况下，这意味着任何“1”就使中心值成为“1”。

以下是使用libtiff库的示例代码，假设你已经安装并正确配置了libtiff库：

1. #include <tiffio.h>
   
2. #include <stdint.h>
   
3. #include <stdlib.h>
   
4. #include <stdio.h>
   
5. #include <memory.h>
   
6. 
   
7. void processTIFF(const char* inputFileName, const char* outputFileName) {
   
8.     TIFF* tif = TIFFOpen(inputFileName, "r");
   
9.     if (!tif) {
   
10.         printf("Could not open input file %s\n", inputFileName);
    
11.         return;
    
12.     }
    
13. 
    
14.     uint32 width, height;
    
15.     size_t nPixels;
    
16.     uint32* raster;
    
17. 
    
18.     TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
    
19.     TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
    
20.     nPixels = width * height;
    
21.     raster = (uint32*)_TIFFmalloc(nPixels * sizeof(uint32));
    
22. 
    
23.     if (!raster) {
    
24.         printf("Memory allocation error\n");
    
25.         TIFFClose(tif);
    
26.         return;
    
27.     }
    
28. 
    
29.     // Read image data
    
30.     if (!TIFFReadRGBAImage(tif, width, height, raster, 0)) {
    
31.         printf("Could not read image\n");
    
32.         _TIFFfree(raster);
    
33.         TIFFClose(tif);
    
34.         return;
    
35.     }
    
36. 
    
37.     // Creating output raster with the same size
    
38.     uint32* outputRaster = (uint32*)_TIFFmalloc(nPixels * sizeof(uint32));
    
39.     if (!outputRaster) {
    
40.         printf("Memory allocation error\n");
    
41.         _TIFFfree(raster);
    
42.         TIFFClose(tif);
    
43.         return;
    
44.     }
    
45. 
    
46.     // Copy the original image before processing
    
47.     memcpy(outputRaster, raster, nPixels * sizeof(uint32));
    
48. 
    
49.     // Dilation with a 2x2 structure
    
50.     for (uint32 y = 0; y < height - 1; y++) {
    
51.         for (uint32 x = 0; x < width - 1; x++) {
    
52.             int isSet = 0;
    
53.             uint32 idx = y * width + x;
    
54.             
    
55.             // Examine 2x2 area
    
56.             isSet |= (raster[idx] & 0xFF); // pixel at (x, y)
    
57.             isSet |= (raster[idx + 1] & 0xFF); // pixel at (x+1, y)
    
58.             isSet |= (raster[idx + width] & 0xFF); // pixel at (x, y+1)
    
59.             isSet |= (raster[idx + width + 1] & 0xFF); // pixel at (x+1, y+1)
    
60. 
    
61.             if (isSet) {
    
62.                 // Set gray-scale to max (assuming 8-bit per channel grayscale)
    
63.                 outputRaster[idx] = 0xFFFFFFFF; // white: RGBA all channels max
    
64.                 outputRaster[idx + 1] = 0xFFFFFFFF;
    
65.                 outputRaster[idx + width] = 0xFFFFFFFF;
    
66.                 outputRaster[idx + width + 1] = 0xFFFFFFFF;
    
67.             }
    
68.         }
    
69.     }
    
70. 
    
71.     TIFF* out = TIFFOpen(outputFileName, "w");
    
72.     if (!out) {
    
73.         printf("Could not open output file %s\n", outputFileName);
    
74.         _TIFFfree(raster);
    
75.         _TIFFfree(outputRaster);
    
76.         TIFFClose(tif);
    
77.         return;
    
78.     }
    
79. 
    
80.     TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
    
81.     TIFFSetField(out, TIFFTAG_IMAGELENGTH, height);
    
82.     TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 4);
    
83.     TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
    
84.     TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
    
85.     TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    
86.     TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
    
87. 
    
88.     tsize_t lineBytes = 4 * width; // RGBA image
    
89.     unsigned char* buf = NULL;   // buffer used to store the horizontal line
    
90. 
    
91.     // Allocate buffer for 1 line of span
    
92.     buf = (unsigned char*)_TIFFmalloc(lineBytes);
    
93.     if (!buf) {
    
94.         printf("Memory allocation error\n");
    
95.         _TIFFfree(raster);
    
96.         _TIFFfree(outputRaster);
    
97.         TIFFClose(tif);
    
98.         TIFFClose(out);
    
99.         return;
    
100.     }
     
101. 
     
102.     // Write the image
     
103.     for (uint32 row = 0; row < height; row++) {
     
104.         memcpy(buf, &outputRaster[(height-row-1)*width], lineBytes);   
     
105.         if (TIFFWriteScanline(out, buf, row, 0) < 0) {
     
106.             break;
     
107.         }
     
108.     }
     
109. 
     
110.     _TIFFfree(buf);
     
111.     _TIFFfree(raster);
     
112.     _TIFFfree(outputRaster);
     
113.     TIFFClose(tif);
     
114.     TIFFClose(out);
     
115. }
     
116. 
     
117. int main() {
     
118.     processTIFF("input.tif", "output.tif");
     
119.     return 0;
     
120. }

复制代码

在这个示例中，遍历图像时，检查当前位置及其上、左、右上方像素的值。若任一位置为1，表示需要设置结果位置为255（即白色）。注意，这段代码是基于假设图像为8位灰度（每像素一个字节），需要根据实际的TIFF格式做调整，比如样本字节大小和像素格式。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cxnet

FishC 发表于 2024-11-17 11:49
要使用2x2的结构元素进行膨胀，你需要遍历每个像素，并检查该像素及其右、下、和右下区域的像素值（因 ...

为什么这段代码里的2*2的结构元素膨胀后比opencv的2*2的结构元素所膨胀得要多差不多1像素呢？相当于opencv的3*3的结构元素膨胀效果,我要把它减为1*1结构元素应该修改哪个参数

FishC

cxnet 发表于 2024-11-17 11:55
为什么这段代码里的2*2的结构元素膨胀后比opencv的2*2 ...

这段代码的膨胀操作实际上是基于2x2邻域（正方形顶部左角开始），它影响的区域是比2x2邻域要多的。这是因为代码遍历了邻近像素并以相对简单的方式扩展了图像。

如果要缩小为1x1结构元素，即简单的自扩展（实际上不扩展任何像素），那么实际上不会改变图像，因为1x1结构元素等同于对像素自身进行检查，没有邻域的影响。所以“1x1膨胀”不会对图像产生变化。

对于只考虑2x2实际的膨胀：

1. 检查每个单独像素而不是树立看整个2x2局部。
2. 确保只有自身参与"扩张"，这意味着只修改特定点。

但是，如果你的意思是将不同形状的结果生成，查看代码时注意：

1. for (int j = 0; j < 2; j++) {
   
2.     yy = y + j - 1;
   
3.     for (int i = 0; i < 2; i++) {
   
4.         xx = x + i - 1;
   
5.         if (m_pImage > val) {
   
6.             val = m_pImage;
   
7.         }
   
8.     }
   
9. }

复制代码

在上面这个片段中，如果你想控制邻域的大小和形状，调整这两个for循环即可。`1x1`不改变任何邻域，你可以直接输出原始图像而无需额外处理，或者移除所有的`val`赋值步骤，保留`outputRaster`生成部分即可。

如果你遇到了图形扩张结果不是预期问题，可能是邻域处理中访问过多外背景，因此要更谨慎的设置起始和边界条件，如果您需要精细化，使用专业工具（如OpenCV的形态学操作）可能会更合适。但在`libtiff`仅用于读取和原生操作部分，它不提供OpenCV复杂操作。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cxnet

FishC 发表于 2024-11-17 11:55
这段代码的膨胀操作实际上是基于2x2邻域（正方形顶部左角开始），它影响的区域是比2x2邻域要多的。这是 ...

用这种方式试了一下大尺寸的TIF图片会出错，看来这种方式也只能处理比较小的图片。

用CImage方式加载TIF二值8位或者1位二值图进行2*2结构元素进行膨胀应该怎样写代码。想试试这种方式是否可行

FishC

cxnet 发表于 2024-11-17 12:11
用这种方式试了一下大尺寸的TIF图片会出错，看来这种 ...

使用 `CImage` 类来处理 TIFF 图像可以利用 GDI+ 来进行图像加载和处理，从而支持较大的图片。下面是一个使用 `CImage` 和 GDI+ 实现简单膨胀的示例代码：

1. #include <afxwin.h>     // MFC core and standard components
   
2. #include <gdiplus.h>    // GDI+
   
3. 
   
4. #pragma comment (lib, "gdiplus.lib")
   
5. 
   
6. using namespace Gdiplus;
   
7. 
   
8. void ProcessTIFwithCImage(const wchar_t* inputFileName, const wchar_t* outputFileName) {
   
9.     // Initialize GDI+
   
10.     GdiplusStartupInput gdiplusStartupInput;
    
11.     ULONG_PTR gdiplusToken;
    
12.     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
    
13. 
    
14.     CImage image;
    
15.     HRESULT hr = image.Load(inputFileName);
    
16.     if (FAILED(hr)) {
    
17.         printf("Failed to load image\n");
    
18.         return;
    
19.     }
    
20. 
    
21.     int width = image.GetWidth();
    
22.     int height = image.GetHeight();
    
23. 
    
24.     // Create a new image for the output
    
25.     CImage outputImage;
    
26.     outputImage.Create(width, height, 8);
    
27. 
    
28.     // Iterate through each pixel, excluding the boundary pixels
    
29.     for (int y = 0; y < height - 1; y++) {
    
30.         for (int x = 0; x < width - 1; x++) {
    
31.             // Check the 2x2 neighborhood for dilation
    
32.             BYTE pixelValue = image.GetPixel(x, y) == 0xFFFFFF ? 1 : 0;   // Assuming binary white is the forepixel
    
33. 
    
34.             // Check each pixel in 2x2 area
    
35.             if (pixelValue == 0) {
    
36.                 if ((x + 1 < width && image.GetPixel(x + 1, y) == 0xFFFFFF) ||
    
37.                     (y + 1 < height && image.GetPixel(x, y + 1) == 0xFFFFFF) ||
    
38.                     (x + 1 < width && y + 1 < height && image.GetPixel(x + 1, y + 1) == 0xFFFFFF)) {
    
39.                     pixelValue = 1;
    
40.                 }
    
41.             }
    
42. 
    
43.             // Set the result pixel value
    
44.             COLORREF color = pixelValue ? RGB(255, 255, 255) : RGB(0, 0, 0);
    
45.             outputImage.SetPixel(x, y, color);
    
46.         }
    
47.     }
    
48. 
    
49.     // Save the processed image to a new file
    
50.     outputImage.Save(outputFileName);
    
51. 
    
52.     // Cleanup GDI+
    
53.     GdiplusShutdown(gdiplusToken);
    
54. }
    
55. 
    
56. int main() {
    
57.     ProcessTIFwithCImage(L"input.tif", L"output.tif");
    
58.     return 0;
    
59. }

复制代码

### 代码说明：
1. **初始化GDI+**：在使用任何 GDI+ 功能之前，必须进行初始化。

2. **加载图像**：使用 `CImage` 来加载 TIFF 文件。

3. **创建输出图像**：创建一个新的 `CImage` 对象来存储输出结果。

4. **处理图像**：通过遍历图像，为每个非边界像素检查其自身及相邻像素的值，执行膨胀操作。

5. **保存结果**：最后将处理后的图像保存为一个新的 TIFF 文件。

请注意，确保使用 `CImage` 和 GDI+ 方法时，处理二值图像时要保证图像是用正确的格式（比如前景为白色 `0xFFFFFF` 和背景为黑色 `0x000000`）。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。