// -------------------------------------------------------------------------
void ctkDICOMDatasetViewPrivate::setImage(const QModelIndex &imageIndex, bool defaultIntensity){
Q_Q(ctkDICOMDatasetView);
ctkDICOMModel* model = const_cast<ctkDICOMModel*>(qobject_cast<const ctkDICOMModel*>(imageIndex.model()));
if(model){
QModelIndex seriesIndex = imageIndex.parent();
QModelIndex studyIndex = seriesIndex.parent();
QString dicomPath = this->DatabaseDirectory;
dicomPath.append("/dicom/").append(model->data(studyIndex ,ctkDICOMModel::UIDRole).toString());
dicomPath.append("/").append(model->data(seriesIndex ,ctkDICOMModel::UIDRole).toString());
dicomPath.append("/").append(model->data(imageIndex ,ctkDICOMModel::UIDRole).toString());
if (QFile(dicomPath).exists()){
DicomImage dcmImage( QDir::toNativeSeparators(dicomPath).toStdString().c_str() );
q->clearImages();
q->addImage(dcmImage, defaultIntensity);
this->CurrentImageIndex = imageIndex;
q->emitImageDisplayedSignal(imageIndex.row(), model->rowCount(seriesIndex));
}else{
q->clearImages();
}
}
}
//------------------------------------------------------------------------------
void ctkDICOMDatabase::insert ( DcmDataset *dataset, bool storeFile, bool generateThumbnail)
{
Q_D(ctkDICOMDatabase);
if (!dataset)
{
return;
}
// Check to see if the file has already been loaded
OFString sopInstanceUID ;
dataset->findAndGetOFString(DCM_SOPInstanceUID, sopInstanceUID);
QSqlQuery fileExists ( d->Database );
fileExists.prepare("SELECT InsertTimestamp,Filename FROM Images WHERE SOPInstanceUID == ?");
fileExists.bindValue(0,QString(sopInstanceUID.c_str()));
fileExists.exec();
if ( fileExists.next() && QFileInfo(fileExists.value(1).toString()).lastModified() < QDateTime::fromString(fileExists.value(0).toString(),Qt::ISODate) )
{
logger.debug ( "File " + fileExists.value(1).toString() + " already added" );
return;
}
OFString patientsName, patientID, patientsBirthDate, patientsBirthTime, patientsSex,
patientComments, patientsAge;
OFString studyInstanceUID, studyID, studyDate, studyTime,
accessionNumber, modalitiesInStudy, institutionName, performingPhysiciansName, referringPhysician, studyDescription;
OFString seriesInstanceUID, seriesDate, seriesTime,
seriesDescription, bodyPartExamined, frameOfReferenceUID,
contrastAgent, scanningSequence;
OFString instanceNumber;
Sint32 seriesNumber = 0, acquisitionNumber = 0, echoNumber = 0, temporalPosition = 0;
//If the following fields can not be evaluated, cancel evaluation of the DICOM file
dataset->findAndGetOFString(DCM_PatientName, patientsName);
dataset->findAndGetOFString(DCM_StudyInstanceUID, studyInstanceUID);
dataset->findAndGetOFString(DCM_SeriesInstanceUID, seriesInstanceUID);
dataset->findAndGetOFString(DCM_PatientID, patientID);
dataset->findAndGetOFString(DCM_PatientBirthDate, patientsBirthDate);
dataset->findAndGetOFString(DCM_PatientBirthTime, patientsBirthTime);
dataset->findAndGetOFString(DCM_PatientSex, patientsSex);
dataset->findAndGetOFString(DCM_PatientAge, patientsAge);
dataset->findAndGetOFString(DCM_PatientComments, patientComments);
dataset->findAndGetOFString(DCM_StudyID, studyID);
dataset->findAndGetOFString(DCM_StudyDate, studyDate);
dataset->findAndGetOFString(DCM_StudyTime, studyTime);
dataset->findAndGetOFString(DCM_AccessionNumber, accessionNumber);
dataset->findAndGetOFString(DCM_ModalitiesInStudy, modalitiesInStudy);
dataset->findAndGetOFString(DCM_InstitutionName, institutionName);
dataset->findAndGetOFString(DCM_PerformingPhysicianName, performingPhysiciansName);
dataset->findAndGetOFString(DCM_ReferringPhysicianName, referringPhysician);
dataset->findAndGetOFString(DCM_StudyDescription, studyDescription);
dataset->findAndGetOFString(DCM_SeriesDate, seriesDate);
dataset->findAndGetOFString(DCM_SeriesTime, seriesTime);
dataset->findAndGetOFString(DCM_SeriesDescription, seriesDescription);
dataset->findAndGetOFString(DCM_BodyPartExamined, bodyPartExamined);
dataset->findAndGetOFString(DCM_FrameOfReferenceUID, frameOfReferenceUID);
dataset->findAndGetOFString(DCM_ContrastBolusAgent, contrastAgent);
dataset->findAndGetOFString(DCM_ScanningSequence, scanningSequence);
dataset->findAndGetSint32(DCM_SeriesNumber, seriesNumber);
dataset->findAndGetSint32(DCM_AcquisitionNumber, acquisitionNumber);
dataset->findAndGetSint32(DCM_EchoNumbers, echoNumber);
dataset->findAndGetSint32(DCM_TemporalPositionIdentifier, temporalPosition);
// store the file if the database is not in memomry
QString filename;
if ( storeFile && !this->isInMemory() )
{
DcmFileFormat* fileformat = new DcmFileFormat ( dataset );
QString destinationDirectoryName = databaseDirectory() + "/dicom/";
QDir destinationDir(destinationDirectoryName);
QString studySeriesDirectory = QString(studyInstanceUID.c_str()) + "/" + seriesInstanceUID.c_str();
destinationDir.mkpath(studySeriesDirectory);
filename = databaseDirectory() + "/dicom/" + pathForDataset(dataset);
logger.debug ( "Saving file: " + filename );
OFCondition status = fileformat->saveFile ( filename.toAscii() );
if ( !status.good() )
{
logger.error ( "Error saving file: " + filename + "\nError is " + status.text() );
delete fileformat;
return;
}
delete fileformat;
}
QSqlQuery check_exists_query(d->Database);
//The patient UID is a unique number within the database, generated by the sqlite autoincrement
int patientUID = -1;
if ( patientID != "" && patientsName != "" )
{
//Check if patient is already present in the db
check_exists_query.prepare ( "SELECT * FROM Patients WHERE PatientID = ? AND PatientsName = ?" );
check_exists_query.bindValue ( 0, QString ( patientID.c_str() ) );
check_exists_query.bindValue ( 1, QString ( patientsName.c_str() ) );
check_exists_query.exec();
if (check_exists_query.next())
{
patientUID = check_exists_query.value(check_exists_query.record().indexOf("UID")).toInt();
}
else
{
// Insert it
QSqlQuery statement ( d->Database );
statement.prepare ( "INSERT INTO Patients ('UID', 'PatientsName', 'PatientID', 'PatientsBirthDate', 'PatientsBirthTime', 'PatientsSex', 'PatientsAge', 'PatientsComments' ) values ( NULL, ?, ?, ?, ?, ?, ?, ? )" );
statement.bindValue ( 0, QString ( patientsName.c_str() ) );
statement.bindValue ( 1, QString ( patientID.c_str() ) );
statement.bindValue ( 2, QString ( patientsBirthDate.c_str() ) );
statement.bindValue ( 3, QString ( patientsBirthTime.c_str() ) );
statement.bindValue ( 4, QString ( patientsSex.c_str() ) );
// TODO: shift patient's age to study, since this is not a patient level attribute in images
// statement.bindValue ( 5, QString ( patientsAge.c_str() ) );
statement.bindValue ( 6, QString ( patientComments.c_str() ) );
statement.exec ();
patientUID = statement.lastInsertId().toInt();
logger.debug ( "New patient inserted: " + QString().setNum ( patientUID ) );
}
}
if ( studyInstanceUID != "" )
{
check_exists_query.prepare ( "SELECT * FROM Studies WHERE StudyInstanceUID = ?" );
check_exists_query.bindValue ( 0, QString ( studyInstanceUID.c_str() ) );
check_exists_query.exec();
if(!check_exists_query.next())
{
QSqlQuery statement ( d->Database );
statement.prepare ( "INSERT INTO Studies ( 'StudyInstanceUID', 'PatientsUID', 'StudyID', 'StudyDate', 'StudyTime', 'AccessionNumber', 'ModalitiesInStudy', 'InstitutionName', 'ReferringPhysician', 'PerformingPhysiciansName', 'StudyDescription' ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )" );
statement.bindValue ( 0, QString ( studyInstanceUID.c_str() ) );
statement.bindValue ( 1, patientUID );
statement.bindValue ( 2, QString ( studyID.c_str() ) );
statement.bindValue ( 3, QDate::fromString ( studyDate.c_str(), "yyyyMMdd" ) );
statement.bindValue ( 4, QString ( studyTime.c_str() ) );
statement.bindValue ( 5, QString ( accessionNumber.c_str() ) );
statement.bindValue ( 6, QString ( modalitiesInStudy.c_str() ) );
statement.bindValue ( 7, QString ( institutionName.c_str() ) );
statement.bindValue ( 8, QString ( referringPhysician.c_str() ) );
statement.bindValue ( 9, QString ( performingPhysiciansName.c_str() ) );
statement.bindValue ( 10, QString ( studyDescription.c_str() ) );
if ( !statement.exec() )
{
logger.error ( "Error executing statament: " + statement.lastQuery() + " Error: " + statement.lastError().text() );
}
}
}
if ( seriesInstanceUID != "" )
{
check_exists_query.prepare ( "SELECT * FROM Series WHERE SeriesInstanceUID = ?" );
check_exists_query.bindValue ( 0, QString ( seriesInstanceUID.c_str() ) );
logger.warn ( "Statement: " + check_exists_query.lastQuery() );
check_exists_query.exec();
if(!check_exists_query.next())
{
QSqlQuery statement ( d->Database );
statement.prepare ( "INSERT INTO Series ( 'SeriesInstanceUID', 'StudyInstanceUID', 'SeriesNumber', 'SeriesDate', 'SeriesTime', 'SeriesDescription', 'BodyPartExamined', 'FrameOfReferenceUID', 'AcquisitionNumber', 'ContrastAgent', 'ScanningSequence', 'EchoNumber', 'TemporalPosition' ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )" );
statement.bindValue ( 0, QString ( seriesInstanceUID.c_str() ) );
statement.bindValue ( 1, QString ( studyInstanceUID.c_str() ) );
statement.bindValue ( 2, static_cast<int>(seriesNumber) );
statement.bindValue ( 3, QString ( seriesDate.c_str() ) );
statement.bindValue ( 4, QDate::fromString ( seriesTime.c_str(), "yyyyMMdd" ) );
statement.bindValue ( 5, QString ( seriesDescription.c_str() ) );
statement.bindValue ( 6, QString ( bodyPartExamined.c_str() ) );
statement.bindValue ( 7, QString ( frameOfReferenceUID.c_str() ) );
statement.bindValue ( 8, static_cast<int>(acquisitionNumber) );
statement.bindValue ( 9, QString ( contrastAgent.c_str() ) );
statement.bindValue ( 10, QString ( scanningSequence.c_str() ) );
statement.bindValue ( 11, static_cast<int>(echoNumber) );
statement.bindValue ( 12, static_cast<int>(temporalPosition) );
if ( !statement.exec() )
{
logger.error ( "Error executing statament: " + statement.lastQuery() + " Error: " + statement.lastError().text() );
}
}
}
if ( !filename.isEmpty() )
{
check_exists_query.prepare ( "SELECT * FROM Images WHERE Filename = ?" );
check_exists_query.bindValue ( 0, filename );
check_exists_query.exec();
if(!check_exists_query.next())
{
QSqlQuery statement ( d->Database );
statement.prepare ( "INSERT INTO Images ( 'SOPInstanceUID', 'Filename', 'SeriesInstanceUID', 'InsertTimestamp' ) VALUES ( ?, ?, ?, ? )" );
statement.bindValue ( 0, QString ( sopInstanceUID.c_str() ) );
statement.bindValue ( 1, filename );
statement.bindValue ( 2, QString ( seriesInstanceUID.c_str() ) );
statement.bindValue ( 3, QDateTime::currentDateTime() );
statement.exec();
}
}
if(generateThumbnail){
if(d->thumbnailGenerator){
QString studySeriesDirectory = QString(studyInstanceUID.c_str()) + "/" + QString(seriesInstanceUID.c_str());
//Create thumbnail here
QString thumbnailPath = databaseDirectory() +
"/thumbs/" + this->pathForDataset(dataset) + ".png";
//QString(studyInstanceUID.c_str()) + "/" +
//QString(seriesInstanceUID.c_str()) + "/" +
//QString(sopInstanceUID.c_str()) + ".png";
QFileInfo thumbnailInfo(thumbnailPath);
if(!(thumbnailInfo.exists() && (thumbnailInfo.lastModified() > QFileInfo(filename).lastModified()))){
QDir(databaseDirectory() + "/thumbs/").mkpath(studySeriesDirectory);
DicomImage dcmImage(QDir::toNativeSeparators(filename).toAscii());
d->thumbnailGenerator->generateThumbnail(&dcmImage, thumbnailPath);
}
}
}
if (isInMemory())
{
emit databaseChanged();
}
}
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 ctkDICOMDatabasePrivate::insert( const ctkDICOMDataset& ctkDataset, const QString& filePath, bool storeFile, bool generateThumbnail)
{
Q_Q(ctkDICOMDatabase);
// Check to see if the file has already been loaded
// TODO:
// It could make sense to actually remove the dataset and re-add it. This needs the remove
// method we still have to write.
//
QString sopInstanceUID ( ctkDataset.GetElementAsString(DCM_SOPInstanceUID) );
QSqlQuery fileExists ( Database );
fileExists.prepare("SELECT InsertTimestamp,Filename FROM Images WHERE SOPInstanceUID == :sopInstanceUID");
fileExists.bindValue(":sopInstanceUID",sopInstanceUID);
bool success = fileExists.exec();
if (!success)
{
logger.error("SQLITE ERROR: " + fileExists.lastError().driverText());
return;
}
qDebug() << "filename is: " << fileExists.value(1).toString();
qDebug() << "modified date is: " << QFileInfo(fileExists.value(1).toString()).lastModified();
qDebug() << "db mod date is: " << QDateTime::fromString(fileExists.value(0).toString(),Qt::ISODate);
if ( fileExists.next() && QFileInfo(fileExists.value(1).toString()).lastModified() < QDateTime::fromString(fileExists.value(0).toString(),Qt::ISODate) )
{
logger.debug ( "File " + fileExists.value(1).toString() + " already added" );
return;
}
//If the following fields can not be evaluated, cancel evaluation of the DICOM file
QString patientsName(ctkDataset.GetElementAsString(DCM_PatientName) );
QString studyInstanceUID(ctkDataset.GetElementAsString(DCM_StudyInstanceUID) );
QString seriesInstanceUID(ctkDataset.GetElementAsString(DCM_SeriesInstanceUID) );
QString patientID(ctkDataset.GetElementAsString(DCM_PatientID) );
if ( patientsName.isEmpty() && !patientID.isEmpty() )
{ // Use patient id as name if name is empty - can happen on anonymized datasets
// see: http://www.na-mic.org/Bug/view.php?id=1643
patientsName = patientID;
}
if ( patientsName.isEmpty() || studyInstanceUID.isEmpty() || patientID.isEmpty() )
{
logger.error("Dataset is missing necessary information!");
return;
}
QString patientsBirthDate(ctkDataset.GetElementAsString(DCM_PatientBirthDate) );
QString patientsBirthTime(ctkDataset.GetElementAsString(DCM_PatientBirthTime) );
QString patientsSex(ctkDataset.GetElementAsString(DCM_PatientSex) );
QString patientsAge(ctkDataset.GetElementAsString(DCM_PatientAge) );
QString patientComments(ctkDataset.GetElementAsString(DCM_PatientComments) );
QString studyID(ctkDataset.GetElementAsString(DCM_StudyID) );
QString studyDate(ctkDataset.GetElementAsString(DCM_StudyDate) );
QString studyTime(ctkDataset.GetElementAsString(DCM_StudyTime) );
QString accessionNumber(ctkDataset.GetElementAsString(DCM_AccessionNumber) );
QString modalitiesInStudy(ctkDataset.GetElementAsString(DCM_ModalitiesInStudy) );
QString institutionName(ctkDataset.GetElementAsString(DCM_InstitutionName) );
QString performingPhysiciansName(ctkDataset.GetElementAsString(DCM_PerformingPhysicianName) );
QString referringPhysician(ctkDataset.GetElementAsString(DCM_ReferringPhysicianName) );
QString studyDescription(ctkDataset.GetElementAsString(DCM_StudyDescription) );
QString seriesDate(ctkDataset.GetElementAsString(DCM_SeriesDate) );
QString seriesTime(ctkDataset.GetElementAsString(DCM_SeriesTime) );
QString seriesDescription(ctkDataset.GetElementAsString(DCM_SeriesDescription) );
QString bodyPartExamined(ctkDataset.GetElementAsString(DCM_BodyPartExamined) );
QString frameOfReferenceUID(ctkDataset.GetElementAsString(DCM_FrameOfReferenceUID) );
QString contrastAgent(ctkDataset.GetElementAsString(DCM_ContrastBolusAgent) );
QString scanningSequence(ctkDataset.GetElementAsString(DCM_ScanningSequence) );
long seriesNumber(ctkDataset.GetElementAsInteger(DCM_SeriesNumber) );
long acquisitionNumber(ctkDataset.GetElementAsInteger(DCM_AcquisitionNumber) );
long echoNumber(ctkDataset.GetElementAsInteger(DCM_EchoNumbers) );
long temporalPosition(ctkDataset.GetElementAsInteger(DCM_TemporalPositionIdentifier) );
// store the file if the database is not in memomry
// TODO: if we are called from insert(file) we
// have to do something else
//
QString filename = filePath;
if ( storeFile && !q->isInMemory() && !seriesInstanceUID.isEmpty() )
{
// QString studySeriesDirectory = studyInstanceUID + "/" + seriesInstanceUID;
QString destinationDirectoryName = q->databaseDirectory() + "/dicom/";
QDir destinationDir(destinationDirectoryName);
filename = destinationDirectoryName +
studyInstanceUID + "/" +
seriesInstanceUID + "/" +
sopInstanceUID;
destinationDir.mkpath(studyInstanceUID + "/" +
seriesInstanceUID);
if(filePath.isEmpty())
{
logger.debug ( "Saving file: " + filename );
if ( !ctkDataset.SaveToFile( filename) )
{
logger.error ( "Error saving file: " + filename );
return;
}
}
else
{
// we're inserting an existing file
QFile currentFile( filePath );
currentFile.copy(filename);
logger.debug( "Copy file from: " + filePath );
logger.debug( "Copy file to : " + filename );
}
}
QSqlQuery checkPatientExistsQuery(Database);
//The dbPatientID is a unique number within the database,
//generated by the sqlite autoincrement
//The patientID is the (non-unique) DICOM patient id
int dbPatientID = -1;
if ( patientID != "" && patientsName != "" )
{
//Speed up: Check if patient is the same as in last file;
// very probable, as all images belonging to a study have the same patient
if ( lastPatientID != patientID
|| lastPatientsBirthDate != patientsBirthDate
|| lastPatientsName != patientsName )
{
// Ok, something is different from last insert, let's insert him if he's not
// already in the db.
//
// Check if patient is already present in the db
// TODO: maybe add birthdate check for extra safety
checkPatientExistsQuery.prepare ( "SELECT * FROM Patients WHERE PatientID = ? AND PatientsName = ?" );
checkPatientExistsQuery.bindValue ( 0, patientID );
checkPatientExistsQuery.bindValue ( 1, patientsName );
loggedExec(checkPatientExistsQuery);
if (checkPatientExistsQuery.next())
{
// we found him
dbPatientID = checkPatientExistsQuery.value(checkPatientExistsQuery.record().indexOf("UID")).toInt();
}
else
{
// Insert it
QSqlQuery insertPatientStatement ( Database );
insertPatientStatement.prepare ( "INSERT INTO Patients ('UID', 'PatientsName', 'PatientID', 'PatientsBirthDate', 'PatientsBirthTime', 'PatientsSex', 'PatientsAge', 'PatientsComments' ) values ( NULL, ?, ?, ?, ?, ?, ?, ? )" );
insertPatientStatement.bindValue ( 0, patientsName );
insertPatientStatement.bindValue ( 1, patientID );
insertPatientStatement.bindValue ( 2, patientsBirthDate );
insertPatientStatement.bindValue ( 3, patientsBirthTime );
insertPatientStatement.bindValue ( 4, patientsSex );
// TODO: shift patient's age to study,
// since this is not a patient level attribute in images
// insertPatientStatement.bindValue ( 5, patientsAge );
insertPatientStatement.bindValue ( 6, patientComments );
loggedExec(insertPatientStatement);
dbPatientID = insertPatientStatement.lastInsertId().toInt();
logger.debug ( "New patient inserted: " + QString().setNum ( dbPatientID ) );
}
/// keep this for the next image
lastPatientUID = dbPatientID;
lastPatientID = patientID;
lastPatientsBirthDate = patientsBirthDate;
lastPatientsName = patientsName;
}
// Patient is in now. Let's continue with the study
if ( studyInstanceUID != "" && lastStudyInstanceUID != studyInstanceUID )
{
QSqlQuery checkStudyExistsQuery (Database);
checkStudyExistsQuery.prepare ( "SELECT * FROM Studies WHERE StudyInstanceUID = ?" );
checkStudyExistsQuery.bindValue ( 0, studyInstanceUID );
checkStudyExistsQuery.exec();
if(!checkStudyExistsQuery.next())
{
QSqlQuery insertStudyStatement ( Database );
insertStudyStatement.prepare ( "INSERT INTO Studies ( 'StudyInstanceUID', 'PatientsUID', 'StudyID', 'StudyDate', 'StudyTime', 'AccessionNumber', 'ModalitiesInStudy', 'InstitutionName', 'ReferringPhysician', 'PerformingPhysiciansName', 'StudyDescription' ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )" );
insertStudyStatement.bindValue ( 0, studyInstanceUID );
insertStudyStatement.bindValue ( 1, dbPatientID );
insertStudyStatement.bindValue ( 2, studyID );
insertStudyStatement.bindValue ( 3, QDate::fromString ( studyDate, "yyyyMMdd" ) );
insertStudyStatement.bindValue ( 4, studyTime );
insertStudyStatement.bindValue ( 5, accessionNumber );
insertStudyStatement.bindValue ( 6, modalitiesInStudy );
insertStudyStatement.bindValue ( 7, institutionName );
insertStudyStatement.bindValue ( 8, referringPhysician );
insertStudyStatement.bindValue ( 9, performingPhysiciansName );
insertStudyStatement.bindValue ( 10, studyDescription );
if ( !insertStudyStatement.exec() )
{
logger.error ( "Error executing statament: " + insertStudyStatement.lastQuery() + " Error: " + insertStudyStatement.lastError().text() );
}
else
{
lastStudyInstanceUID = studyInstanceUID;
}
}
}
if ( seriesInstanceUID != "" && seriesInstanceUID != lastSeriesInstanceUID )
{
QSqlQuery checkSeriesExistsQuery (Database);
checkSeriesExistsQuery.prepare ( "SELECT * FROM Series WHERE SeriesInstanceUID = ?" );
checkSeriesExistsQuery.bindValue ( 0, seriesInstanceUID );
logger.warn ( "Statement: " + checkSeriesExistsQuery.lastQuery() );
loggedExec(checkSeriesExistsQuery);
if(!checkSeriesExistsQuery.next())
{
QSqlQuery insertSeriesStatement ( Database );
insertSeriesStatement.prepare ( "INSERT INTO Series ( 'SeriesInstanceUID', 'StudyInstanceUID', 'SeriesNumber', 'SeriesDate', 'SeriesTime', 'SeriesDescription', 'BodyPartExamined', 'FrameOfReferenceUID', 'AcquisitionNumber', 'ContrastAgent', 'ScanningSequence', 'EchoNumber', 'TemporalPosition' ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )" );
insertSeriesStatement.bindValue ( 0, seriesInstanceUID );
insertSeriesStatement.bindValue ( 1, studyInstanceUID );
insertSeriesStatement.bindValue ( 2, static_cast<int>(seriesNumber) );
insertSeriesStatement.bindValue ( 3, seriesDate );
insertSeriesStatement.bindValue ( 4, QDate::fromString ( seriesTime, "yyyyMMdd" ) );
insertSeriesStatement.bindValue ( 5, seriesDescription );
insertSeriesStatement.bindValue ( 6, bodyPartExamined );
insertSeriesStatement.bindValue ( 7, frameOfReferenceUID );
insertSeriesStatement.bindValue ( 8, static_cast<int>(acquisitionNumber) );
insertSeriesStatement.bindValue ( 9, contrastAgent );
insertSeriesStatement.bindValue ( 10, scanningSequence );
insertSeriesStatement.bindValue ( 11, static_cast<int>(echoNumber) );
insertSeriesStatement.bindValue ( 12, static_cast<int>(temporalPosition) );
if ( !insertSeriesStatement.exec() )
{
logger.error ( "Error executing statament: "
+ insertSeriesStatement.lastQuery()
+ " Error: " + insertSeriesStatement.lastError().text() );
lastSeriesInstanceUID = "";
}
else
{
lastSeriesInstanceUID = seriesInstanceUID;
}
}
}
// TODO: what to do with imported files
//
if ( !filename.isEmpty() && !seriesInstanceUID.isEmpty() )
{
QSqlQuery checkImageExistsQuery (Database);
checkImageExistsQuery.prepare ( "SELECT * FROM Images WHERE Filename = ?" );
checkImageExistsQuery.bindValue ( 0, filename );
checkImageExistsQuery.exec();
if(!checkImageExistsQuery.next())
{
QSqlQuery insertImageStatement ( Database );
insertImageStatement.prepare ( "INSERT INTO Images ( 'SOPInstanceUID', 'Filename', 'SeriesInstanceUID', 'InsertTimestamp' ) VALUES ( ?, ?, ?, ? )" );
insertImageStatement.bindValue ( 0, sopInstanceUID );
insertImageStatement.bindValue ( 1, filename );
insertImageStatement.bindValue ( 2, seriesInstanceUID );
insertImageStatement.bindValue ( 3, QDateTime::currentDateTime() );
insertImageStatement.exec();
}
}
if( generateThumbnail && thumbnailGenerator && !seriesInstanceUID.isEmpty() )
{
QString studySeriesDirectory = studyInstanceUID + "/" + seriesInstanceUID;
//Create thumbnail here
QString thumbnailPath = q->databaseDirectory() +
"/thumbs/" + studyInstanceUID + "/" + seriesInstanceUID
+ "/" + sopInstanceUID + ".png";
QFileInfo thumbnailInfo(thumbnailPath);
if( !(thumbnailInfo.exists()
&& (thumbnailInfo.lastModified() > QFileInfo(filename).lastModified())))
{
QDir(q->databaseDirectory() + "/thumbs/").mkpath(studySeriesDirectory);
DicomImage dcmImage(QDir::toNativeSeparators(filename).toAscii());
thumbnailGenerator->generateThumbnail(&dcmImage, thumbnailPath);
}
}
if (q->isInMemory())
{
emit q->databaseChanged();
}
}
}
