tif读写（C++，不配置opencv）

已于 2023-07-21 09:55:23 修改
阅读量1.2k 收藏 7
点赞数
分类专栏： 图像处理 文章标签： 图像处理 c++ 计算机视觉
于 2022-07-01 16:47:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Scream1314/article/details/125561760
版权

TIFF图像文件格式详解 - vstion - 博客园

根据TIF图像的格式来编写了TIF读写程序。不用调包。

#pragma once
#include <string>
#include <cstdint>
#include <cstring>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

typedef struct
{
	uint16_t endian; 
	uint16_t magic;  
	uint32_t ifdOffset; 
}IFH;
typedef struct
{
	uint16_t tag;  // TAG的唯一标识
	uint16_t type; // 数据类型
	uint32_t size; // 数量
	uint32_t valOffset;
}DE;
typedef struct
{
	uint16_t size;  
	char* beginptr;  
}Endptr;
typedef struct IFDclass
{
	uint16_t n; // 表示此IFD包含了多少个DE,假设数目为n
	DE* p; 
	uint32_t nextIfdOffset; // 下一个IFD的偏移量,如果没有则置为0
	IFDclass() :p(nullptr) {};
	~IFDclass() {
		free(p);
		p = nullptr;
	};
}IFD;

typedef enum { whiteIsZeros = 0, BlackIsZeros = 1, RGB = 2, RGBPalette = 3, transparencyMask = 4, KCMYK = 5, YCbCr = 6, CIELAB = 8 }PhotometricInterpretation;

typedef struct imgInfo
{
	PhotometricInterpretation  _PhotometricInterpretation;
	uint16_t stripsPerImage;
	uint16_t* BitsPerSample;
	uint16_t channel;  // 表示图像通道数
	uint16_t orientation;
	uint16_t subFileNum;
	uint32_t height;  // 表示图像高度
	uint32_t width; // 表示图像宽度
	uint32_t* stripOffsets;// 图像条带数据起始地址存储位置相对于文件开始的位置val的保存位置，共有stripsPerImage个
	uint32_t* stripByteCouts;   //每压缩带字节数
	uint16_t  Compression;//1代表没有压缩、7代表JPEG压缩、32773代表packBits压缩
	uint32_t rowsPerStrip;
	uint32_t allBytes;//全部比特数
	imgInfo() :_PhotometricInterpretation(BlackIsZeros), stripsPerImage(1), channel(1), allBytes(0),
		orientation(1), subFileNum(1), height(0), width(0), Compression(1), rowsPerStrip(height),
		BitsPerSample(nullptr), stripOffsets(nullptr), stripByteCouts(nullptr) {};
	~imgInfo() {
		free(BitsPerSample);
		BitsPerSample = nullptr;
		free(stripOffsets);
		stripOffsets = nullptr;
		free(stripByteCouts);
		stripByteCouts = nullptr;
	}
}imInfo;

inline bool mashineEndian(void)
{
	uint16_t a = 1;
	uint16_t* p = &a;
	return *((uint8_t*)p) == a;
}

template<typename baseType>
struct tiffTypeMap {
	uint16_t typeValue = 1;
};
template<>
struct tiffTypeMap<uint8_t> {
	uint16_t typeValue = 1;
};
template<>
struct tiffTypeMap<uint16_t> {
	uint16_t typeValue = 3;
};
template<>
struct tiffTypeMap<uint32_t> {
	uint16_t typeValue = 4;
};
template<>
struct tiffTypeMap<uint64_t> {
	uint16_t typeValue = 5;
};
template<>
struct tiffTypeMap<int8_t> {
	uint16_t typeValue = 6;
};
template<>
struct tiffTypeMap<int16_t> {
	uint16_t typeValue = 8;
};
template<>
struct tiffTypeMap<int32_t> {
	uint16_t typeValue = 9;
};
template<>
struct tiffTypeMap<int64_t> {
	uint16_t typeValue = 10;
};
template<>
struct tiffTypeMap<float> {
	uint16_t typeValue = 11;
};
template<>
struct tiffTypeMap<double> {
	uint16_t typeValue = 12;
};


