DICOM文件解析

最新推荐文章于 2024-05-16 09:59:33 发布
最新推荐文章于 2024-05-16 09:59:33 发布
阅读量906 收藏 5
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35769071/article/details/121854983
版权

dicom是一种神奇的格式，可以用dcmtk这个第三方库进行解析。

但是，dcmtk的编译实在令人头大，还要用到opencv库。

不就是把图片读出来嘛，吾辈当自强，我们自己也可以！！（注意！！本代码仅可解析非常非常非常基础的几种dicom，吾辈强度有限）！

于是参照 Dicom格式文件解析器 - assassinx - 博客园 这位大佬的解析和实现，鄙人自己写了一个C++版本的Dicom解析工具。

DicomHelper类负责读取并解析dicom文件，并将图片数据存储到一个特殊的结构体里。结构体包括像素阵列的宽和高以及像素数据。大家可以使用这些数据把dicom格式转换为自己喜欢的格式，或者通过自己喜欢的方法将图片展示出来。

废话不多说，以下是DicomHelper的代码。同时鄙人还做了一个非常简陋的dicom浏览工具，是用Qt实现的。代码会放到百度网盘神奇的链接里，效果大概是这样的：

首先是百度网盘链接

链接：https://pan.baidu.com/s/1w7Ute-_YzOanR22Ib-uc6w 
提取码：dcms

接下来是代码：

DicomHelper.h:

#pragma once
#include <vector>
#include <string>
#include <map>

using namespace std;

typedef struct STpixelStruct
{
	int r;
	int g;
	int b;
};
typedef struct STImageData
{
	int rows;
	int cols;
	vector<STpixelStruct>pixels;
};

class DicomData {
public:
	DicomData()
	{
		isLittleEdian = false;
		isExplicitVR = false;
		fileHeaderLen = 0;
		fileHeaderOffset = 0;
		pixDataOffset = 0;
		pxDataLen = 0;
		tags.clear();
		filename = "";
		windowCenter = 1000;
		windowWidth = 200;
		fileData = NULL;
	}
	int parseFile(string path);
	STImageData getImageData()
	{
		return imageData;
	}
	~DicomData()
	{
		if (fileData != NULL)
		{
			delete fileData;
			fileData = NULL;
		}
		
	}
	STImageData getImageData(int windowCenter, int windowWidth);
private:
	STImageData imageData;
	string filename;
	map<string, string> tags;
	unsigned int fileHeaderLen;
	long fileHeaderOffset;
	unsigned int pxDataLen;
	long pixDataOffset;//像素数据开始位置
	bool isLittleEdian;
	bool isExplicitVR;
	int windowCenter;
	int windowWidth;
	unsigned char* fileData;
	long fileLenth;
	string getVR(string tag);
	string getVF(string VR, vector<unsigned char>VF);
	int readTags(unsigned char* fileData, long fileLenth);
	bool getImage(unsigned char* filedata, long fileLength);
};

DicomHelper.cpp

#include "DicomHelper.h"
#include <stdio.h>
#define ST_INT_MAX (2147483647)
#define ST_UINT_MAX (0XFFFFFFFF)
typedef union ST_NUM {
	double v_d;
	float v_f;
	int v_i;
	unsigned int v_ui;
	unsigned short v_us;
	short v_s;
	unsigned char a[8];
};
enum ST_NUM_TYPE {
	ST_TYPE_UINT16 = 1,
	ST_TYPE_INT16,
	ST_TYPE_UINT32,
	ST_TYPE_INT32,
	ST_TYPE_FLOAT,
	ST_TYPE_DOUBLE
};

