// Load our vtkImageData object from a list of DICOM image filenames...
// http://www.vtk.org/pipermail/vtkusers/2007-August/042635.html
void vtkDicom::load_dcmFiles(QStringList dcm_fileList) {
DcmFileFormat dcm;
std::string imgFname;
std::cout << "vtkdicom: Files/Images(?): " << dcm_fileList.size() << "\n";
for (int sei = 0; sei < dcm_fileList.size(); ++sei) {
imgFname = dcm_fileList.at(sei).toLocal8Bit().constData();
OFCondition status = dcm.loadFile(imgFname.c_str());
if (!status.good()) {
std::cout << " vtkdicom: Error: cannot read file (" << status.text() << ")" << "\n";
return;
}
if (sei == 0) {
OFString acquisitionNumber, instanceNumber, imagePositionPatient, patientsName;
DcmDataset *dcmDs = dcm.getDataset();
dcmDs->findAndGetOFStringArray(DCM_ImagePositionPatient, imagePositionPatient);
dcmDs->findAndGetOFString(DCM_AcquisitionNumber, acquisitionNumber);
dcmDs->findAndGetOFString(DCM_InstanceNumber, instanceNumber);
dcmDs->findAndGetOFString(DCM_PatientName, patientsName);
std::cout << "vtkdicom: I#, IPP: " << instanceNumber << " - " << imagePositionPatient << "\n";
}
dcm.loadAllDataIntoMemory();
const unsigned short* p = NULL;
dcm.getDataset()->findAndGetUint16Array(DCM_PixelData, p);
}
}
//------------------------------------------------------------------------------
void ctkDICOMDatabase::loadFileHeader (QString fileName)
{
Q_D(ctkDICOMDatabase);
DcmFileFormat fileFormat;
OFCondition status = fileFormat.loadFile(fileName.toLatin1().data());
if (status.good())
{
DcmDataset *dataset = fileFormat.getDataset();
DcmStack stack;
while (dataset->nextObject(stack, true) == EC_Normal)
{
DcmObject *dO = stack.top();
if (dO->isaString())
{
QString tag = QString("%1,%2").arg(
dO->getGTag(),4,16,QLatin1Char('0')).arg(
dO->getETag(),4,16,QLatin1Char('0'));
std::ostringstream s;
dO->print(s);
d->LoadedHeader[tag] = QString(s.str().c_str());
}
}
}
return;
}
bool DicomImporter::IsFileValid(const String& _file)
{
try
{
//
// create the dicom fileformat and check if this is possible
//
DcmFileFormat ff;
OFCondition cond = ff.loadFile(_file.c_str());
if (cond.bad()) return false;
//
// ist it in part 10 format (does meta-header exist)?
//
DcmMetaInfo *m = ff.getMetaInfo();
if (m == NULL || m->card() == 0) return false;
//
// does the file contain data (does the dataset exist)?
//
DcmDataset *d = ff.getDataset();
if (d == NULL) return false;
//
// yes, it is a valid dicom file!
//
return true;
}
catch (...)
{
throw;
}
}
bool DCMTKImageIO::CanReadFile(const char* filename)
{
DcmFileFormat dicomFile;
OFCondition condition = dicomFile.loadFile( filename );
if ( !condition.good() ) {
return false;
}
E_TransferSyntax xfer = dicomFile.getDataset()->getOriginalXfer();
if( xfer == EXS_JPEG2000LosslessOnly ||
xfer == EXS_JPEG2000 ||
xfer == EXS_JPEG2000MulticomponentLosslessOnly ||
xfer == EXS_JPEG2000Multicomponent ) {
return false;
}
// search for mandatory tags
DcmStack stack;
DcmTagKey searchKey;
unsigned int group = 0x0028; // samples per pixel
unsigned int elem = 0x0002; // samples per pixel
searchKey.set(group, elem);
if (dicomFile.search(searchKey, stack, ESM_fromHere, OFTrue) != EC_Normal)
return false;
group = 0x0028; // pixel type
elem = 0x0100; // pixel type
searchKey.set(group, elem);
if (dicomFile.search(searchKey, stack, ESM_fromHere, OFTrue) != EC_Normal)
return false;
return true;
}
void
LocalService::SolveFile(
const boost::filesystem::path & fileName, const boost::filesystem::path & path,
ResultSet &result)
{
OFString ofStr;
DcmFileFormat dfile;
OFCondition cond = dfile.loadFile( fileName.string().data());
if (! cond.good())
{
LOG( "Loading of " << fileName << " failed. (" << cond.text() << ")" );
return;
}
DcmDataset *dataSet = dfile.getDataset();
TableRow row;
SerieInfo serInfo;
// load data and check if it is already in tree
CheckDataSet( dataSet, serInfo, row, path.string());
// look if this row is already in resultSet
FoundStudiesSet::iterator found = m_alreadyFoundInRun.find(row.studyID);
// if not, add it
if( found == m_alreadyFoundInRun.end() )
{
m_alreadyFoundInRun.insert( FoundStudiesSet::value_type( row.studyID) );
result.push_back( row);
}
}
Examen*
ParserDicom::loadFile(string dirName)
{
// Open directory
DIR* dir = opendir(dirName.c_str());
if (dir == NULL) {
return NULL;
}
// Get examen informations
ExamenParams* params = getInfos(dir, dirName);
if (params == NULL) {
return NULL;
}
// Create struct examen
Volume* img = new Volume(params->width, params->height, params->depth);
Examen* exam = new Examen(img, params);
// Read data
int index = 0;
struct dirent* file;
rewinddir(dir);
string pathDirectory = dirName + PATH_SEPARATOR;
int tabSize = params->width * params->height;
float tab[tabSize];
while ((file = readdir(dir)) != NULL) {
if (strcmp(file->d_name, ".") != 0 &&
strcmp(file->d_name, "..") != 0) {
string fullpath = pathDirectory + file->d_name;
DcmFileFormat dcm;
OFCondition cond = dcm.loadFile(fullpath.c_str());
if (cond.bad()) {
delete img;
delete params;
return NULL;
}
DiDocument* didoc = new DiDocument(fullpath.c_str());
DiMono2Image* dimg = new DiMono2Image(didoc, EIS_Normal);
OFString s;
dcm.getDataset()->findAndGetOFString(DCM_BitsStored, s);
int bitsStored = atoi(s.c_str());
short* slice = (short*) dimg->getOutputData(0, bitsStored, 0);
for(int i=0; i<tabSize; ++i) {
tab[i] = (float) slice[i];
}
img->setSlice(tab, index++);
delete dimg;
delete didoc;
}
}
closedir(dir);
return exam;
}
mitk::DataNode::Pointer RTDoseReader::
LoadRTDose(const char* filename)
{
DcmFileFormat fileformat;
OFCondition outp = fileformat.loadFile(filename, EXS_Unknown);
if(outp.bad())
{
MITK_ERROR << "Cant read the file" << std::endl;
}
DcmDataset *dataset = fileformat.getDataset();
std::string name = filename;
itk::FilenamesContainer file;
file.push_back(name);
mitk::DicomSeriesReader* reader = new mitk::DicomSeriesReader;
mitk::DataNode::Pointer originalNode = reader->LoadDicomSeries(file,false);
if(originalNode.IsNull())
{
MITK_ERROR << "Error reading the dcm file" << std::endl;
return 0;
}
mitk::Image::Pointer originalImage
= dynamic_cast<mitk::Image*>(originalNode->GetData());
DRTDoseIOD doseObject;
OFCondition result = doseObject.read(*dataset);
if(result.bad())
{
MITK_ERROR << "Error reading the Dataset" << std::endl;
return 0;
}
OFString gridScaling;
Float32 gridscale;
doseObject.getDoseGridScaling(gridScaling);
gridscale = OFStandard::atof(gridScaling.c_str());
AccessByItk_1(originalImage, MultiplayGridScaling, gridscale);
double prescripeDose = this->GetMaxDoseValue(dataset);
originalNode->SetName("RT Dose");
originalNode->SetFloatProperty(mitk::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(),prescripeDose);
originalNode->SetFloatProperty(mitk::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), 40);
originalNode->SetBoolProperty(mitk::Constants::DOSE_PROPERTY_NAME.c_str(),true);
return originalNode;
}
StoreStatus ServerContext::Store(std::string& resultPublicId,
DcmFileFormat& dicomInstance,
const char* dicomBuffer,
size_t dicomSize)
{
DicomMap dicomSummary;
FromDcmtkBridge::Convert(dicomSummary, *dicomInstance.getDataset());
DicomInstanceHasher hasher(dicomSummary);
resultPublicId = hasher.HashInstance();
Json::Value dicomJson;
FromDcmtkBridge::ToJson(dicomJson, *dicomInstance.getDataset());
StoreStatus status = StoreStatus_Failure;
if (dicomSize > 0)
{
status = Store(dicomBuffer, dicomSize, dicomSummary, dicomJson, "");
}
return status;
}
int main(void)
{
DcmFileFormat fileformat;
OFCondition oc = fileformat.loadFile("D:\\021A3C1C.dcm");
if(oc.good())
{
OFString patientName;
if(fileformat.getDataset()->findAndGetOFString(DCM_PatientName, patientName).good())
{
std::cout<<"Patient Name:"<<patientName<<std::endl;
}
}
return 0;
}
Status ConvertDicomToLittleEndian::convert(QString inputFile, QString outputFile)
{
DcmFileFormat fileformat;
DcmDataset *dataset = fileformat.getDataset();
OFCondition error;
Status state;
// Transfer Syntax del fitxer d'entrada
E_TransferSyntax opt_ixfer = EXS_Unknown;
E_FileReadMode opt_readMode = ERM_autoDetect;
E_TransferSyntax opt_oxfer = EXS_LittleEndianExplicit;
QString descriptionError;
E_EncodingType opt_oenctype = EET_ExplicitLength;
E_GrpLenEncoding opt_oglenc = EGL_recalcGL;
E_PaddingEncoding opt_opadenc = EPD_noChange;
OFCmdUnsignedInt opt_filepad = 0;
OFCmdUnsignedInt opt_itempad = 0;
E_FileWriteMode writeMode = EWM_fileformat;
error = fileformat.loadFile(qPrintable(QDir::toNativeSeparators(inputFile)), opt_ixfer, EGL_noChange, DCM_MaxReadLength, opt_readMode);
if (error.bad())
{
ERROR_LOG(QString("No s'ha pogut obrir el fitxer a convertir LittleEndian %1, descripcio error: %2").arg(inputFile, error.text()));
return state.setStatus(error);
}
dataset->loadAllDataIntoMemory();
DcmXfer opt_oxferSyn(opt_oxfer);
dataset->chooseRepresentation(opt_oxfer, NULL);
if (!dataset->canWriteXfer(opt_oxfer))
{
descriptionError = "Error: no conversion to transfer syntax " + QString(opt_oxferSyn.getXferName()) + " possible";
state.setStatus(qPrintable(descriptionError), false, 1300);
ERROR_LOG(descriptionError);
return state;
}
error = fileformat.saveFile(qPrintable(QDir::toNativeSeparators(outputFile)), opt_oxfer, opt_oenctype, opt_oglenc, opt_opadenc,
OFstatic_cast(Uint32, opt_filepad), OFstatic_cast(Uint32, opt_itempad), writeMode);
if (!error.good())
{
ERROR_LOG(QString("S'ha produit un error al intentar gravar la imatge %1 convertida a LittleEndian al path %2, descripcio error: %3")
.arg(inputFile, outputFile, error.text()));
}
return state.setStatus(error);
}
StoreStatus ServerContext::Store(std::string& resultPublicId,
DcmFileFormat& dicomInstance)
{
std::string buffer;
if (!FromDcmtkBridge::SaveToMemoryBuffer(buffer, dicomInstance.getDataset()))
{
throw OrthancException(ErrorCode_InternalError);
}
if (buffer.size() == 0)
return Store(resultPublicId, dicomInstance, NULL, 0);
else
return Store(resultPublicId, dicomInstance, &buffer[0], buffer.size());
}
std::string ImageMatrix::get_patientname(const std::string & dirpath){
std::string filepath = dirpath + "\\ADC\\ADC_1";
DcmFileFormat *pDicomFile = new DcmFileFormat();
OFCondition oc = pDicomFile->loadFile(filepath.c_str());
if(oc.good()){
DcmDataset *pDataset = pDicomFile->getDataset();
const char * name;
pDataset -> findAndGetString(DCM_PatientName, name);
std::string res(name);
delete pDataset;
return res;
}
else
return "f**k";
}
void vtkDicom::dumpDicomFile(std::string imgFname)
{
DcmFileFormat dfile;
OFCondition status = dfile.loadFile(imgFname.c_str());
if (status.good()) {
OFString acquisitionNumber, instanceNumber, imagePositionPatient, patientsName;
dfile.loadAllDataIntoMemory();
DcmDataset *dcmDs = dfile.getDataset();
dcmDs->findAndGetOFStringArray(DCM_ImagePositionPatient, imagePositionPatient);
dcmDs->findAndGetOFString(DCM_AcquisitionNumber, acquisitionNumber);
dcmDs->findAndGetOFString(DCM_InstanceNumber, instanceNumber);
dcmDs->findAndGetOFString(DCM_PatientName, patientsName);
std::cout << " " << instanceNumber << " - " << imagePositionPatient << "\n";
} else {
std::cout << " Error: cannot read file (" << status.text() << ")" << "\n";
}
}
void
LocalService::SolveFileGET( const boost::filesystem::path & fileName,
const std::string &patientID,
const std::string &studyID,
const std::string &serieID,
DicomObjSet &result,
const std::string &path)
{
OFString ofStr;
DcmFileFormat dfile;
OFCondition cond = dfile.loadFile( fileName.string().data());
if (! cond.good())
{
LOG( "Loading of " << fileName << " failed. (" << cond.text() << ")" );
return;
}
DcmDataset *dataSet = dfile.getDataset();
TableRow row;
SerieInfo serInfo;
// load data and check if it is already in tree
CheckDataSet( dataSet, serInfo, row, path);
// compare with wantend ones
if( row.patientID == patientID
&& row.studyID == studyID
&& serInfo.id == serieID)
{
// if it mathes, insert new image into result
DicomObj buddy;
result.push_back( buddy);
// copy dataset reference & init
DicomObj *newOne = &result.back();
newOne->Load( fileName.string() );
newOne->Init();
}
}
IFileIO::ConfidenceLevel DICOMSegmentationIO::GetReaderConfidenceLevel() const
{
if (AbstractFileIO::GetReaderConfidenceLevel() == Unsupported)
return Unsupported;
const std::string fileName = this->GetLocalFileName();
DcmFileFormat dcmFileFormat;
OFCondition status = dcmFileFormat.loadFile(fileName.c_str());
if (status.bad())
return Unsupported;
OFString modality;
if (dcmFileFormat.getDataset()->findAndGetOFString(DCM_Modality, modality).good())
{
if (modality.compare("SEG") == 0)
return Supported;
else
return Unsupported;
}
return Unsupported;
}
OFCondition RetrieveDICOMFilesFromPACS::storeSCP(T_ASC_Association *association, T_DIMSE_Message *msg, T_ASC_PresentationContextID presentationContextID)
{
T_DIMSE_C_StoreRQ *storeRequest = &msg->msg.CStoreRQ;
OFBool useMetaheader = OFTrue;
StoreSCPCallbackData storeSCPCallbackData;
DcmFileFormat retrievedFile;
DcmDataset *retrievedDataset = retrievedFile.getDataset();
storeSCPCallbackData.dcmFileFormat = &retrievedFile;
storeSCPCallbackData.retrieveDICOMFilesFromPACS = this;
storeSCPCallbackData.fileName = storeRequest->AffectedSOPInstanceUID;
OFCondition condition = DIMSE_storeProvider(association, presentationContextID, storeRequest, NULL, useMetaheader, &retrievedDataset, storeSCPCallback,
(void*) &storeSCPCallbackData, DIMSE_BLOCKING, 0);
if (condition.bad())
{
// Remove file
ERROR_LOG("S'ha produit al processar una peticio de descarregar d'un fitxer, descripcio error " + QString(condition.text()));
unlink(qPrintable(storeSCPCallbackData.fileName));
}
return condition;
}
std::vector<itk::SmartPointer<BaseData> > RTDoseReader::Read()
{
std::vector<itk::SmartPointer<mitk::BaseData> > result;
DICOMTag referencedRTPlan(0x300c, 0x0002);
mitk::IDICOMTagsOfInterest* toiSrv = GetDicomTagsOfInterestService();
if (toiSrv)
{
toiSrv->AddTagOfInterest(referencedRTPlan);
}
std::string location = GetInputLocation();
mitk::DICOMFileReaderSelector::Pointer selector = mitk::DICOMFileReaderSelector::New();
selector->LoadBuiltIn3DConfigs();
selector->SetInputFiles({ location });
mitk::DICOMFileReader::Pointer reader = selector->GetFirstReaderWithMinimumNumberOfOutputImages();
reader->SetAdditionalTagsOfInterest(toiSrv->GetTagsOfInterest());
reader->SetInputFiles({ location });
reader->AnalyzeInputFiles();
reader->LoadImages();
if (reader->GetNumberOfOutputs() == 0){
MITK_ERROR << "Could not determine a DICOM reader for this file" << std::endl;
return result;
}
const mitk::DICOMImageBlockDescriptor& desc = reader->GetOutput(0);
mitk::Image::Pointer originalImage = desc.GetMitkImage();
if (originalImage.IsNull())
{
MITK_ERROR << "Error reading the RTDOSE file in mitk::DicomFileReader" << std::endl;
return result;
}
DcmFileFormat fileformat;
OFCondition outp = fileformat.loadFile(location.c_str(), EXS_Unknown);
if (outp.bad())
{
MITK_ERROR << "Error reading the RTDOSE file in DCMTK" << std::endl;
return result;
}
DcmDataset *dataset = fileformat.getDataset();
DRTDoseIOD doseObject;
OFCondition DCMTKresult = doseObject.read(*dataset);
if (DCMTKresult.bad())
{
MITK_ERROR << "Error reading the RTDOSE file in DCMTK" << std::endl;
return result;
}
OFString gridScaling;
Float32 gridscale;
doseObject.getDoseGridScaling(gridScaling);
gridscale = OFStandard::atof(gridScaling.c_str());
AccessByItk_1(originalImage, MultiplyGridScaling, gridscale);
auto statistics = this->scaledDoseImage->GetStatistics();
double maxDose = statistics->GetScalarValueMax();
this->scaledDoseImage->SetPropertyList(originalImage->GetPropertyList());
this->scaledDoseImage->SetProperty(mitk::RTConstants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(), mitk::GenericProperty<double>::New(0.8*maxDose));
result.push_back(this->scaledDoseImage.GetPointer());
return result;
}
ExamenParams*
ParserDicom::getInfos(DIR* dir, string dirName)
{
struct dirent* file = getOneFile(dir);
if (file == NULL) {
return NULL;
}
string fullpath = dirName + PATH_SEPARATOR + file->d_name;
DcmFileFormat dcm;
OFCondition cond = dcm.loadFile(fullpath.c_str());
if (cond.bad()) {
return NULL;
}
Information* generalInfos = new Information();
OFString s;
dcm.getDataset()->findAndGetOFString(DCM_PatientName, s);
generalInfos->addInformation("Patient name", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_PatientID, s);
generalInfos->addInformation("Patient ID", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_PatientBirthDate, s);
generalInfos->addInformation("Patient birthday", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_PatientAge, s);
generalInfos->addInformation("Patient age", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_PatientSex, s);
generalInfos->addInformation("Patient sex", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_PatientSize, s);
generalInfos->addInformation("Patient size", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_PatientWeight, s);
generalInfos->addInformation("Patient weight", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_ImagePositionPatient, s);
generalInfos->addInformation("Image position patient", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_ImageOrientationPatient, s);
generalInfos->addInformation("Image orientation patient", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_StudyID, s);
generalInfos->addInformation("Study data", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_StudyDate, s);
generalInfos->addInformation("Study date", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_StudyTime, s);
generalInfos->addInformation("Study time", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_StudyDescription, s);
generalInfos->addInformation("Study description", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_BitsAllocated, s);
generalInfos->addInformation("Bits allocated", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_BitsStored, s);
generalInfos->addInformation("Bits stored", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_HighBit, s);
generalInfos->addInformation("High bit", s.c_str());
generalInfos->addInformation("Intercept", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_RescaleIntercept, s);
int intercept = atoi(s.c_str());
generalInfos->addInformation("Slope", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_RescaleSlope, s);
int slope = atoi(s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_WindowCenter, s);
generalInfos->addInformation("Window center", s.c_str());
int Wcenter=atoi(s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_WindowWidth, s);
generalInfos->addInformation("Window width", s.c_str());
int Wwidth=atoi(s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_SliceThickness, s);
generalInfos->addInformation("Slice thickness", s.c_str());
float Sthickness = atof(s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_WindowCenterWidthExplanation, s);
generalInfos->addInformation("WindowCenterWidthExplanation", s.c_str());
dcm.getDataset()->findAndGetOFString(DCM_Manufacturer, s);
generalInfos->addInformation("Manufacturer", s.c_str());
//---------------------------------------------
// Affectation des parametres de l'examen
//---------------------------------------------
GrayTranslationFunction gtf(slope, intercept);
ExamenParams* params = new ExamenParams(gtf, fullpath, generalInfos);
params->getGrayViewWindow().setLuminosity(Wcenter);
params->getGrayViewWindow().setContrast(Wwidth);
//params->getGrayViewWindow().setMin(HundsfieldValue::min()); // Must choose !
//params->getGrayViewWindow().setMax(HundsfieldValue::max());
//params->setParametersSI(Sthickness);
//---------------------------------------------
// Examen size informations
//---------------------------------------------
DiDocument* didoc = new DiDocument(fullpath.c_str());
DiMono2Image* dimg = new DiMono2Image(didoc, EIS_Normal);
params->width = dimg->getColumns();
params->height = dimg->getRows();
params->depth = nbFiles(dir);
params->resolutionX = dimg->getPixelWidth();;
params->resolutionY = dimg->getPixelHeight();;
params->resolutionZ = Sthickness; // check
ostringstream sNbSlice, sSize, sResX, sResY;
sResX << params->resolutionX;
sResY << params->resolutionY;
sNbSlice << params->depth + 1;
sSize << params->width << " " << params->height;
generalInfos->addInformation("Slice number", sNbSlice.str());
generalInfos->addInformation("Scan resolution (x, y)", sSize.str());
generalInfos->addInformation("Pixel resolution X", sResX.str());
generalInfos->addInformation("Pixel resolution Y", sResY.str());
delete dimg;
delete didoc;
return params;
}
//************************************
// Method: Open
// FullName: CDcmMerger::Open
// Access: public
// Returns: int
// Qualifier:
// Parameter: CStringList * in_pFileList
// Purpose:
//************************************
int CDcmMerger::Open(CStringList* in_pFileList)
{
int retcode = SV_NORMAL;
for (INT i = 0; i< in_pFileList->GetCount(); i++)
{
POSITION pos = NULL;
pos = in_pFileList->FindIndex(i);
if(pos != NULL)
{
CString sFileName = in_pFileList->GetAt(pos);
char* pzTempName;
//Convert to ANSI code
if(CUtility::UnicodeToAnsi(sFileName,&pzTempName) != ERROR_SUCCESS)
retcode = SV_SYSTEM_ERR;
//Create DICOM file access object
DcmFileFormat* pDcmFile = NULL;
DicomImage* pDcmImage = NULL;
//*********Create file object
pDcmFile = new DcmFileFormat();
if (pDcmFile == NULL) retcode = SV_MEMORY_ERR;
//Load file
E_TransferSyntax xfer;
if(retcode == SV_NORMAL)
{
OFCondition cond = pDcmFile->loadFile(pzTempName,
EXS_Unknown,
EGL_withoutGL,
DCM_MaxReadLength,
ERM_autoDetect);
if (cond.bad()) retcode = SV_FILEIO_ERROR;
else xfer = pDcmFile->getDataset()->getOriginalXfer();
}
OFCmdUnsignedInt opt_frame = 0; //default: start from first frame
OFCmdUnsignedInt opt_frameCount = 0; //default: process all frame
if(retcode == SV_NORMAL)
{
//*********Create image object
pDcmImage = new DicomImage(pDcmFile, xfer, CIF_AcrNemaCompatibility, opt_frame, opt_frameCount);
if (pDcmImage == NULL)
retcode = SV_MEMORY_ERR;
else if (pDcmImage->getStatus() != EIS_Normal)
retcode = SV_UNSUPPORT_FORMAT;
}
if(retcode == SV_NORMAL)
{
// VOI LUT processing [1/31/2009 QUYPS]
pDcmImage->setMinMaxWindow();
//Add to list
m_FileList.AddTail(pDcmFile);
m_ImageList.AddTail(pDcmImage);
}
else
{
delete pDcmFile;
delete pDcmImage;
}
//Release memory
delete[] pzTempName;
}
else
{
retcode = SV_SYSTEM_ERR;
}
//if error occur, escape from loop
if (retcode != SV_NORMAL) break;
}
return retcode;
}
virtual ReadResult readImage(const std::string& file, const osgDB::ReaderWriter::Options* options) const
{
notice()<<"Reading DICOM file "<<file<<" using DCMTK"<<std::endl;
std::string ext = osgDB::getLowerCaseFileExtension(file);
if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
std::string fileName = file;
if (ext=="dicom")
{
fileName = osgDB::getNameLessExtension(file);
}
fileName = osgDB::findDataFile( fileName, options );
if (fileName.empty()) return ReadResult::FILE_NOT_FOUND;
Files files;
osgDB::FileType fileType = osgDB::fileType(fileName);
if (fileType==osgDB::DIRECTORY)
{
getDicomFilesInDirectory(fileName, files);
}
else
{
#if 1
files.push_back(fileName);
#else
if (!getDicomFilesInDirectory(osgDB::getFilePath(fileName), files))
{
files.push_back(fileName);
}
#endif
}
if (files.empty())
{
return ReadResult::FILE_NOT_FOUND;
}
osg::ref_ptr<osg::RefMatrix> matrix = new osg::RefMatrix;
osg::ref_ptr<osg::Image> image;
unsigned int imageNum = 0;
EP_Representation pixelRep = EPR_Uint8;
int numPlanes = 0;
GLenum pixelFormat = 0;
GLenum dataType = 0;
unsigned int pixelSize = 0;
typedef std::list<FileInfo> FileInfoList;
FileInfoList fileInfoList;
typedef std::map<double, FileInfo> DistanceFileInfoMap;
typedef std::map<osg::Vec3d, DistanceFileInfoMap> OrientationFileInfoMap;
OrientationFileInfoMap orientationFileInfoMap;
unsigned int totalNumSlices = 0;
for(Files::iterator itr = files.begin();
itr != files.end();
++itr)
{
DcmFileFormat fileformat;
OFCondition status = fileformat.loadFile((*itr).c_str());
if(!status.good()) return ReadResult::ERROR_IN_READING_FILE;
FileInfo fileInfo;
fileInfo.filename = *itr;
double pixelSize_y = 1.0;
double pixelSize_x = 1.0;
double sliceThickness = 1.0;
double imagePositionPatient[3] = {0, 0, 0};
double imageOrientationPatient[6] = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0 };
Uint16 numOfSlices = 1;
double value = 0.0;
if (fileformat.getDataset()->findAndGetFloat64(DCM_PixelSpacing, value,0).good())
{
pixelSize_y = value;
fileInfo.matrix(1,1) = pixelSize_y;
}
if (fileformat.getDataset()->findAndGetFloat64(DCM_PixelSpacing, value,1).good())
{
pixelSize_x = value;
fileInfo.matrix(0,0) = pixelSize_x;
}
// Get slice thickness
if (fileformat.getDataset()->findAndGetFloat64(DCM_SliceThickness, value).good())
{
sliceThickness = value;
notice()<<"sliceThickness = "<<sliceThickness<<std::endl;
fileInfo.sliceThickness = sliceThickness;
}
notice()<<"tagExistsWithValue(DCM_NumberOfFrames)="<<fileformat.getDataset()->tagExistsWithValue(DCM_NumberOfFrames)<<std::endl;
notice()<<"tagExistsWithValue(DCM_NumberOfSlices)="<<fileformat.getDataset()->tagExistsWithValue(DCM_NumberOfSlices)<<std::endl;
Uint32 numFrames;
if (fileformat.getDataset()->findAndGetUint32(DCM_NumberOfFrames, numFrames).good())
{
fileInfo.numSlices = numFrames;
notice()<<"Read number of frames = "<<numFrames<<std::endl;
}
OFString numFramesStr;
if (fileformat.getDataset()->findAndGetOFString(DCM_NumberOfFrames, numFramesStr).good())
{
fileInfo.numSlices = atoi(numFramesStr.c_str());
notice()<<"Read number of frames = "<<numFramesStr<<std::endl;
}
if (fileformat.getDataset()->findAndGetUint16(DCM_NumberOfFrames, numOfSlices).good())
{
fileInfo.numSlices = numOfSlices;
notice()<<"Read number of frames = "<<numOfSlices<<std::endl;
}
if (fileformat.getDataset()->findAndGetUint16(DCM_NumberOfSlices, numOfSlices).good())
{
fileInfo.numSlices = numOfSlices;
notice()<<"Read number of slices = "<<numOfSlices<<std::endl;
}
// patient position
for(int i=0; i<3; ++i)
{
if (fileformat.getDataset()->findAndGetFloat64(DCM_ImagePositionPatient, imagePositionPatient[i],i).good())
{
notice()<<"Read DCM_ImagePositionPatient["<<i<<"], "<<imagePositionPatient[i]<<std::endl;
}
else
{
notice()<<"Have not read DCM_ImagePositionPatient["<<i<<"]"<<std::endl;
}
}
//notice()<<"imagePositionPatient[2]="<<imagePositionPatient[2]<<std::endl;
fileInfo.matrix.setTrans(imagePositionPatient[0],imagePositionPatient[1],imagePositionPatient[2]);
for(int i=0; i<6; ++i)
{
double value = 0.0;
if (fileformat.getDataset()->findAndGetFloat64(DCM_ImageOrientationPatient, value,i).good())
{
imageOrientationPatient[i] = value;
notice()<<"Read imageOrientationPatient["<<i<<"], "<<imageOrientationPatient[i]<<std::endl;
}
else
{
notice()<<"Have not read imageOrientationPatient["<<i<<"]"<<std::endl;
}
}
osg::Vec3d dirX(imageOrientationPatient[0],imageOrientationPatient[1],imageOrientationPatient[2]);
osg::Vec3d dirY(imageOrientationPatient[3],imageOrientationPatient[4],imageOrientationPatient[5]);
osg::Vec3d dirZ = dirX ^ dirY;
dirZ.normalize();
dirX *= pixelSize_x;
dirY *= pixelSize_y;
fileInfo.matrix(0,0) = dirX[0];
fileInfo.matrix(1,0) = dirX[1];
fileInfo.matrix(2,0) = dirX[2];
fileInfo.matrix(0,1) = dirY[0];
fileInfo.matrix(1,1) = dirY[1];
fileInfo.matrix(2,1) = dirY[2];
fileInfo.matrix(0,2) = dirZ[0];
fileInfo.matrix(1,2) = dirZ[1];
fileInfo.matrix(2,2) = dirZ[2];
fileInfo.distance = dirZ * (osg::Vec3d(0.0,0.0,0.0)*fileInfo.matrix);
notice()<<"dirX = "<<dirX<<std::endl;
notice()<<"dirY = "<<dirY<<std::endl;
notice()<<"dirZ = "<<dirZ<<std::endl;
notice()<<"matrix = "<<fileInfo.matrix<<std::endl;
notice()<<"pos = "<<osg::Vec3d(0.0,0.0,0.0)*fileInfo.matrix<<std::endl;
notice()<<"dist = "<<fileInfo.distance<<std::endl;
notice()<<std::endl;
(orientationFileInfoMap[dirZ])[fileInfo.distance] = fileInfo;
totalNumSlices += fileInfo.numSlices;
}
if (orientationFileInfoMap.empty()) return 0;
typedef std::map<double, FileInfo> DistanceFileInfoMap;
typedef std::map<osg::Vec3d, DistanceFileInfoMap> OrientationFileInfoMap;
for(OrientationFileInfoMap::iterator itr = orientationFileInfoMap.begin();
itr != orientationFileInfoMap.end();
++itr)
{
notice()<<"Orientation = "<<itr->first<<std::endl;
DistanceFileInfoMap& dfim = itr->second;
for(DistanceFileInfoMap::iterator ditr = dfim.begin();
ditr != dfim.end();
++ditr)
{
FileInfo& fileInfo = ditr->second;
notice()<<" d = "<<fileInfo.distance<<" "<<fileInfo.filename<<std::endl;
}
}
DistanceFileInfoMap& dfim = orientationFileInfoMap.begin()->second;
if (dfim.empty()) return 0;
double totalDistance = 0.0;
if (dfim.size()>1)
{
totalDistance = fabs(dfim.rbegin()->first - dfim.begin()->first);
}
else
{
totalDistance = dfim.begin()->second.sliceThickness * double(dfim.begin()->second.numSlices);
}
notice()<<"Total Distance including ends "<<totalDistance<<std::endl;
double averageThickness = totalNumSlices<=1 ? 1.0 : totalDistance / double(totalNumSlices-1);
notice()<<"Average thickness "<<averageThickness<<std::endl;
for(DistanceFileInfoMap::iterator ditr = dfim.begin();
ditr != dfim.end();
++ditr)
{
FileInfo& fileInfo = ditr->second;
std::auto_ptr<DicomImage> dcmImage(new DicomImage(fileInfo.filename.c_str()));
if (dcmImage.get())
{
if (dcmImage->getStatus()==EIS_Normal)
{
// get the pixel data
const DiPixel* pixelData = dcmImage->getInterData();
if(!pixelData)
{
warning()<<"Error: no data in DicomImage object."<<std::endl;
return ReadResult::ERROR_IN_READING_FILE;
}
osg::ref_ptr<osg::Image> imageAdapter = new osg::Image;
EP_Representation curr_pixelRep;
int curr_numPlanes;
GLenum curr_pixelFormat;
GLenum curr_dataType;
unsigned int curr_pixelSize;
// create the new image
convertPixelTypes(pixelData,
curr_pixelRep, curr_numPlanes,
curr_dataType, curr_pixelFormat, curr_pixelSize);
imageAdapter->setImage(dcmImage->getWidth(), dcmImage->getHeight(), dcmImage->getFrameCount(),
curr_pixelFormat,
curr_pixelFormat,
curr_dataType,
(unsigned char*)(pixelData->getData()),
osg::Image::NO_DELETE);
if (!image)
{
pixelRep = curr_pixelRep;
numPlanes = curr_numPlanes;
dataType = curr_dataType;
pixelFormat = curr_pixelFormat;
pixelSize = curr_pixelSize;
(*matrix)(0,0) = fileInfo.matrix(0,0);
(*matrix)(1,0) = fileInfo.matrix(1,0);
(*matrix)(2,0) = fileInfo.matrix(2,0);
(*matrix)(0,1) = fileInfo.matrix(0,1);
(*matrix)(1,1) = fileInfo.matrix(1,1);
(*matrix)(2,1) = fileInfo.matrix(2,1);
(*matrix)(0,2) = fileInfo.matrix(0,2) * averageThickness;
(*matrix)(1,2) = fileInfo.matrix(1,2) * averageThickness;
(*matrix)(2,2) = fileInfo.matrix(2,2) * averageThickness;
image = new osg::Image;
image->setUserData(matrix.get());
image->setFileName(fileName.c_str());
image->allocateImage(dcmImage->getWidth(), dcmImage->getHeight(), totalNumSlices,
pixelFormat, dataType);
matrix->preMult(osg::Matrix::scale(double(image->s()), double(image->t()), double(image->r())));
notice()<<"Image dimensions = "<<image->s()<<", "<<image->t()<<", "<<image->r()<<" pixelFormat=0x"<<std::hex<<pixelFormat<<" dataType=0x"<<std::hex<<dataType<<std::dec<<std::endl;
}
else if (pixelData->getPlanes()>numPlanes ||
pixelData->getRepresentation()>pixelRep)
{
notice()<<"Need to reallocated "<<image->s()<<", "<<image->t()<<", "<<image->r()<<std::endl;
// record the previous image settings to use when we copy back the content.
osg::ref_ptr<osg::Image> previous_image = image;
// create the new image
convertPixelTypes(pixelData,
pixelRep, numPlanes,
dataType, pixelFormat, pixelSize);
image = new osg::Image;
image->setUserData(previous_image->getUserData());
image->setFileName(fileName.c_str());
image->allocateImage(dcmImage->getWidth(), dcmImage->getHeight(), totalNumSlices,
pixelFormat, dataType);
osg::copyImage(previous_image.get(), 0,0,0, previous_image->s(), previous_image->t(), imageNum,
image.get(), 0, 0, 0,
false);
}
osg::copyImage(imageAdapter.get(), 0,0,0, imageAdapter->s(), imageAdapter->t(), imageAdapter->r(),
image.get(), 0, 0, imageNum,
false);
imageNum += dcmImage->getFrameCount();
}
else
{
warning()<<"Error in reading dicom file "<<fileName.c_str()<<", error = "<<DicomImage::getString(dcmImage->getStatus())<<std::endl;
}
}
}
if (!image)
{
return ReadResult::ERROR_IN_READING_FILE;
}
notice()<<"Spacing = "<<*matrix<<std::endl;
return image.get();
}
void ImageInstance::initImage(const QString &file)
{
DcmFileFormat dcmFile;
OFCondition result;
result = dcmFile.loadFile(file.toLocal8Bit());
DcmDataset *dset = dcmFile.getDataset();
if (result.good()) {
//patient information
const char *value = NULL;
result = dset->findAndGetString(DCM_PatientID, value);
patientID = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_PatientName, value);
patientName = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_PatientAge, value);
patientAge = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_PatientBirthDate, value);
patientBirth = QDate::fromString(QString::fromLocal8Bit(value),
DATE_DICOM_FORMAT);
result = dset->findAndGetString(DCM_PatientSex, value);
patientSex = QString::fromLocal8Bit(value);
//study information
result = dset->findAndGetString(DCM_StudyInstanceUID, value);
studyUid = QString::fromLatin1(value);
result = dset->findAndGetString(DCM_StudyDate, value);
studyTime.setDate(QDate::fromString(QString::fromLocal8Bit(value),
DATE_DICOM_FORMAT));
result = dset->findAndGetString(DCM_StudyTime, value);
studyTime.setTime(formatDicomTime(QString::fromLatin1(value)));
result = dset->findAndGetString(DCM_StudyDescription, value);
studyDes = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_ProtocolName, value);
procId = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_BodyPartExamined, value);
bodyPart = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_Manufacturer, value);
manufacturer = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_Modality, value);
modality = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_StationName, value);
stationName = QString::fromLocal8Bit(value);
//series information
result = dset->findAndGetString(DCM_SeriesInstanceUID, value);
seriesUid = QString::fromLatin1(value);
result = dset->findAndGetString(DCM_SeriesNumber, value);
seriesNumber = QString::fromLatin1(value);
result = dset->findAndGetString(DCM_SeriesDescription, value);
seriesDes = QString::fromLocal8Bit(value);
//instance information
result = dset->findAndGetString(DCM_SOPClassUID, value);
sopClassUid = QString::fromLatin1(value);
result = dset->findAndGetString(DCM_SOPInstanceUID, value);
instanceUid = QString::fromLatin1(value);
result = dset->findAndGetString(DCM_InstanceNumber, value);
instanceNumber = QString::fromLatin1(value);
result = dset->findAndGetString(DCM_InstitutionName, value);
institution = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_AcquisitionDate, value);
if (value==NULL) result = dset->findAndGetString(DCM_ContentDate, value);
acquisitionTime.setDate(QDate::fromString(QString::fromLatin1(value),
DATE_DICOM_FORMAT));
result = dset->findAndGetString(DCM_AcquisitionTime, value);
if (value==NULL) result = dset->findAndGetString(DCM_ContentTime, value);
acquisitionTime.setTime(formatDicomTime(QString::fromLatin1(value)));
result = dset->findAndGetString(DCM_PatientPosition, value);
patientPostion = QString::fromLatin1(value);
result = dset->findAndGetString(DCM_RequestingPhysician, value);
reqPhysician = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_PerformingPhysicianName, value);
perPhysician = QString::fromLocal8Bit(value);
result = dset->findAndGetString(DCM_AccessionNumber, value);
accessionNumber = QString::fromLatin1(value);
result = dset->findAndGetFloat64(DCM_PixelSpacing, pixelSpacingY, 0);
result = dset->findAndGetFloat64(DCM_PixelSpacing, pixelSpacingX, 1);
result = dset->findAndGetString(DCM_KVP, value);
kvp = QString::fromLatin1(value).toDouble();
result = dset->findAndGetString(DCM_Exposure, value);
mAs = QString::fromLatin1(value).toInt();
result = dset->findAndGetFloat64(DCM_WindowWidth, winWidth);
result = dset->findAndGetFloat64(DCM_WindowCenter, winCenter);
defCenter = winCenter;
defWidth = winWidth;
if (UID_DigitalXRayImageStorageForPresentation == sopClassUid) {
DcmItem *refItem;
const char *refImageUid;
dset->findAndGetSequenceItem(DCM_ReferencedImageSequence, refItem);
if (refItem && refItem->findAndGetString(DCM_ReferencedSOPInstanceUID, refImageUid).good()) {
QString dirName = file.left(file.lastIndexOf('/'));
rawFile = QString("%1/%2_%3.dcm").arg(dirName, RAW_IMAGE_PREFIX, refImageUid);
rawCenter = winCenter;
rawWidth = winWidth;
}
}
}
dcmImage = new DicomImage(dset, dset->getOriginalXfer());
if (dcmImage->getStatus() == EIS_Normal) {
//dcmImage->getWindow(winCenter, winWidth);
getPixmap(cachedPixmap);
}
}
bool Dicom::DicomReader::OpenDicoms(const std::list<std::string>& dcms)
{
if (m_pImageData)
{
//已经打开了数据
return false;
}
std::map<int,DcmFileFormat*> mapDcms;
int iMaxLayer = -1;
int iMinLayer = INT_MAX;
{
//获取图像数据
std::list<std::string>::const_iterator iter = dcms.begin();
while (iter != dcms.end())
{
DcmFileFormat* pDcmFile = new DcmFileFormat();
OFCondition cond = pDcmFile->loadFile(iter->c_str());
if (cond.bad())
{
delete pDcmFile;
++iter;
continue;
}
DcmDataset* pDataset = pDcmFile->getDataset();
Uint16 iC = 0, iR = 0, iB = 0;
pDataset->findAndGetUint16(DCM_Columns, iC);
pDataset->findAndGetUint16(DCM_Rows, iR);
pDataset->findAndGetUint16(DCM_BitsAllocated, iB);
if (mapDcms.size()<1)
{
m_iColumns = iC;
m_iRows = iR;
m_iBits = iB;
}
if (iC != m_iColumns || iR != m_iRows || iB != m_iBits)
{
delete pDcmFile;
++iter;
continue;
}
Sint32 iL = -1;
pDataset->findAndGetSint32(DCM_InstanceNumber, iL);
if (iL>-1 && mapDcms.find(iL) == mapDcms.end())
{
mapDcms[iL] = pDcmFile;
if (iL > iMaxLayer)
iMaxLayer = iL;
if (iL < iMinLayer)
iMinLayer = iL;
}
else
{
delete pDcmFile;
}
++iter;
}
if (m_iBits != 16)
return false;
}
//总层数
m_iLayers = iMaxLayer-iMinLayer+1;
m_pImageData = new Image::ImageData<short>(m_iRows, m_iColumns, m_iLayers);
Image::ImageData<short>* pImageShort = reinterpret_cast<Image::ImageData<short>*>(m_pImageData);
char* pDataPtr = m_pImageData->GetDataPtr();
{
//设置图像数据
std::map<int, DcmFileFormat*>::iterator iter = mapDcms.begin();
while (iter != mapDcms.end())
{
DcmFileFormat* pDcmFile = iter->second;
DcmDataset* pDataSet = pDcmFile->getDataset();
{
const Uint16* pSrcData = NULL;
unsigned long iCount = 0;
pDataSet->findAndGetUint16Array(DCM_PixelData, pSrcData, &iCount);
if (iCount == pImageShort->GetX()*pImageShort->GetY())
{
memcpy(pDataPtr+(iCount*2*(iter->first-iMinLayer)), pSrcData, iCount * 2);
}
else
{
assert("Read dicom error!");
}
}
delete pDcmFile;
++iter;
}
mapDcms.clear();
}
m_pImageData->UpdateData();
return true;
}
std::vector<BaseData::Pointer> DICOMSegmentationIO::Read()
{
mitk::LocaleSwitch localeSwitch("C");
LabelSetImage::Pointer labelSetImage;
std::vector<BaseData::Pointer> result;
const std::string path = this->GetLocalFileName();
MITK_INFO << "loading " << path << std::endl;
if (path.empty())
mitkThrow() << "Empty filename in mitk::ItkImageIO ";
try
{
// Get the dcm data set from file path
DcmFileFormat dcmFileFormat;
OFCondition status = dcmFileFormat.loadFile(path.c_str());
if (status.bad())
mitkThrow() << "Can't read the input file!";
DcmDataset *dataSet = dcmFileFormat.getDataset();
if (dataSet == nullptr)
mitkThrow() << "Can't read data from input file!";
// Read the DICOM SEG images (segItkImages) and DICOM tags (metaInfo)
dcmqi::ImageSEGConverter *converter = new dcmqi::ImageSEGConverter();
pair<map<unsigned, ImageType::Pointer>, string> dcmqiOutput = converter->dcmSegmentation2itkimage(dataSet);
map<unsigned, ImageType::Pointer> segItkImages = dcmqiOutput.first;
// For each itk image add a layer to the LabelSetImage output
for (auto &element : segItkImages)
{
// Get the labeled image and cast it to mitkImage
typedef itk::CastImageFilter<itkInternalImageType, itkInputImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(element.second);
castFilter->Update();
Image::Pointer layerImage;
CastToMitkImage(castFilter->GetOutput(), layerImage);
// Get pixel value of the label
itkInternalImageType::ValueType segValue = 1;
typedef itk::ImageRegionIterator<const itkInternalImageType> IteratorType;
// Iterate over the image to find the pixel value of the label
IteratorType iter(element.second, element.second->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
itkInputImageType::PixelType value = iter.Get();
if (value != 0)
{
segValue = value;
break;
}
++iter;
}
dcmqi::JSONSegmentationMetaInformationHandler metaInfo(dcmqiOutput.second.c_str());
metaInfo.read();
MITK_INFO << "Input " << metaInfo.getJSONOutputAsString();
// TODO: Read all DICOM Tags
// Get the label information from segment attributes
vector<map<unsigned, dcmqi::SegmentAttributes *>>::const_iterator segmentIter =
metaInfo.segmentsAttributesMappingList.begin();
map<unsigned, dcmqi::SegmentAttributes *> segmentMap = (*segmentIter);
map<unsigned, dcmqi::SegmentAttributes *>::const_iterator segmentMapIter = (*segmentIter).begin();
dcmqi::SegmentAttributes *segmentAttr = (*segmentMapIter).second;
OFString labelName;
if (segmentAttr->getSegmentedPropertyTypeCodeSequence() != nullptr)
segmentAttr->getSegmentedPropertyTypeCodeSequence()->getCodeMeaning(labelName);
else
{
labelName = std::to_string(segmentAttr->getLabelID()).c_str();
if (labelName.empty())
labelName = "Unnamed";
}
float tmp[3] = {0.0, 0.0, 0.0};
if (segmentAttr->getRecommendedDisplayRGBValue() != nullptr)
{
tmp[0] = segmentAttr->getRecommendedDisplayRGBValue()[0] / 255.0;
tmp[1] = segmentAttr->getRecommendedDisplayRGBValue()[1] / 255.0;
tmp[2] = segmentAttr->getRecommendedDisplayRGBValue()[2] / 255.0;
}
// If labelSetImage do not exists (first image)
if (labelSetImage.IsNull())
{
// Initialize the labelSetImage with the read image
labelSetImage = LabelSetImage::New();
labelSetImage->InitializeByLabeledImage(layerImage);
// Already a label was generated, so set the information to this
Label *activeLabel = labelSetImage->GetActiveLabel(labelSetImage->GetActiveLayer());
activeLabel->SetName(labelName.c_str());
activeLabel->SetColor(Color(tmp));
activeLabel->SetValue(segValue);
}
else
{
// Add a new layer to the labelSetImage. Background label is set automatically
labelSetImage->AddLayer(layerImage);
// Add new label
Label *newLabel = new Label;
newLabel->SetName(labelName.c_str());
newLabel->SetColor(Color(tmp));
newLabel->SetValue(segValue);
labelSetImage->GetLabelSet(labelSetImage->GetActiveLayer())->AddLabel(newLabel);
}
++segmentIter;
}
// Clean up
if (converter != nullptr)
delete converter;
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while reading the DICOM Seg file: " << e.what();
return result;
}
// Set active layer to th first layer of the labelset image
if (labelSetImage->GetNumberOfLayers() > 1 && labelSetImage->GetActiveLayer() != 0)
labelSetImage->SetActiveLayer(0);
result.push_back(labelSetImage.GetPointer());
return result;
}
/* Helper function to write a DICOM file using C++ */
static int write_dcm_cpp(const char *path, const Image *const im,
const Dcm_meta *const meta, const float max_val) {
#define BUF_LEN 1024
char buf[BUF_LEN];
// Ensure the image is monochromatic
if (im->nc != 1) {
SIFT3D_ERR("write_dcm_cpp: image %s has %d channels. "
"Currently only signle-channel images are supported.\n",
path, im->nc);
return SIFT3D_FAILURE;
}
// If no metadata was provided, initialize default metadata
Dcm_meta meta_new;
set_meta_defaults(meta, &meta_new);
// Create a new fileformat object
DcmFileFormat fileFormat;
// Set the file type to derived
DcmDataset *const dataset = fileFormat.getDataset();
OFCondition status = dataset->putAndInsertString(DCM_ImageType,
"DERIVED");
if (status.bad()) {
std::cerr << "write_dcm_cpp: Failed to set the image type" <<
std::endl;
return SIFT3D_FAILURE;
}
// Set the class UID
dataset->putAndInsertString(DCM_SOPClassUID,
UID_CTImageStorage);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the SOPClassUID\n");
return SIFT3D_FAILURE;
}
// Set the photometric interpretation
const char *photoInterp;
if (im->nc == 1) {
photoInterp = "MONOCHROME2";
} else if (im->nc == 3) {
photoInterp = "RGB";
} else {
SIFT3D_ERR("write_dcm_cpp: failed to determine the "
"photometric representation for %d channels \n",
im->nc);
return SIFT3D_FAILURE;
}
dataset->putAndInsertString(DCM_PhotometricInterpretation,
photoInterp);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the photometric "
"interpretation \n");
return SIFT3D_FAILURE;
}
// Set the pixel representation to unsigned
dataset->putAndInsertUint16(DCM_PixelRepresentation, 0);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the pixel "
"representation \n");
return SIFT3D_FAILURE;
}
// Set the number of channels (Samples Per Pixel) and set the planar
// configuration to interlaced pixels
assert(SIFT3D_IM_GET_IDX(im, 0, 0, 0, 1) ==
SIFT3D_IM_GET_IDX(im, 0, 0, 0, 0) + 1);
snprintf(buf, BUF_LEN, "%d", im->nc);
dataset->putAndInsertString(DCM_SamplesPerPixel, buf);
dataset->putAndInsertString(DCM_PlanarConfiguration, "0");
// Set the bits allocated and stored, in big endian format
const unsigned int dcm_high_bit = dcm_bit_width - 1;
dataset->putAndInsertUint16(DCM_BitsAllocated, dcm_bit_width);
dataset->putAndInsertUint16(DCM_BitsStored, dcm_bit_width);
dataset->putAndInsertUint16(DCM_HighBit, dcm_high_bit);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the bit widths \n");
return SIFT3D_FAILURE;
}
// Set the patient name
status = dataset->putAndInsertString(DCM_PatientName,
meta_new.patient_name);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the patient name\n");
return SIFT3D_FAILURE;
}
// Set the patient ID
status = dataset->putAndInsertString(DCM_PatientID,
meta_new.patient_id);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the patient ID \n");
return SIFT3D_FAILURE;
}
// Set the study UID
status = dataset->putAndInsertString(DCM_StudyInstanceUID,
meta_new.study_uid);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the "
"StudyInstanceUID \n");
return SIFT3D_FAILURE;
}
// Set the series UID
status = dataset->putAndInsertString(DCM_SeriesInstanceUID,
meta_new.series_uid);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the "
"SeriesInstanceUID \n");
return SIFT3D_FAILURE;
}
// Set the series description
status = dataset->putAndInsertString(DCM_SeriesDescription,
meta_new.series_descrip);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the series "
"description \n");
return SIFT3D_FAILURE;
}
// Set the instance UID
status = dataset->putAndInsertString(DCM_SOPInstanceUID,
meta_new.instance_uid);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: failed to set the "
"SOPInstanceUID \n");
return SIFT3D_FAILURE;
}
// Set the dimensions
OFCondition xstatus = dataset->putAndInsertUint16(DCM_Rows, im->ny);
OFCondition ystatus = dataset->putAndInsertUint16(DCM_Columns, im->nx);
snprintf(buf, BUF_LEN, "%d", im->nz);
OFCondition zstatus = dataset->putAndInsertString(DCM_NumberOfFrames,
buf);
if (xstatus.bad() || ystatus.bad() || zstatus.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the dimensions \n");
return SIFT3D_FAILURE;
}
// Set the instance number
snprintf(buf, BUF_LEN, "%u", meta_new.instance_num);
status = dataset->putAndInsertString(DCM_InstanceNumber, buf);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the instance "
"number \n");
return SIFT3D_FAILURE;
}
// Set the ImagePositionPatient vector
const double imPosX = static_cast<double>(im->nx - 1) * im->ux;
const double imPosY = static_cast<double>(im->ny - 1) * im->uy;
const double imPosZ = static_cast<double>(meta_new.instance_num) *
im->uz;
snprintf(buf, BUF_LEN, "%f\\%f\\%f", imPosX, imPosY, imPosZ);
status = dataset->putAndInsertString(DCM_ImagePositionPatient, buf);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the "
"ImagePositionPatient vector \n");
return SIFT3D_FAILURE;
}
// Set the slice location
snprintf(buf, BUF_LEN, "%f", imPosZ);
status = dataset->putAndInsertString(DCM_SliceLocation, buf);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the slice "
"location \n");
return SIFT3D_FAILURE;
}
// Set the pixel spacing
snprintf(buf, BUF_LEN, "%f\\%f", im->ux, im->uy);
status = dataset->putAndInsertString(DCM_PixelSpacing, buf);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the pixel "
"spacing \n");
return SIFT3D_FAILURE;
}
// Set the aspect ratio
snprintf(buf, BUF_LEN, "%f\\%f", im->ux, im->uy);
status = dataset->putAndInsertString(DCM_PixelAspectRatio, buf);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the pixel aspect "
"aspect ratio \n");
return SIFT3D_FAILURE;
}
// Set the slice thickness
snprintf(buf, BUF_LEN, "%f", im->uz);
status = dataset->putAndInsertString(DCM_SliceThickness, buf);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: Failed to set the slice "
"thickness \n");
return SIFT3D_FAILURE;
}
// Count the number of pixels in the image
unsigned long numPixels = im->dims[0];
for (int i = 1; i < IM_NDIMS; i++) {
numPixels *= im->dims[i];
}
// Get the image scaling factor
const float dcm_max_val = static_cast<float>(1 << dcm_bit_width) - 1.0f;
const float im_max = max_val < 0.0f ? im_max_abs(im) : max_val;
const float scale = im_max == 0.0f ? 1.0f : dcm_max_val / im_max;
// Render the data to an 8-bit unsigned integer array
assert(dcm_bit_width == 8);
assert(fabsf(dcm_max_val - 255.0f) < FLT_EPSILON);
uint8_t *pixelData = new uint8_t[numPixels];
int x, y, z, c;
SIFT3D_IM_LOOP_START_C(im, x, y, z, c)
const float vox = SIFT3D_IM_GET_VOX(im, x, y, z, c);
if (vox < 0.0f) {
SIFT3D_ERR("write_dcm_cpp: Image cannot be "
"negative \n");
return SIFT3D_FAILURE;
}
pixelData[c + x + y * im->nx + z * im->nx * im->ny] =
static_cast<uint8_t>(vox * scale);
SIFT3D_IM_LOOP_END_C
// Write the data
status = dataset->putAndInsertUint8Array(DCM_PixelData, pixelData,
numPixels);
delete[] pixelData;
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: failed to set the pixel data \n");
return SIFT3D_FAILURE;
}
// Choose the encoding format
#if 0
DJEncoderRegistration::registerCodecs();
const E_TransferSyntax xfer = EXS_JPEGProcess14SV1TransferSyntax;
DJ_RPLossless rp_lossless;
status = dataset->chooseRepresentation(xfer, &rp_lossless);
#else
const E_TransferSyntax xfer = EXS_LittleEndianExplicit;
dataset->chooseRepresentation(xfer, NULL);
#endif
if (!dataset->canWriteXfer(xfer)) {
SIFT3D_ERR("write_dcm_cpp: Failed to choose the encoding "
"format \n");
return SIFT3D_FAILURE;
}
// Force the media storage UIDs to be re-generated by removing them
dataset->remove(DCM_MediaStorageSOPClassUID);
dataset->remove(DCM_MediaStorageSOPInstanceUID);
// Save the file
status = fileFormat.saveFile(path, xfer);
if (status.bad()) {
SIFT3D_ERR("write_dcm_cpp: failed to write file %s (%s) \n",
path, status.text());
return SIFT3D_FAILURE;
}
return SIFT3D_SUCCESS;
#undef BUF_LEN
}
/* Load the data from a DICOM file */
Dicom::Dicom(std::string path) : filename(path), valid(false) {
// Load the image as a DcmFileFormat
DcmFileFormat fileFormat;
OFCondition status = fileFormat.loadFile(path.c_str());
if (status.bad()) {
SIFT3D_ERR("Dicom.Dicom: failed to read DICOM file %s (%s)\n",
path.c_str(), status.text());
return;
}
// Get the dataset
DcmDataset *const data = fileFormat.getDataset();
// Get the series UID
const char *seriesUIDStr;
status = data->findAndGetString(DCM_SeriesInstanceUID, seriesUIDStr);
if (status.bad() || seriesUIDStr == NULL) {
SIFT3D_ERR("Dicom.Dicom: failed to get SeriesInstanceUID "
"from file %s (%s)\n", path.c_str(), status.text());
return;
}
seriesUID = std::string(seriesUIDStr);
#if 0
// Read the patient position
const char *patientPosStr;
status = data->findAndGetString(DCM_PatientPosition, patientPosStr);
if (status.bad() || patientPosStr == NULL) {
std::cerr << "Dicom.Dicom: failed to get PatientPosition " <<
"from file " << path << " (" << status.text() << ")" <<
std::endl;
return;
}
// Interpret the patient position to give the sign of the z axis
double zSign;
switch (patientPosStr[0]) {
case 'H':
zSign = -1.0;
break;
case 'F':
zSign = 1.0;
break;
default:
std::cerr << "Dicom.Dicom: unrecognized patient position: " <<
patientPosStr << std::endl;
return;
}
#else
//TODO: Is this needed?
const double zSign = 1.0;
#endif
// Read the image position patient vector
const char *imPosPatientStr;
status = data->findAndGetString(DCM_ImagePositionPatient,
imPosPatientStr);
if (status.bad() || imPosPatientStr == NULL) {
SIFT3D_ERR("Dicom.Dicom: failed to get ImagePositionPatient "
"from file %s (%s)\n", path.c_str(), status.text());
return;
}
// Parse the image position patient vector to get the z coordinate
double imPosZ;
if (sscanf(imPosPatientStr, "%*f\\%*f\\%lf", &imPosZ) != 1) {
SIFT3D_ERR("Dicom.Dicom: failed to parse "
"ImagePositionPatient tag %s from file %s\n",
imPosPatientStr, path.c_str());
return;
}
// Compute the z-location of the upper-left corner, in feet-first
// coordinates
z = zSign * imPosZ;
// Load the DicomImage object
DicomImage dicomImage(path.c_str());
if (dicomImage.getStatus() != EIS_Normal) {
SIFT3D_ERR("Dicom.Dicom: failed to open image %s (%s)\n",
path.c_str(),
DicomImage::getString(dicomImage.getStatus()));
return;
}
// Check for color images
if (!dicomImage.isMonochrome()) {
SIFT3D_ERR("Dicom.Dicom: reading of color DICOM images is "
"not supported at this time \n");
return;
}
nc = 1;
// Read the dimensions
nx = dicomImage.getWidth();
ny = dicomImage.getHeight();
nz = dicomImage.getFrameCount();
if (nx < 1 || ny < 1 || nz < 1) {
SIFT3D_ERR("Dicom.Dicom: invalid dimensions for file %s "
"(%d, %d, %d)\n", path.c_str(), nx, ny, nz);
return;
}
// Read the pixel spacing
const char *pixelSpacingStr;
status = data->findAndGetString(DCM_PixelSpacing, pixelSpacingStr);
if (status.bad()) {
SIFT3D_ERR("Dicom.Dicom: failed to get pixel spacing from "
"file %s (%s)\n", path.c_str(), status.text());
return;
}
if (sscanf(pixelSpacingStr, "%lf\\%lf", &ux, &uy) != 2) {
SIFT3D_ERR("Dicom.Dicom: unable to parse pixel spacing from "
"file %s \n", path.c_str());
return;
}
if (ux <= 0.0 || uy <= 0.0) {
SIFT3D_ERR("Dicom.Dicom: file %s has invalid pixel spacing "
"[%f, %f]\n", path.c_str(), ux, uy);
return;
}
// Read the slice thickness
Float64 sliceThickness;
status = data->findAndGetFloat64(DCM_SliceThickness, sliceThickness);
if (!status.good()) {
SIFT3D_ERR("Dicom.Dicom: failed to get slice thickness from "
"file %s (%s)\n", path.c_str(), status.text());
return;
}
// Convert to double
uz = sliceThickness;
if (uz <= 0.0) {
SIFT3D_ERR("Dicom.Dicom: file %s has invalid slice "
"thickness: %f \n", path.c_str(), uz);
return;
}
// Set the window
dicomImage.setMinMaxWindow();
valid = true;
}
void mitk::DICOMDCMTKTagScanner::Scan()
{
this->PushLocale();
try
{
DcmPathProcessor processor;
processor.setItemWildcardSupport(true);
DICOMGenericTagCache::Pointer newCache = DICOMGenericTagCache::New();
for (const auto& fileName : this->m_InputFilenames)
{
DcmFileFormat dfile;
OFCondition cond = dfile.loadFile(fileName.c_str());
if (cond.bad())
{
MITK_ERROR << "Error when scanning for tags. Cannot open given file. File: " << fileName;
}
else
{
DICOMGenericImageFrameInfo::Pointer info = DICOMGenericImageFrameInfo::New(fileName);
for (const auto& path : this->m_ScannedTags)
{
std::string tagPath = DICOMTagPathToDCMTKSearchPath(path);
cond = processor.findOrCreatePath(dfile.getDataset(), tagPath.c_str());
if (cond.good())
{
OFList< DcmPath * > findings;
processor.getResults(findings);
for (const auto& finding : findings)
{
auto element = dynamic_cast<DcmElement*>(finding->back()->m_obj);
if (!element)
{
auto item = dynamic_cast<DcmItem*>(finding->back()->m_obj);
if (item)
{
element = item->getElement(finding->back()->m_itemNo);
}
}
if (element)
{
OFString value;
cond = element->getOFStringArray(value);
if (cond.good())
{
info->SetTagValue(DcmPathToTagPath(finding), std::string(value.c_str()));
}
}
}
}
}
newCache->AddFrameInfo(info);
}
}
m_Cache = newCache;
this->PopLocale();
}
catch (...)
{
this->PopLocale();
throw;
}
}
void SortDcmFile::sortFile(const char url[])
{
QDir *dir=new QDir(url);
QStringList filter;
DcmFileFormat fileformat;
OFString tempinfo;
QString FileAddress = QString(url);
//如果重名
SortDcmFile::changName(url);
//获取目录下所有文件名（含两个目录名）
QList<QFileInfo> *fileInfo=new QList<QFileInfo>(dir->entryInfoList(filter));
QList<dicomInfo> sortInfo;
//获取dicom信息
for(int i = 2 ; i < fileInfo->count() ; ++i)
{
dicomInfo temp;
temp.filename = fileInfo->at(i).fileName();
QByteArray ba = fileInfo->at(i).filePath().toLatin1();
char *url = ba.data();
OFCondition os=fileformat.loadFile(url);
if(os.good())
{
if((fileformat.getDataset()->findAndGetOFString(DcmTagKey(0x0020,0x0013),tempinfo)).good())
{
temp.imageID=tempinfo;
//cout<<temp.imageID<<endl;
}else
{
cout<<"No Find"<<endl;
}
if(fileformat.getDataset()->findAndGetOFString(DcmTagKey(0x0020,0x1041),tempinfo).good())
{
temp.sliceLocation=OFtoSignal(tempinfo);
}else
{
cout<<"No Find"<<endl;
}
sortInfo.push_back(temp);
}
}
sort(sortInfo.begin(),sortInfo.end(),cmp);
QList<dicomInfo>::iterator it;
//分组
double tempbef=9999;
int group=0;
int group_number=-1;
//QList<dicomInfo>::iterator it;
for(it=sortInfo.begin();it!=sortInfo.end();it++)
{
if(it->sliceLocation>tempbef)
{
group++;
SortDcmFile::Pslice = group_number+1;
group_number=0;
tempbef=9999;
}else
{
tempbef=it->sliceLocation;
group_number++;
}
SortDcmFile::PsetNum = group+1;
QFile::rename( FileAddress+it->filename ,FileAddress+"IM"+QString::fromStdString(itos(group))+"-"+QString::fromStdString(itos(group_number)));
}
}
int gendicom(const char* file_name, const std::vector<float> &data,
unsigned int rows, unsigned int cols)
{
char uid[100];
DcmFileFormat fileformat;
DcmDataset *dataset = fileformat.getDataset();
OFCondition result = EC_Normal;
if (result.good()) result = dataset->putAndInsertString(DCM_SOPClassUID, UID_SecondaryCaptureImageStorage);
//if (result.good()) result = dataset->putAndInsertString(DCM_MediaStorageSOPClassUID, UID_SecondaryCaptureImageStorage); //same as SOP
if (result.good()) result = dataset->putAndInsertString(DCM_SOPInstanceUID, dcmGenerateUniqueIdentifier(uid, SITE_INSTANCE_UID_ROOT));
//if (result.good()) result = dataset->putAndInsertString(DCM_MediaStorageSOPInstanceUID, dcmGenerateUniqueIdentifier(uid, SITE_INSTANCE_UID_ROOT));
if (result.good()) result = dataset->putAndInsertString(DCM_SeriesInstanceUID, dcmGenerateUniqueIdentifier(uid, SITE_INSTANCE_UID_ROOT));
if (result.good()) result = dataset->putAndInsertString(DCM_StudyInstanceUID, dcmGenerateUniqueIdentifier(uid, SITE_INSTANCE_UID_ROOT));
//if (result.good()) result = dataset->putAndInsertString(DCM_TransferSyntaxUID, UID_LittleEndianExplicitTransferSyntax);
//if (result.good()) result = dataset->putAndInsertUint16(DCM_FileMetaInformationVersion, 1);
if (result.good()) result = dataset->putAndInsertString(DCM_ImageType, "DERIVED");
if (result.good()) result = dataset->putAndInsertString(DCM_Modality, "MR");
if (result.good()) result = dataset->putAndInsertString(DCM_ConversionType, "WSD");
if (result.good()) result = dataset->putAndInsertString(DCM_DerivationDescription, "IRGN Processed MR Reconstruction");
if (result.good()) result = dataset->putAndInsertString(DCM_SecondaryCaptureDeviceManufacturer, "IMT TUGRAZ");
if (result.good()) result = dataset->putAndInsertString(DCM_SecondaryCaptureDeviceManufacturerModelName, "IMT Cuda Workstation");
if (result.good()) result = dataset->putAndInsertString(DCM_PatientName, "Doe^John");
// set instance creation date and time
OFString s;
if (result.good()) result = DcmDate::getCurrentDate(s);
if (result.good()) result = dataset->putAndInsertOFStringArray(DCM_InstanceCreationDate, s);
if (result.good()) result = DcmTime::getCurrentTime(s);
if (result.good()) result = dataset->putAndInsertOFStringArray(DCM_InstanceCreationTime, s);
//--- Write image-data ---
std::vector<Uint16> uint16_data;
float val=0;
float min_val;
float max_val = *std::max_element(data.begin(),data.end());
for(unsigned int i=0; i<data.size(); ++i)
{
val = (data[i]/max_val)*65535;
uint16_data.push_back(Uint16(val));
}
max_val = *std::max_element(uint16_data.begin(),uint16_data.end());
min_val = *std::min_element(uint16_data.begin(),uint16_data.end());
std::cout<<"\n max-val: "<<max_val;
std::cout<<"\n min-val: "<<min_val;
unsigned bits=16;
Uint16 bitsAllocated=((bits-1)/8+1)*8;
Uint16 bitsStored=bits;
Uint16 highBit=bits-1;
if (result.good()) result = dataset->putAndInsertUint16(DCM_BitsAllocated, bitsAllocated);
if (result.good()) result = dataset->putAndInsertUint16(DCM_BitsStored, bitsStored);
if (result.good()) result = dataset->putAndInsertUint16(DCM_HighBit, highBit);
if (result.good()) result = dataset->putAndInsertUint16(DCM_Rows, rows);
if (result.good()) result = dataset->putAndInsertUint16(DCM_Columns, cols);
if (result.good()) result = dataset->putAndInsertUint16(DCM_PixelRepresentation, 0); // 1 signed, 0 unsigned
if (result.good()) result = dataset->putAndInsertOFStringArray(DCM_PhotometricInterpretation, "MONOCHROME2");
if (result.good()) result = dataset->putAndInsertUint16(DCM_SamplesPerPixel, 1);
if (result.good()) result = dataset->putAndInsertUint16(DCM_SmallestImagePixelValue, min_val);
if (result.good()) result = dataset->putAndInsertUint16(DCM_LargestImagePixelValue, max_val);
Uint8* pixelData = (Uint8*)&uint16_data[0];
Uint32 pixelLength;
pixelLength = uint16_data.size()*2; //number of elements in vector * 2bytes (for Uint16)
dataset->putAndInsertUint8Array(DCM_PixelData, pixelData, pixelLength);
OFCondition status = fileformat.saveFile(file_name, EXS_LittleEndianExplicit);
if (result.bad())
std::cerr << "Error: cannot write DICOM file (" << result.text() << ")" << std::endl;
if (status.bad())
std::cerr << "Error: cannot write DICOM file (" << status.text() << ")" << std::endl;
return 0;
}
void QtDcmManager::makePreview ( const QString &filename )
{
DcmRLEDecoderRegistration::registerCodecs ( OFFalse, OFFalse );
DJDecoderRegistration::registerCodecs ( EDC_photometricInterpretation, EUC_default, EPC_default, OFFalse );
DcmFileFormat file;
file.loadFile ( filename.toLatin1().data() );
DcmDataset * dset = file.getDataset();
DicomImage* dcimage = new DicomImage ( dset, file.getDataset()->getOriginalXfer(), CIF_MayDetachPixelData );
if ( dcimage != NULL ) {
dcimage->setNoDisplayFunction();
dcimage->hideAllOverlays();
dcimage->setNoVoiTransformation();
if ( dcimage->getStatus() == EIS_Normal ) {
Uint32 *pixelData = ( Uint32 * ) ( dcimage->getOutputData ( 32 /* bits per sample */ ) );
if ( pixelData != NULL ) {
Uint8 *colored = new Uint8[dcimage->getWidth() * dcimage->getHeight() * 4]; //4 * dcimage->getWidth() * dcimage->getHeight() matrix
Uint8 *col = colored;
Uint32 *p = pixelData;
//get the highest values for RGBA, then use them to scale the pixel luminosity
Uint32 p_max = 0;
#ifdef WIN32
Uint32 p_min = UINT_LEAST32_MAX;
#else
Uint32 p_min = std::numeric_limits<Uint32>::max();
#endif
for ( unsigned i = 0; i < dcimage->getWidth(); ++i ) {
for ( unsigned j = 0; j < dcimage->getHeight(); ++j, ++p ) {
if ( *p > p_max ) {
p_max = *p;
}
if ( *p < p_min ) {
p_min = *p;
}
}
}
double a = 4294967295.f / ( ( double ) p_max - ( double ) p_min );
//re-initialize 'col'
p = pixelData;
//copy the pixels in our QImage
for ( unsigned i = 0; i < dcimage->getWidth(); ++i ) {
for ( unsigned j = 0; j < dcimage->getHeight(); ++j, ++p ) {
*col = ( Uint8 ) ( ( 255.f / 4294967295.f ) * ( a * ( ( double ) ( *p ) - ( double ) p_min ) ) );
++col;
*col = ( Uint8 ) ( ( 255.f / 4294967295.f ) * ( a * ( ( double ) ( *p ) - ( double ) p_min ) ) );
++col;
*col = ( Uint8 ) ( ( 255.f / 4294967295.f ) * ( a * ( ( double ) ( *p ) - ( double ) p_min ) ) );
++col;
*col = 255;
++col;
}
}
QImage image ( colored, dcimage->getWidth(), dcimage->getHeight(), QImage::Format_ARGB32 );
if ( d->previewWidget ) {
d->previewWidget->imageLabel->setPixmap ( QPixmap::fromImage ( image.scaled ( 130,130 ), Qt::AutoColor ) );
}
delete[] colored;
}
}
delete dcimage;
}
DcmRLEDecoderRegistration::cleanup();
DJDecoderRegistration::cleanup();
}
bool CreateResource(DcmDirectoryRecord*& target,
ResourceType level,
DcmFileFormat& dicom,
const char* filename,
const char* path)
{
DcmDataset& dataset = *dicom.getDataset();
OFCondition result;
OFString id;
E_DirRecType type;
switch (level)
{
case ResourceType_Patient:
result = dataset.findAndGetOFString(DCM_PatientID, id);
type = ERT_Patient;
break;
case ResourceType_Study:
result = dataset.findAndGetOFString(DCM_StudyInstanceUID, id);
type = ERT_Study;
break;
case ResourceType_Series:
result = dataset.findAndGetOFString(DCM_SeriesInstanceUID, id);
type = ERT_Series;
break;
case ResourceType_Instance:
result = dataset.findAndGetOFString(DCM_SOPInstanceUID, id);
type = ERT_Image;
break;
default:
throw OrthancException(ErrorCode_InternalError);
}
if (!result.good())
{
throw OrthancException(ErrorCode_InternalError);
}
IndexKey key = std::make_pair(level, std::string(id.c_str()));
Index::iterator it = index_.find(key);
if (it != index_.end())
{
target = it->second;
return false; // Already existing
}
std::auto_ptr<DcmDirectoryRecord> record(new DcmDirectoryRecord(type, NULL, filename));
switch (level)
{
case ResourceType_Patient:
FillPatient(*record, dataset);
break;
case ResourceType_Study:
FillStudy(*record, dataset);
break;
case ResourceType_Series:
FillSeries(*record, dataset);
break;
case ResourceType_Instance:
FillInstance(*record, dataset, *dicom.getMetaInfo(), path);
break;
default:
throw OrthancException(ErrorCode_InternalError);
}
if (record->isAffectedBySpecificCharacterSet())
{
copyElementType1C(dataset, DCM_SpecificCharacterSet, *record);
}
target = record.get();
GetRoot().insertSub(record.release());
index_[key] = target;
return true; // Newly created
}