class TiffImg {
public:
	imInfo _imInfo;
	uint8_t* data;
	IFH _IFH;
	IFD _IFD;
	Endptr endptr;
	TiffImg(string path);
	template<typename T>
	TiffImg(T, uint32_t height, uint32_t width, uint8_t channel = 1);
	void getmin();
	void save(string savePath = "defaultSave.tif");
	~TiffImg() {
		/*save();*/
		free(data);
		data = nullptr;
	}
	template<typename T>
	T& operator()(T, uint32_t row, uint32_t col, uint8_t depth = 1) {
		uint64_t sum = ((row - 1) * _imInfo.width + (col - 1)) * chanBytes(_imInfo.channel, _imInfo.BitsPerSample) + chanBytes(depth - 1, _imInfo.BitsPerSample);
		return *((T*)(data + sum));
	}
private:
	bool EndianTrans;
	bool read(string path, uint32_t IFDoffset = 0);
	const uint16_t littleEndian = 0x4949;
	const uint16_t bigEndian = 0x4d4d;
	uint8_t chanBytes(uint16_t channel, uint16_t* BitsPerSample);
};
uint8_t TiffImg::chanBytes(uint16_t channel, uint16_t* BitsPerSample) {
	uint8_t res{};
	for (int i = 0; i < channel; ++i) {
		res += (BitsPerSample[i] / 8 + BitsPerSample[i] % 8);
	}
	return res;
};
template<typename T>
TiffImg::TiffImg(T, uint32_t height, uint32_t width, uint8_t channel) {
	_imInfo.height = height;
	_imInfo.width = width;
	_imInfo.channel = channel;
	_imInfo.BitsPerSample = sizeof(T) * 8;
	endptr.beginptr = new char[1024];
	endptr.size = 0;
	_imInfo.stripByteCouts[0] = height * width * channel * sizeof(T);
	if (_imInfo.stripByteCouts[0] % 2 != 0) {
		++_imInfo.stripByteCouts[0];
	}
	uint8_t typeLabel = tiffTypeMap<T>().typeValue;
	//_imInfo.ImageStart[0] = sizeof(_IFH);
	_imInfo.stripOffsets[0] = 22550;
	data = (uint8_t*)malloc(_imInfo.stripByteCouts[0]);
	EndianTrans = false;
	_IFH.endian = mashineEndian ? littleEndian : bigEndian;
	_IFH.magic = 42;
	_IFH.ifdOffset = _imInfo.stripByteCouts[0] + sizeof(_IFH);
	_IFH.ifdOffset = sizeof(_IFH);
	_IFD.n = 6;
	_IFD.p = (DE*)malloc(_IFD.n * sizeof(DE));
	memset((void*)_IFD.p, 0, _IFD.n * sizeof(DE));
	DE* temp = _IFD.p;
	temp->tag = 0x0100; temp->type; temp->size; temp->valOffset = _imInfo.width;
	++temp; temp->tag = 0x0101; temp->type; temp->size; temp->valOffset = _imInfo.height;
	++temp; temp->tag = 0x0102; temp->type = typeLabel; temp->size; temp->valOffset;
	++temp; temp->tag = 0x0106; temp->type; temp->size; temp->valOffset = _imInfo.channel;
	++temp; temp->tag = 0x0111; temp->type; temp->size; temp->valOffset = _imInfo.stripOffsets[0];
	++temp; temp->tag = 0x0117; temp->type; temp->size; temp->valOffset = _imInfo.stripByteCouts[0];

	_IFD.nextIfdOffset = 1;
}