string getNumString(ST_NUM_TYPE type, vector<unsigned char>VF)
{
	char numstr[100];
	memset(numstr, 0, sizeof(numstr));
	ST_NUM num;

	if (type == ST_TYPE_UINT16)
	{
		num.a[0] = VF[0];
		num.a[1] = VF[1];
		itoa(num.v_us, numstr, 10);
	}
	else if (type == ST_TYPE_INT16)
	{
		num.a[0] = VF[0];
		num.a[1] = VF[1];
		itoa(num.v_s, numstr, 10);
	}
	else if (type == ST_TYPE_UINT32)
	{
		num.a[0] = VF[0];
		num.a[1] = VF[1];
		num.a[2] = VF[2];
		num.a[3] = VF[3];
		itoa(num.v_ui, numstr, 10);
	}
	else if (type == ST_TYPE_INT32)
	{
		num.a[0] = VF[0];
		num.a[1] = VF[1];
		num.a[2] = VF[2];
		num.a[3] = VF[3];
		itoa(num.v_i, numstr, 10);
	}
	else if (type == ST_TYPE_FLOAT)
	{
		num.a[0] = VF[0];
		num.a[1] = VF[1];
		num.a[2] = VF[2];
		num.a[3] = VF[3];
		sprintf(numstr, "%f", num.v_f);
	}
	else if (type == ST_TYPE_DOUBLE)
	{
		num.a[0] = VF[0];
		num.a[1] = VF[1];
		num.a[2] = VF[2];
		num.a[3] = VF[3];
		num.a[4] = VF[4];
		num.a[5] = VF[5];
		num.a[6] = VF[6];
		num.a[7] = VF[7];
		sprintf(numstr, "%f", num.v_d);
	}
	return numstr;
}

string DicomData::getVR(string tag)
{
	if(tag =="0002,0000")//文件元信息长度
		return "UL";
	if(tag =="0002,0010")//传输语法
		return "UI";
	if (tag == "0002,0013")//文件生成程序的标题
		return "SH";
	if(tag == "0008,0005")//文本编码
		return "CS";
	if (tag == "0008,0008")
		return "CS";
	if (tag == "0008,1032")//成像时间
		return "SQ";
	if (tag == "0008,1111")
		return "SQ";
	if (tag == "0008,0020")//检查日期
		return "DA";
	if (tag == "0008,0060")//成像仪器
		return "CS";
	if (tag == "0008,0070")//成像仪厂商
		return "LO";
	if (tag == "0008,0080")
		return "LO";
	if (tag == "0010,0010")//病人姓名
		return "PN";
	if (tag == "0010,0020")//病人id
		return "LO";
	if (tag == "0010,0030")//病人生日
		return "DA";
	if (tag == "0018,0060")//电压
		return "DS";
	if (tag == "0018,1030")//协议名
		return "LO";
	if (tag == "0018,1151")
		return "IS";
	if (tag == "0020,0010")//检查ID
		return "SH";
	if (tag == "0020,0011")//序列
		return "IS";
	if (tag == "0020,0012")//成像编号
		return "IS";
	if (tag == "0020,0013")//影像编号
		return "IS";
	if (tag == "0028,0002")//像素采样1为灰度3为彩色
		return "US";
	if (tag == "0028,0004")//图像模式MONOCHROME2为灰度
		return "CS";
	if (tag == "0028,0010")//row高
		return "US";
	if (tag == "0028,0011")//col宽
		return "US";
	if (tag == "0028,0100")//单个采样数据长度
		return "US";
	if (tag == "0028,0101")//实际长度
		return "US";
	if (tag == "0028,0102")//采样最大值
		return "US";
	if (tag == "0028,1050")//窗位
		return "DS";
	if (tag == "0028,1051")//窗宽
		return "DS";
	if (tag == "0028,1052")
		return "DS";
	if (tag == "0028,1053")
		return "DS";
	if (tag == "0040,0008")//文件夹标签
		return "SQ";
	if (tag == "0040,0260")//文件夹标签
		return "SQ";
	if (tag == "0040,0275")//文件夹标签
		return "SQ";
	if (tag == "7fe0,0010")//像素数据开始处
		return "OW";
	
	return "UN";
	
}

string DicomData::getVF(string VR, vector<unsigned char>VF)
{
	string vfStr = "";
	if (VF.size() == 0)
	{
		return vfStr;
	}
	if (VR == "SS")
	{		
		vfStr = getNumString(ST_TYPE_INT16,VF);
	}
	else if (VR == "US")
	{
		vfStr = getNumString(ST_TYPE_UINT16, VF);
	}
	else if (VR == "SL")
	{
		vfStr = getNumString(ST_TYPE_INT32, VF);
	}
	else if (VR == "UL")
	{
		vfStr = getNumString(ST_TYPE_UINT32, VF);
	}
	else if (VR == "AT")
	{
		vfStr = getNumString(ST_TYPE_UINT16, VF);
	}
	else if (VR == "FL")
	{
		vfStr = getNumString(ST_TYPE_FLOAT, VF);
	}
	else if (VR == "FD")
	{
		vfStr = getNumString(ST_TYPE_DOUBLE, VF);
	}
	else if (VR == "OB" || VR == "OW" || VR == "SQ" || VR == "OF" || VR == "UT")
	{
		vfStr = (char*)VF.data();
	}
	else {
		vfStr = (char*)VF.data();
	}

	return vfStr;
}

