itk和c++讀取dicom序列前言代碼結果讀取單張dicom讀單張tif寫入單張tif寫單張dicom

前言

• 使用

  c++

  版的

  itk

  讀取存儲在檔案夾中的

  dicom

  序列
• 工具：visual studio 2022 community

代碼

CommonF.h

#pragma once
#include<itkImage.h>
#include<string>

using PixelType = unsigned short;
using ImageType = itk::Image<PixelType, 3>;
using ImageStyle = ImageType::Pointer;


class CommonF
{
public:
	/// <summary>
	/// 讀取dicom檔案夾序列
	/// </summary>
	/// <param name="dicom_dir">dicom檔案夾路徑</param>
	/// <param name="OutImage">讀到的圖像</param>
	void read_dicom_series(const std::string& dicom_dir,ImageStyle& OutImage);

};
           

CommonF.cpp

#include "CommonF.h"
#include<itkGDCMImageIO.h>
#include<itkGDCMSeriesFileNames.h>
#include<itkImageSeriesReader.h>
#include<vector>


void CommonF::read_dicom_series(const std::string& dicom_dir, ImageStyle& OutImage)
{
	using ImageIOType = itk::GDCMImageIO;
	ImageIOType::Pointer DicomIO = ImageIOType::New();

	using ImageReaderType3D = itk::ImageSeriesReader<ImageType>;
	ImageReaderType3D::Pointer ImageReader3D = ImageReaderType3D::New();

	ImageReader3D->SetImageIO(DicomIO);

	using NamesGeneratorType = itk::GDCMSeriesFileNames;
	NamesGeneratorType::Pointer NameGenerator = NamesGeneratorType::New();
	NameGenerator->SetDirectory(dicom_dir);

	using SeriesIdContainer = std::vector<std::string>;
	const SeriesIdContainer& SeriesUID = NameGenerator->GetSeriesUIDs();
	SeriesIdContainer::const_iterator SeriesItr_begin = SeriesUID.begin();
	SeriesIdContainer::const_iterator SeriesItr_end = SeriesUID.end();

	while (SeriesItr_begin != SeriesItr_end)
	{
		std::cout << SeriesItr_begin->c_str() << std::endl;
		SeriesItr_begin++;
	}

	std::string SeriesIdentifier;
	SeriesIdentifier = SeriesUID.begin()->c_str();
	using FileNamesContainer = std::vector<std::string>;
	FileNamesContainer filenames;
	filenames = NameGenerator->GetFileNames(SeriesIdentifier);

	ImageReader3D->SetFileNames(filenames);
	try
	{
		ImageReader3D->Update();
	}
	catch (itk::ExceptionObject& err)
	{
		std::cerr << "error, exception object caught!" << std::endl;
	}

	OutImage = ImageReader3D->GetOutput();
}
           

main.cpp

#include"CommonF.h"



int main()
{
	using std::cout;
	using std::endl;

	CommonF common_f;

	ImageStyle input_image;
	common_f.read_dicom_series("D:/test/004HeRuiPing_CT",input_image);
	ImageType::SizeType size = input_image->GetLargestPossibleRegion().GetSize();
	cout << "org_size = " << size << endl;


	return 0;
}

           

結果

讀取單張

dicom

void RigisterClass::read_one_dicom(
	const std::string& file_path,
	XrayStyle& out_xray)
{
	// reader
	using ReaderType = itk::ImageFileReader<XrayType>;
	auto reader = ReaderType::New();

	// IO
	using ImageIOType = itk::GDCMImageIO;
	auto dcmIO = ImageIOType::New();

	reader->SetImageIO(dcmIO);
	reader->SetFileName(file_path);

	try {
		reader->Update();
	}
	catch (const itk::ExceptionObject& e) {
		std::cout << "error in reading xray" << std::endl;
		std::cerr << e.what() << std::endl;
		throw "error in reading xray";
	}
	out_xray = reader->GetOutput();
}
           

讀單張

tif

void RigisterClass::read_tif(
	const std::string& file_path,
	XrayStyle& out_xray)
{
	using ImageReaderType2D = itk::ImageFileReader<XrayType>;
	ImageReaderType2D::Pointer imageReader2D = ImageReaderType2D::New();

	// IO
	using TIFFIOType = itk::TIFFImageIO;
	TIFFIOType::Pointer tiffIO = TIFFIOType::New();

	imageReader2D->SetImageIO(tiffIO);

	imageReader2D->SetFileName(file_path);
	try {
		imageReader2D->Update();
	}
	catch (const itk::ExceptionObject& e) {
		std::cerr << e << std::endl;
	}
	out_xray = imageReader2D->GetOutput();
}
           

寫入單張

tif

void RigisterClass::write_tif_image(
	const OutputImageStyle& writed_image,
	const std::string& file_path)
{
	// writer
	using WriterType = itk::ImageFileWriter<OutputImageType>;
	WriterType::Pointer writer = WriterType::New();

	// IO
	using TIFFIOType = itk::TIFFImageIO;
	TIFFIOType::Pointer tiffIO = TIFFIOType::New();

	writer->SetImageIO(tiffIO);
	writer->SetFileName(file_path);
	writer->SetInput(writed_image);
	try
	{
		std::cout << "Writing image: " << file_path << std::endl;
		writer->Update();
	}
	catch (itk::ExceptionObject& err)
	{
		std::cerr << "error in saveing out-xray !" << std::endl;
		std::cerr << err << std::endl;
		throw "error in saveing out-xray.";
	}
}
           

寫單張

dicom

void RigisterClass::write_one_dcm(
	const OutputImageStyle& writed_image,
	const std::string& file_path)
{
	using WriterType = itk::ImageFileWriter<OutputImageType>;
	auto writer = WriterType::New();

	using ImageIOType = itk::GDCMImageIO;
	auto dcmIO = ImageIOType::New();

	writer->SetImageIO(dcmIO);

	writer->SetFileName(file_path);
	writer->UseInputMetaDataDictionaryOff();
	writer->SetInput(writed_image);
	try {
		writer->Update();
	}
	catch (const itk::ExceptionObject& e) {
		std::cout << "error in saveing out dcm" << std::endl;
		std::cerr << e.what() << std::endl;
	}
}