TiffImg::TiffImg(string path) {
	_IFD.nextIfdOffset = 0;
	bool  hasNext = true;
	
	_imInfo.subFileNum = 0;
	_imInfo.allBytes = 0;
	while (read(path, _IFD.nextIfdOffset) && hasNext) {
		ifstream frd(path, ios::in | ios::binary);
		if (frd) {//文件打开成功
			auto chanBytes = [](auto channel, auto  BitsPerSample)->uint8_t {
				uint8_t res{};
				for (int i = 0; i < channel; ++i) {
					res += (BitsPerSample[i] / 8 + BitsPerSample[i] % 8);
				}
				return res;
			};
			auto subSum = _imInfo.height * _imInfo.width * chanBytes(_imInfo.channel, _imInfo.BitsPerSample);
			auto subdat = (uint8_t*)malloc(subSum);
			memset(subdat, 0, subSum);
			data = subdat;
			auto tripBytes = [](auto strips, auto  stripByteCouts)->uint32_t {
				uint32_t res{};
				for (int i = 0; i < strips; ++i) {
					res += stripByteCouts[i];
				}
				return res;
			};
			int tempsum{};
			for (auto k = 0; k < _imInfo.stripsPerImage; ++k) {
				frd.seekg(static_cast<long>(_imInfo.stripOffsets[k]), ios::beg);

				for (auto i = 0; i < _imInfo.stripByteCouts[k]; ++i) {
					if (_imInfo.Compression == 1) {
						frd.read(reinterpret_cast<char*>(subdat + tempsum), _imInfo.stripByteCouts[k]);
						tempsum += _imInfo.stripByteCouts[k];
						break;
					}
					else if (_imInfo.Compression == 7) {
						cerr << "JPEG压缩还没写";
					}
					else if (_imInfo.Compression == 32773) {
						int8_t temp{};
						frd.read(reinterpret_cast<char*>(&temp), 1);
						if (temp == -128) {
						}
						else if (temp < 0) {
							uint8_t nextdata{};
							frd.read(reinterpret_cast<char*>(&nextdata), 1);
							memset(subdat + tempsum, nextdata, 1 - temp);
							tempsum += 1 - temp;
							++i;
						}
						else {
							frd.read(reinterpret_cast<char*>(subdat + tempsum), temp + 1);
							tempsum += 1 + temp;
							i += temp + 1;
						}

					}
				}
				if (EndianTrans) {
					cerr << "大小端转换还没写";
				}

			}
			if (!_IFD.nextIfdOffset) {
				hasNext = false;
			}
			frd.close();
			_imInfo.allBytes += subSum;
			++_imInfo.subFileNum;
		}
	}
};
uint8_t getsize(uint16_t typeLabel) {
	switch (typeLabel) {
	case 1:;//Byte
	case 2:return 1; break;//文本类型，7位Ascii码加1位二进制0
	case 3:; return sizeof(uint16_t); break;//2字节
	case 4:  return sizeof(uint32_t); break;//4字节
	case 5:;  return sizeof(uint64_t); break;//有理数，第一无符号Long为分子，第二个为分母部分
	case 6:;  return sizeof(int8_t); break;
	case 8:; return sizeof(int16_t); break;
	case 9:;  return sizeof(int32_t); break;
	case 10:;  return sizeof(int64_t); break;///有理数，第一无符号Long为分子，第二个为分母部分
	case 11:; return sizeof(float); break;
	case 12:;  return sizeof(double); break;
	default:;   return 1; break;
	}
}
bool TiffImg::read(string path, uint32_t IfdOffset)
{
	ifstream frd(path, ios::in | ios::binary);
	while (frd) {
		frd.seekg(IfdOffset, ios::beg);
		frd.read(reinterpret_cast<char*>(&(_IFH)), sizeof(_IFH));
		bool imEndian{ _IFH.endian == littleEndian }; 
		EndianTrans = (imEndian != mashineEndian());

		auto IFD_Start = _IFH.ifdOffset;
		frd.seekg(static_cast<long>(IFD_Start), ios::beg);
		frd.read(reinterpret_cast<char*>(&(_IFD.n)), sizeof(_IFD.n));
		if (EndianTrans) {
			;
		}
		auto DE_n = _IFD.n;
		_IFD.p = (DE*)malloc(sizeof(DE) * DE_n);
		frd.read(reinterpret_cast<char*>(_IFD.p), sizeof(DE) * DE_n);
		endptr.beginptr = new char[1000000];
		endptr.size = 0;
		auto getNdata = [path](auto& DE_ele, auto* res, auto endptr)->void {
			uint8_t typ = getsize(DE_ele.type);
			auto DE_val_size = typ * DE_ele.size;
			if (DE_val_size > 4) {
				ifstream fr(path, ios::in | ios::binary);
				fr.seekg(static_cast<long>(DE_ele.valOffset), ios::beg);
				fr.read(reinterpret_cast<char*>(res), DE_val_size);
				//memcpy(&endptr->beginptr[endptr->size], reinterpret_cast<char*>(res), DE_val_size);
				//endptr->size += DE_val_size;
				fr.close();
			}
			else {
				memcpy(reinterpret_cast<char*>(res), reinterpret_cast<char*>(&DE_ele.valOffset), DE_val_size);
			}
		};

		for (uint32_t i = 0; i < DE_n; ++i) {
			DE& temp = _IFD.p[i];
			switch (temp.tag) {

			case 0x00FE: {
				if (temp.valOffset & 1) {
					
				}
				if (temp.valOffset & 2) {
					
				}
				if (temp.valOffset & 4) {
					
				}
				break;
			}
			case 0x00FF: {
				if (temp.valOffset == 1) {
					
				}
				if (temp.valOffset == 2) {
				
				}
				if (temp.valOffset == 3) {
					
				}
				break;
			}
			case 0x0100: getNdata(temp, &_imInfo.width,&endptr); break;// 图像宽度存储位置
			case 0x0101: getNdata(temp, &_imInfo.height, &endptr); break;// 图像高度存储位置
			case 0x0102: {//每个通道的Bit数 SHORT ，长度为SamplesPerPixel
				_imInfo.channel = temp.size;
				_imInfo.BitsPerSample = new uint16_t[_imInfo.channel];
				getNdata(temp, _imInfo.BitsPerSample, &endptr);
				break;
			}
			case 0x0103: {// 图像是否压缩 05表示压缩 short、1
				getNdata(temp, &_imInfo.Compression, &endptr);
				break;
			}
			case 0x0106: {// 表示图像的种类
				_imInfo._PhotometricInterpretation = (PhotometricInterpretation)_IFD.p[i].valOffset;
				break;
			}
			case 0x0111: {// 图像条带数据起始地址存储位置相对于文件开始的位置val的保存位置
				_imInfo.stripsPerImage = _IFD.p[i].size;
				_imInfo.stripOffsets = new uint32_t[_imInfo.stripsPerImage];
				getNdata(temp, _imInfo.stripOffsets, &endptr);
				break;
			}
			case 0x0112: {
				getNdata(temp, &_imInfo.orientation, &endptr);
				break;
			}
			case 0x0114: break;
			case 0x0115:getNdata(_IFD.p[i], &_imInfo.channel, &endptr);  break;
			case 0x0116: {
				getNdata(temp, &_imInfo.rowsPerStrip, &endptr);
				break;
			}
			case 0x0117: {
				_imInfo.stripsPerImage = _IFD.p[i].size;
				_imInfo.stripByteCouts = new uint32_t[_imInfo.stripsPerImage];
				getNdata(temp, _imInfo.stripByteCouts, &endptr);
				break; 
			}
			case 284: break;
			case 0x0128:
				break;
			case 0x011A:
			
				break;
			case 0x011B:
				break;
			default:  break;
			}
		}
		frd.read(reinterpret_cast<char*>(&_IFD.nextIfdOffset), sizeof(_IFD.nextIfdOffset));
		auto comf = frd.tellg();
		frd.seekg(0L,ios::end);
		auto come = frd.tellg();
		frd.seekg(comf);
		frd.read(endptr.beginptr, come - comf);
		endptr.size = come - comf;
		frd.close();
		return true;
	}
	return false;
}
void TiffImg::save(string savePath) {

	ofstream fd{ savePath, ios::out | ios::binary };
	if (fd.is_open()) {
		fd.seekp(0L, ios::beg);
		if (EndianTrans) {
			uint16_t Endian = (_IFH.endian == littleEndian ? bigEndian : littleEndian);
			fd.write((char*)(&(Endian)), sizeof(_IFH.endian));
		}
		else {
			fd.write((char*)&(_IFH.endian), sizeof(_IFH.endian));
		}
		fd.write((char*)&(_IFH.magic), sizeof(_IFH.magic));
		fd.write((char*)&(_IFH.ifdOffset), sizeof(_IFH.ifdOffset));
		fd.seekp(_IFH.ifdOffset, ios::beg);
		fd.write((char*)&(_IFD.n), sizeof(_IFD.n));
		fd.write((char*)(_IFD.p), sizeof(DE) * _IFD.n);
		fd.write((char*)(&(_IFD.nextIfdOffset)), sizeof(_IFD.nextIfdOffset)); 
		fd.write(endptr.beginptr, endptr.size);
		fd.seekp(_imInfo.stripOffsets[0], ios::beg);
		fd.write((char*)(data), _imInfo.allBytes);
		fd.close();
	}

}