int DicomData::readTags(unsigned char* fileData, long fileLenth)
{
	bool enDir = false;
	int level = 0;
	string flodertag = "";
	vector<char>floderData;
	int startPos = 132;
	while (startPos + 6 < fileLenth)
	{
		char tag[10];
		sprintf(tag, "%02x", fileData[startPos + 1]);
		sprintf(tag + 2, "%02x", fileData[startPos]);
		tag[4] = ',';
		sprintf(tag + 5, "%02x", fileData[startPos + 3]);
		sprintf(tag + 7, "%02x", fileData[startPos + 2]);
		tag[9] = '\0';
		startPos += 4;
		string VR = "";
		string stag = tag;
		if (stag == "0028,0010")
		{
			printf("hh");
		}
		unsigned int len = 0;
		if (stag.substr(0, 4) == "0002")
		{
			VR += fileData[startPos];
			startPos++;
			VR += fileData[startPos];
			startPos++;
			if (VR == "OB" || VR == "OW" || VR == "SQ" || VR == "OF" || VR == "UT" || VR == "UN")
			{
				startPos += 2;
				ST_NUM num;
				num.a[0] = fileData[startPos];
				num.a[1] = fileData[startPos + 1];
				num.a[2] = fileData[startPos + 2];
				num.a[3] = fileData[startPos + 3];
				len = num.v_ui;
				startPos += 4;
			}
			else
			{
				
				ST_NUM num;
				num.a[0] = fileData[startPos];
				num.a[1] = fileData[startPos + 1];
				len = num.v_us;
				startPos += 2;
			}
		}
		else if (stag == "fffe,e000" || stag == "fffe,e00d" || stag == "fffe,e0dd")//文件夹标签
		{
			VR = "**";
			ST_NUM num;
			//startPos += 2;
			num.a[0] = fileData[startPos];
			num.a[1] = fileData[startPos + 1];
			num.a[2] = fileData[startPos + 2];
			num.a[3] = fileData[startPos + 3];
			len = num.v_ui;
			startPos += 4;
		}
		else if (isExplicitVR == true)//有无VR的情况
		{
			VR += fileData[startPos];
			startPos++;
			VR += fileData[startPos];
			startPos++;

			if (VR == "OB" || VR == "OW" || VR == "SQ" || VR == "OF" || VR == "UT" || VR == "UN")
			{
				ST_NUM num;
				startPos += 2;
				num.a[0] = fileData[startPos];
				num.a[1] = fileData[startPos + 1];
				num.a[2] = fileData[startPos + 2];
				num.a[3] = fileData[startPos + 3];
				len = num.v_ui;
				startPos += 4;
			}
			else
			{
				ST_NUM num;
				num.a[0] = fileData[startPos];
				num.a[1] = fileData[startPos + 1];
				len = num.v_us;
				startPos += 2;
			}
		}
		else if (isExplicitVR == false)
		{
			VR = getVR(stag);//无显示VR时根据tag一个一个去找 真烦啊。
			ST_NUM num;
			num.a[0] = fileData[startPos];
			num.a[1] = fileData[startPos + 1];
			num.a[2] = fileData[startPos + 2];
			num.a[3] = fileData[startPos + 3];
			len = num.v_ui;
			startPos += 4;
		}
		vector<unsigned char>VF;
		if (stag == "7fe0,0010")
		{
			pxDataLen = len;
			pixDataOffset = startPos;
			for (int i = 0; i < len; i++)
			{
				VF.push_back(fileData[startPos]);
				startPos++;
			}
			VR = "UL";
		}
		else if ((VR == "SQ" && len == ST_UINT_MAX) || (stag == "fffe,e000" && len == ST_UINT_MAX))
		{
			if (enDir == false)
			{
				enDir = true;
				floderData.clear();
				flodertag = stag;
			}
			else
			{
				level++;//VF不赋值
			}
		}
		else if ((stag == "fffe,e00d" && len == 0) || (stag == "fffe,e0dd" && len == 0))//文件夹结束标签
		{
			if (enDir == true)
			{
				enDir = false;
			}
			else
			{
				level--;
			}
		}
		else
		{
			for (int i = 0; i < len; i++)
			{
				VF.push_back(fileData[startPos]);
				startPos++;
			}
		}

		string VFStr;
		VFStr = getVF(VR, VF);

		//----------------------------------------------------------------针对特殊的tag的值的处理
		//特别针对文件头信息处理
		if (stag == "0002,0000")
		{
			fileHeaderLen = len;
			fileHeaderOffset = startPos;
		}
		else if (stag == "0002,0010")//传输语法 关系到后面的数据读取
		{
			if (VFStr == "1.2.840.10008.1.2.1\0")
			{
				isLittleEdian = true;
				isExplicitVR = true;
			}
			else if (VFStr == "1.2.840.10008.1.2.2\0")
			{
				isLittleEdian = false;
				isExplicitVR = true;
			}
			else if (VFStr == "1.2.840.10008.1.2\0")
			{
				isLittleEdian = true;
				isExplicitVR = false;
			}

		}
		for (int i = 1; i <= level; i++)
			stag = "--" + stag;
		//------------------------------------数据搜集代码
		if ((VR == "SQ" && len == ST_UINT_MAX) || (stag == "fffe,e000" && len == ST_UINT_MAX) || level > 0)//文件夹标签代码
		{
			for (int i = 0; i < stag.length(); i++)
			{
				floderData.push_back(stag[i]);
			}
			floderData.push_back('(');
			for (int i = 0; i < VR.length(); i++)
			{
				floderData.push_back(VR[i]);
			}
			floderData.push_back(')');
			floderData.push_back(':');
			for (int i = 0; i < VFStr.length(); i++)
			{
				floderData.push_back(VFStr[i]);
			}

		}
		else if (((stag == "fffe,e00d" && len == 0) || (stag == "fffe,e0dd" && len == 0)) && level == 0)//文件夹结束标签
		{
			for (int i = 0; i < stag.length(); i++)
			{
				floderData.push_back(stag[i]);
			}
			floderData.push_back('(');
			for (int i = 0; i < VR.length(); i++)
			{
				floderData.push_back(VR[i]);
			}
			floderData.push_back(')');
			floderData.push_back(':');
			for (int i = 0; i < VFStr.length(); i++)
			{
				floderData.push_back(VFStr[i]);
			}
			string flodertag1 = flodertag + "SQ";
			tags[flodertag1] = floderData.data();

		}
		else
		{
			string fltag = "";
			fltag += '(';
			fltag += VR;
			fltag += ')';
			for (int i = 0; i < VFStr.length(); i++)
			{
				fltag.push_back(VFStr[i]);
			}
			if (stag == "0028,0010")
			{
				printf("hh");
			}
			tags[stag] = fltag;
		}

	}
	return 0;
}

