// --------------------------------------------------------------------------
void ctkWorkflowStep::validate(const QString& desiredBranchId)
{
Q_D(ctkWorkflowStep);
logger.info(QString("validate - validating the input from %1").arg(d->Name));
this->validationComplete(true, desiredBranchId);
}
//------------------------------------------------------------------------------
bool ctkDICOMRetrieve::getStudy(const QString& studyInstanceUID)
{
if (studyInstanceUID.isEmpty())
{
logger.error("Cannot receive series: Study Instance UID empty.");
return false;
}
Q_D(ctkDICOMRetrieve);
logger.info ( "Starting getStudy" );
return d->get ( studyInstanceUID, "", ctkDICOMRetrievePrivate::RetrieveStudy );
}
//------------------------------------------------------------------------------
bool ctkDICOMRetrieve::getSeries(const QString& studyInstanceUID,
const QString& seriesInstanceUID)
{
if (studyInstanceUID.isEmpty() || seriesInstanceUID.isEmpty())
{
logger.error("Cannot receive series: Either Study or Series Instance UID empty.");
return false;
}
Q_D(ctkDICOMRetrieve);
logger.info ( "Starting getSeries" );
return d->get ( studyInstanceUID, seriesInstanceUID, ctkDICOMRetrievePrivate::RetrieveSeries );
}
//------------------------------------------------------------------------------
ctkDICOMRetrievePrivate::ctkDICOMRetrievePrivate(ctkDICOMRetrieve& obj)
: q_ptr(&obj)
{
this->Database = QSharedPointer<ctkDICOMDatabase> (0);
this->WasCanceled = false;
this->KeepAssociationOpen = true;
this->ConnectionParamsChanged = false;
this->LastRetrieveType = RetrieveNone;
// Register the JPEG libraries in case we need them
// (registration only happens once, so it's okay to call repeatedly)
// register global JPEG decompression codecs
DJDecoderRegistration::registerCodecs();
// register global JPEG compression codecs
DJEncoderRegistration::registerCodecs();
// register RLE compression codec
DcmRLEEncoderRegistration::registerCodecs();
// register RLE decompression codec
DcmRLEDecoderRegistration::registerCodecs();
logger.info ( "Setting Transfer Syntaxes" );
OFList<OFString> transferSyntaxes;
transferSyntaxes.push_back ( UID_LittleEndianExplicitTransferSyntax );
transferSyntaxes.push_back ( UID_BigEndianExplicitTransferSyntax );
transferSyntaxes.push_back ( UID_LittleEndianImplicitTransferSyntax );
this->SCU.addPresentationContext (
UID_MOVEStudyRootQueryRetrieveInformationModel, transferSyntaxes );
this->SCU.addPresentationContext (
UID_GETStudyRootQueryRetrieveInformationModel, transferSyntaxes );
for (Uint16 i = 0; i < numberOfDcmLongSCUStorageSOPClassUIDs; i++)
{
this->SCU.addPresentationContext(dcmLongSCUStorageSOPClassUIDs[i],
transferSyntaxes, ASC_SC_ROLE_SCP);
}
}
//------------------------------------------------------------------------------
bool ctkDICOMRetrieve::retrieveStudy( const QString& studyInstanceUID )
{
Q_D(ctkDICOMRetrieve);
logger.info ( "Starting retrieveStudy" );
return d->retrieve ( studyInstanceUID, ctkDICOMRetrievePrivate::RetrieveStudy );
}
//------------------------------------------------------------------------------
bool ctkDICOMRetrieve::retrieveSeries( const QString& seriesInstanceUID )
{
Q_D(ctkDICOMRetrieve);
logger.info ( "Starting retrieveSeries" );
return d->retrieve ( seriesInstanceUID, ctkDICOMRetrievePrivate::RetrieveSeries );
}
//------------------------------------------------------------------------------
bool ctkDICOMRetrievePrivate::retrieve ( QString UID, RetrieveType retriveType ) {
if ( !this->RetrieveDatabase )
{
logger.error ( "Must have RetrieveDatabase for retrieve transaction" );
return false;
}
// Register the JPEG libraries in case we need them
// (registration only happens once, so it's okay to call repeatedly)
// register global JPEG decompression codecs
DJDecoderRegistration::registerCodecs();
// register global JPEG compression codecs
DJEncoderRegistration::registerCodecs();
// register RLE compression codec
DcmRLEEncoderRegistration::registerCodecs();
// register RLE decompression codec
DcmRLEDecoderRegistration::registerCodecs();
// Set the DCMTK log level
log4cplus::Logger rootLogger = log4cplus::Logger::getRoot();
rootLogger.setLogLevel(log4cplus::DEBUG_LOG_LEVEL);
// TODO: use this->SCU instead ?
DcmSCU scu;
scu.setAETitle ( OFString(this->CallingAETitle.toStdString().c_str()) );
scu.setPort ( this->CallingPort );
scu.setPeerAETitle ( OFString(this->CalledAETitle.toStdString().c_str()) );
scu.setPeerHostName ( OFString(this->Host.toStdString().c_str()) );
scu.setPeerPort ( this->CalledPort );
scu.setMoveDestinationAETitle ( OFString(this->MoveDestinationAETitle.toStdString().c_str()) );
logger.info ( "Setting Transfer Syntaxes" );
OFList<OFString> transferSyntaxes;
transferSyntaxes.push_back ( UID_LittleEndianExplicitTransferSyntax );
transferSyntaxes.push_back ( UID_BigEndianExplicitTransferSyntax );
transferSyntaxes.push_back ( UID_LittleEndianImplicitTransferSyntax );
scu.addPresentationContext ( UID_FINDStudyRootQueryRetrieveInformationModel, transferSyntaxes );
scu.addPresentationContext ( UID_MOVEStudyRootQueryRetrieveInformationModel, transferSyntaxes );
if ( !scu.initNetwork().good() )
{
logger.error ( "Error initializing the network" );
return false;
}
logger.debug ( "Negotiating Association" );
if ( !scu.negotiateAssociation().good() )
{
logger.error ( "Error negotiating association" );
return false;;
}
logger.debug ( "Setting Parameters" );
// Clear the query
unsigned long elements = this->parameters->card();
// Clean it out
for ( unsigned long i = 0; i < elements; i++ )
{
this->parameters->remove ( 0ul );
}
if ( retriveType == RetrieveSeries )
{
this->parameters->putAndInsertString ( DCM_QueryRetrieveLevel, "SERIES" );
this->parameters->putAndInsertString ( DCM_SeriesInstanceUID, UID.toStdString().c_str() );
}
else
{
this->parameters->putAndInsertString ( DCM_QueryRetrieveLevel, "STUDY" );
this->parameters->putAndInsertString ( DCM_StudyInstanceUID, UID.toStdString().c_str() );
}
logger.debug ( "Sending Move Request" );
MOVEResponses *responses = new MOVEResponses();
OFCondition status = scu.sendMOVERequest ( 0, this->parameters, responses );
if (!status.good())
{
logger.error ( "MOVE Request failed: " + QString ( status.text() ) );
return false;
}
logger.debug ( "Find succeded" );
logger.debug ( "Making Output Directory" );
QDir directory = QDir( RetrieveDatabase->databaseDirectory() );
if ( responses->begin() == responses->end() )
{
logger.error ( "No responses!" );
throw std::runtime_error( std::string("No responses!") );
}
// Write the responses out to disk
for ( OFListIterator(FINDResponse*) it = responses->begin(); it != responses->end(); it++ )
{
DcmDataset *dataset = (*it)->m_dataset;
if ( dataset != NULL )
{
logger.debug ( "Got a valid dataset" );
// Save in correct directory
E_TransferSyntax output_transfersyntax = dataset->getOriginalXfer();
dataset->chooseRepresentation( output_transfersyntax, NULL );
if ( !dataset->canWriteXfer( output_transfersyntax ) )
{
// Pick EXS_LittleEndianExplicit as our default
output_transfersyntax = EXS_LittleEndianExplicit;
}
DcmXfer opt_oxferSyn( output_transfersyntax );
if ( !dataset->chooseRepresentation( opt_oxferSyn.getXfer(), NULL ).bad() )
{
DcmFileFormat* fileformat = new DcmFileFormat ( dataset );
// Follow dcmdjpeg example
fileformat->loadAllDataIntoMemory();
OFString SOPInstanceUID;
dataset->findAndGetOFString ( DCM_SOPInstanceUID, SOPInstanceUID );
QFileInfo fi ( directory, QString ( SOPInstanceUID.c_str() ) );
logger.debug ( "Saving file: " + fi.absoluteFilePath() );
status = fileformat->saveFile ( fi.absoluteFilePath().toStdString().c_str(), opt_oxferSyn.getXfer() );
if ( !status.good() )
{
logger.error ( "Error saving file: " + fi.absoluteFilePath() + " Error is " + status.text() );
}
RetrieveDatabase->insert( dataset, true );
delete fileformat;
}
}
}
delete responses;
//if ( !scu.dropNetwork().good() )
//{
//logger.error ( "Error dropping the network" );
//return false;
//}
return true;
}
//------------------------------------------------------------------------------
void ctkDICOMRetrieve::retrieveStudy ( QString studyInstanceUID, QDir directory ) {
Q_D(ctkDICOMRetrieve);
logger.info ( "Starting retrieveStudy" );
d->retrieve ( studyInstanceUID, directory, ctkDICOMRetrievePrivate::RetrieveStudy );
return;
}
//------------------------------------------------------------------------------
void ctkDICOMRetrieve::retrieveSeries ( QString seriesInstanceUID, QDir directory ) {
Q_D(ctkDICOMRetrieve);
logger.info ( "Starting retrieveSeries" );
d->retrieve ( seriesInstanceUID, directory, ctkDICOMRetrievePrivate::RetrieveSeries );
return;
}