Scream1314
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++读写geotiff格式添加坐标信息和投影信息
08-04
用 libgeotiff 库写geotiff格式数据，包括 地理坐标系和投影信息。
C++读取并保存Tiff文件（纯C++，不需要配置opencv、boost.GIL等环境）
Terrence_Pai的博客
04-22 8697
背景说明 最近需要写一个能在LINUX上读取tif图像、修改像素并保存的C文件，之前都是matlab直接调函数，现在突然使用C读取着实有点懵。 找了很多网上的程序却都是需要调特定函数库，opencv库的安装与配置环境在windows下跟着教程还能勉强实现，但到linux配环境属实有点难（为此还租了一个云服务器，哭~）。而且因为最后整个项目要打包到其他电脑运行，这个时候又得考虑去其他电脑是否安装opencv，或者得考虑生成静态库、动态库， ~，那对于像我这样的菜菜估计又是一大波得不到结果的操作（整了一天愣是没
C++之GDAL读取tiff文件，获取行列坐标值
小胖七少爷的博客
12-18 7001
GDAL处理地理图像坐标计算 本文讲解如何使用GDAL处理地理图像时，通过使用行列号计算和转换成tiff图像的地理坐标： tif中坐标计算的方法如下，其中Col表示该坐标点处图像的列号，ROW表示该坐标点处图像的行号， 比如图像左上角Col为0，ROW为0，图像右下角Col为图像宽度，ROW为图像高度。 Xgeo = GT(0) + Col*GT(1) + Row*GT(2) Ygeo = GT(3) + Col*GT(4) + Row*GT(5) #include <gdal_pri..
图像处理之tiff图像读写（纯C++不调库）
Scream1314的博客
06-21 1607
【代码】图像处理之tiff图像读写（纯C++不调库）
TIFF基于特定tiff图像的读写（C++）
Scream1314的博客
07-23 538
图像处理， 首先，需要在网上下载一个查看文件十六进制的软件（FlexHEX），根据软件打开对应的图文件，如下图所示为打开tiff深度图的结果。针对本文章tiff图为波纹板的深度图，它的图文件结构首先是文件头、图像数据、DE个数（占4字节），每个DE的类型（每个DE是12个字节）。然后是其他信息，可以不用读取，主要是图像数据和DE目录里面的图像的宽和图像的高。需要根据软件查看的图文件数据对着TIFF文件格式详解对照着码代码。TIFF文件格式详解在我另一个文章中。
tif文件读取程序
07-22
改代码使用VC++编写，能轻松的赌徒tif文件在遥感影像处理的初级方面很有帮助。类的构建清晰，代码一看就明白。
TIF图像文件的读取（c++代码）
热门推荐
数学屌丝走在it的道路上
10-04 2万+
一 TIF图像介绍     TIFF是最复杂的一种位图文件格式。TIFF是基于标记的文件格式，它广泛地应用于对图像质量要求较高的图像的存储与转换。由于它的结构灵活和包容性大，它已成为图像文件格式的一种标准，绝大多数图像系统都支持这种格式。    TIFF 是一个灵活适应性强的文件格式，通过在文件头中包含“标签”它能够在一个文件中处理多幅图像和数据。标签能够标明图像的如图像大小这样的基本几何尺寸
C++读写tif文件
shuaijieer的博客
06-09 2925
tiff图像文件包含头尾，图像数据在中间
TIFF的C++库
04-16
C++语言的TIFF类库，包含32位和64位。可以用于创建、打开TIFF格式的图像。
读取tif格式图片程序
03-20
读取tif格式图片程序，读取tif格式图片加载显示，vc6.0和vs2010中测试通过
C#读取tif格式图片
04-27
c#语言实现tif格式的图片的显示及读取属性信息 具有可视化界面
Visual c++ TIFF读写源码.rar
12-13
Visual c++ TIFF读写源码.rar 比较齐全，需要有一定的VC和图像处理基础才能很好的应用。
tif文件读取代码
06-30
基于C++中tif文件的读取代码最底层的脚本，可以在C#中调用
封装的tif文件的读写库
06-30
extern "C" __declspec(dllexport) bool TifOpen(char* filename,char* model); extern "C" __declspec(dllexport) bool TifClose(); extern "C" __declspec(dllexport) int GetTifWidth(); extern "C" __declspec(dllexport) int GetTifHeight(); extern "C" __declspec(dllexport) int GetBPS(); extern "C" __declspec(dllexport) int GetBands(); extern "C" __declspec(dllexport) int GetBlockXSize(); extern "C" __declspec(dllexport) int GetBlockYSize(); extern "C" __declspec(dllexport) int GetBlockSize(); extern "C" __declspec(dllexport) bool IsTile(); extern "C" __declspec(dllexport) bool TifCreate(unsigned int xSize, unsigned int ySize, unsigned short bps, unsigned short nBands, unsigned int nBlockXSize, unsigned int nBlockYSize, bool isTiled); extern "C" __declspec(dllexport) bool TifRead(unsigned char* pBuf, int const& xOff, int const& yOff, int xSize, int ySize); extern "C" __declspec(dllexport) bool TifWrite(unsigned char* pBuf, unsigned int tileID, unsigned int nBlockSize, bool isTiled);
TiffRead_libtiff_tiff压缩_图像解析_tiff_tif_
10-04
本程序采用libtiff库解析tiff图像文件。已经在win10-64bit系统上的VC6环境测试通过，结果正确。程序很简洁，适用8bit、24bit、32bit非压缩格式和LZW压缩格式。
vs2022配置opencv进行监控 c++
08-19
vs2022配置opencv进行监控 c++
C++ Opencv imfill 孔洞填充函数
03-25
C++ Opencv imfill 孔洞填充函数
opencv基于c++个人笔记总结
04-10
opencv基于c++语言编程的入门教程，在visval studio 2017环境下，适合于小白入门，各种基础opencv的函数使用查询。
dev—C++5 配置opencv2.2
05-16
详细介绍轻量级编辑器如何配置opencv2.2
devc++怎么配置opencv
最新发布
04-12
在DevC++中配置OpenCV，你需要按照以下步骤进行操作： 1. 下载OpenCV安装包：首先，你需要从OpenCV官网下载适用于Windows的OpenCV安装包。你可以选择合适的平台和版本进行下载，例如OpenCV-4.7.0版本[^1]。 2. 安装OpenCV：解压下载的OpenCV安装包，并将其安装到你选择的目录中。 3. 配置DevC++：打开DevC++，点击菜单栏的"Tools"，然后选择"Compiler Options"。 4. 配置编译器：在弹出的对话框中，选择"Directories"选项卡。在"Include Directories"中添加OpenCV的头文件目录，例如"D:\OpenCV\opencv\build\include"和"D:\OpenCV\opencv\build\include\opencv2"。在"Library Directories"中添加OpenCV的库文件目录，例如"D:\OpenCV\opencv\build\x64\vc16\lib"。 5. 配置链接器：在同一个对话框中，选择"Linker"选项卡。在"Libraries"中添加OpenCV的库文件，例如"opencv_world470d.lib"（如果你选择的是Debug配置）或"opencv_world470.lib"（如果你选择的是Release配置）。 6. 点击"OK"保存配置。 现在，你已经成功配置了DevC++以使用OpenCV。你可以编写和运行使用OpenCV的C++程序了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值