int DicomData::parseFile(string path)
{

	FILE* pf = fopen(path.c_str(), "r");
	if (pf == NULL)
	{
		return -1;
	}
	fseek(pf, 0, SEEK_END);
	long long lsize = ftell(pf);
	if (lsize <= 132)
	{
		fclose(pf);
		return -1;
	}
	fileData = (unsigned char*)malloc(lsize + 1);
	if (fileData == NULL)
	{
		fclose(pf);
		return -1;
	}
	rewind(pf);
	fread((void*)fileData, sizeof(unsigned char), lsize, pf);
	fclose(pf);

	char DicomHead[5];
	for (int i = 128;; i++)
	{
		int curPos = i - 128;
		if (curPos == 4)
		{
			break;
		}
		DicomHead[curPos] = fileData[i];
	}
	DicomHead[4] = '\0';
	if (strcmp(DicomHead, "DICM") != 0)
	{
		return -1;
	}
	int ans = readTags(fileData, lsize);
	if (ans != 0)
	{
		return ans;
	}
	getImage(fileData,this->fileLenth);
}
STImageData DicomData::getImageData(int windowCenter, int windowWidth)
{
	this->windowWidth = windowWidth;
	this->windowCenter = windowCenter;
	getImage(fileData, this->fileLenth);
	return imageData;
}
bool DicomData::getImage(unsigned char* filedata, long fileLength)
{
	int imgNum;
	int dataLen;
	int validLen;

	int rows = atoi(tags["0028,0010"].substr(4).c_str());
	int cols = atoi(tags["0028,0011"].substr(4).c_str());
	int colors = atoi(tags["0028,0002"].substr(4).c_str());
	dataLen = atoi(tags["0028,0100"].substr(4).c_str());
	validLen = atoi(tags["0028,0101"].substr(4).c_str());

	imageData.cols = cols;
	imageData.rows = rows;
	imageData.pixels.clear();
	long reads = 0;
	for (int i = 0; i < cols * rows; i++)
	{
		if (reads >= pxDataLen)
		{
			break;
		}
		int readLen = dataLen / (8 * colors);
		unsigned char* cData = new unsigned char(readLen);
		for (int f = 0; f < readLen; f++)
		{
			cData[f] = fileData[pixDataOffset + reads + f];
		}
		reads += readLen;
		STpixelStruct pix;
		if (colors == 1)
		{
			int grayGDI;
			ST_NUM num;
			num.a[0] = cData[0];
			num.a[1] = cData[1];
			double gray = num.v_us;
			int grayStart = (windowCenter - windowWidth / 2);
			int grayEnd = (windowCenter + windowWidth / 2);

			if (gray < grayStart)
			{
				grayGDI = 0;
			}
			else if (gray > grayEnd)
			{
				grayGDI = 255;
			}
			else {
				grayGDI = (int)((gray - grayStart) * 255 / windowWidth);
			}
			if (grayGDI > 255)
			{
				grayGDI = 255;
			}
			else if (grayGDI < 0)
			{
				grayGDI = 0;
			}

			pix.r = grayGDI;
			pix.g = grayGDI;
			pix.b = grayGDI;

		}
		else if (colors == 3)
		{
			pix.r = cData[0];
			pix.g = cData[1];
			pix.b = cData[2];
		}
		delete cData;
		cData = NULL;
		imageData.pixels.push_back(pix);
	}

	return false;
}

TGTSTTG
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
开窗显示读取DICOM图像
Sandyzz的博客
03-26 1199
matlab——开窗显示法读取dicom图像 直接读取dicom图像，对比度很低，利用开窗显示法，读取的图片更为清晰，更利于医学分析 ct值和灰度值之间的变换公式：ct= pixel * RescaleSlope +RescaleIntercept 将ct值转换为灰度值的开窗显示 info=dicominfo('img');%读取dicom图像的元数据 wc=info.WindowCenter;%读取窗位 ww=info.WindowWidth;%读取窗宽 rs=info.RescaleSlope; r
DICOM医学图像处理：利用fo-dicom发送C-Find查询Worklist
只要踏出一步，路就在前方——zssure
09-01 1万+
背景： 如上一篇专栏博文所描述，Worklist可以看做是PACS系统、MODALITY设备和RIS系统之间的信息交换。从RIS系统到MODALITY通过Worklist可以提供诸如患者个人信息（姓名、年龄、生日等）和其他管理数据，以及提供关于成像过程和产生图像相关的一个唯一UID等信息。本博文此次利用fo-dicom开源库，使用C#语言仿真查询worklist的过程。
DICOM开源库对比
weixin_44997008的博客
03-27 875
DICOM：DICOM三大开源库对比分析之“数据加载” 背景： 上一篇博文DICOM：DICOM万能编辑工具之Sante DICOM Editor介绍了DICOM万能编辑工具，在日常使用过程中发现，“只要Sante DICOM Editor打不开的数据，基本可以判定此DICOM文件格式错误（准确率达99.9999%_）”。在感叹Sante DICOM Editor神器牛掰的同时，想了解一下其底层是...
DICOM医学图像处理：fo-dicom网络传输之 C-Echo and C-Store
weixin_34144450的博客
06-23 816
背景：         上一篇博文对DICOM中的网络传输进行了介绍。主要參照DCMTK Wiki中的英文原文。通过对照DCMTK与fo-dicom两个开源库对DICOM标准的详细实现，对理解DICOM标准有一个更直观的认识。此篇博文是对上一篇博文的补充。由于专栏前面的演示样例大多是利用DCMTK工具包来进行的，此次借着分析fo-dicom源代码结构的机会，參照fo-dicom的READ...
探秘 DICOM：高性能的 Go 语言医疗图像解析库
最新发布
gitblog_00038的博客
05-16 386
探秘 DICOM：高性能的 Go 语言医疗图像解析库 项目地址:https://gitcode.com/suyashkumar/dicom 项目简介 在医学影像领域，DICOM（Digital Imaging and Communications in Medicine）是一种广泛使用的标准格式，用于存储和传输医学影像数据。dicom 是一个由资深 Go 开发者创建的开源库，专为处理 DICOM ...
Dicom中日期和时间的解析处理
weixin_44997008的博客
05-19 1021
Dicom中日期和时间的解析处理 在Dicom 中存储的是05/06/2021, 15:00:38.000000 存入数据库中发现时间变为 是导入Dicom 数据时，解析时间错误，原来的实现如下： string reviewTimeStr;//会变成 if (DataSet[DicomTags.ReviewTime].TryGetString(0, out reviewTimeStr)) { TimeSpan reviewTime; if (TimeSpan.
【转】02.Dicom 学习笔记-DICOM C-Find 消息服务
weixin_44116110的博客
11-01 397
DIcom
C# Dicom文件解析获取Tag数据
03-10
FO-DICOM是基于.NET的开源库，它为C#开发者提供了解析和操作DICOM文件的能力。PACS（Picture Archiving and Communication System）则是用于存储、管理和检索医学影像的系统。本教程将详细讲解如何使用C#通过FO-...
Dicom文件解析DLL
10-10
在您提到的“Dicom文件解析DLL”资源中，包含了三个重要的DLL文件： 1. Dicom.Native64.dll 和 Dicom.Native.dll：这些是原生库文件，分别针对64位和32位操作系统。它们实现了对底层操作系统的直接调用，用于处理与...
DICOM文件解析.rar_DICOM文件解析_dicom_dicom 读取_matlab dicom
07-15
MATLAB中读取DICOM文件，并解析其包含信息，并显示出来
DICOM_Parser:将 DICOM 文件解析为 XML 文件
06-18
将 DICOM 文件解析为 XML 文件可以使得数据更易于理解和操作，尤其是在进行大数据分析、机器学习或者跨平台集成时。 DICOM_Parser 的核心功能在于理解 DICOM 文件的结构并将其转换为 XML。DICOM 文件由一系列的数据...
DICOM 解析和修改
02-05
解析DICOM文件，修改文件的基本内容，然后重新生成新的DICOM文件。
dicom格式文件的读取与处理matlab代码
01-26
dicom格式文件的读取与处理matlab代码，可以用于病灶的选取与标记，区分正常组织与坏死区域
基于c#winfrom Dicom图像解析，包括dic，dcm.pk文件
11-22
基于c#winfrom Dicom图像解析，包括dic，dcm.pk文件,内附dcm文件进行测试，dcm文件在文件夹dcm中
DICOM医学文件解析，Delphi原代码
11-28
DICOM医学文件解析，Delphi原代码，有清晰的注释说明；
210812-dicom文件排序并重命名
csdnxiekai的博客
08-12 968
引言 默写情况下，dcm文件导出后虽然名字为1001.dcm，1002.dcm，…，但是并非连续的，1002.dcm可能是第10层，为了后续后处理，前期可以将dcm文件序号和层数对应上 代码如下： clc;clear;close all; %% patients = dir('data_czey/Y*'); for ii = 1:numel(patients) % 遍历病人 patientname = patients(ii).name; disp(['----------------
医学图像DICOM文件解析——DICOM内部信息详解篇
热门推荐
Joker 007的博客
11-08 2万+
DICOM文件内部信息详解
python医学图像处理之读取DICOM文件信息
Cherry330的博客
07-21 3007
python:读取DICOM文件信息
解析医疗影像中的dicom文件
sean的博客
03-08 1413
我们先了解一下DICOM文件是什么，干嘛用的，以及DICOM内部有哪些信息，然后再谈如何去解析这些信息并转换成java对象。
mfc读取dicom文件
05-15
MFC是一种Microsoft Foundation Class的编程框架，用于Windows应用程序的开发。DICOM是医学数字成像和通信标准，用于医学图像的存储、传输和显示。MFC可以用于读取DICOM文件的编程实现。 DICOM文件通常有不同的数据元素，如图像、属性和描述符。读取DICOM文件的第一步是打开文件并解析数据元素，将它们读入程序中。为了实现DICOM文件的读取，需要使用一些特定的库或API。 MFC框架中使用CFile类可以打开DICOM文件并读取其中的数据。可以使用CArchive类编写序列化函数，将DICOM文件解析成相应的数据结构，并进行序列化。然后，使用MFC提供的界面类，例如CView和CDialog，将DICOM图像显示在Windows应用程序中。 另外，为了更好地处理DICOM图像，还可以使用其他的库或API，如OpenCV、VTK和ITK。这些库和API提供了更完整的功能和更高的性能，可以方便地实现DICOM图像的处理和显示。 总之，MFC可以实现读取DICOM文件的功能，但需要结合其他的库和API，才能更好地处理DICOM图像。在开发DICOM应用程序时，需要灵活选择和使用各种工具和技术，以便实现高效、安全和易于维护的DICOM应用程序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值