sunwen/DCMV
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
91b6228f488c8427f1b6d1c93407d2b39e33a3a2
DCMV/thirdparty/dcm_network/dcm_move.cpp
Krad 3e9f4a7b75 Add thirdparty dir.
2022-07-08 10:04:23 +08:00

1103 lines
30 KiB
C++
Raw Blame History

#include "dcm_move.h"
//------------------------------------------------------------------------------------------------------
// static function
static void moveCallback(void *callbackData, T_DIMSE_C_MoveRQ *request, int responseCount, T_DIMSE_C_MoveRSP *response)
{
dcm_cmove_callback * callback = reinterpret_cast<dcm_cmove_callback *>(callbackData);
if (callback)
{
callback->callback(request, responseCount, response);
}
}
//-----------------------------------------------------------------------------------------------------
// c-move callback
dcm_cmove_callback::dcm_cmove_callback()
{
}
dcm_cmove_callback::~dcm_cmove_callback()
{
}
void dcm_cmove_callback::setAssoc(T_ASC_Association * assoc)
{
assoc = assoc;
}
void dcm_cmove_callback::setPresetnationContextID(const T_ASC_PresentationContextID& presId)
{
presId_ = presId;
}
void dcm_cmove_callback::setCancelAfterNReponse(int n)
{
cancelAfterNResponse_ = n;
}
////dcm_cmove_callback::dcm_cmove_callback(const dcm_cmove_callback& other)
////{
////}
////
////dcm_cmove_callback& dcm_cmove_callback::operator=(const dcm_cmove_callback& other)
////{
////}
// default implementation
dcm_cmove_callback_default::dcm_cmove_callback_default()
{
}
dcm_cmove_callback_default::~dcm_cmove_callback_default()
{
}
void dcm_cmove_callback_default::callback(T_DIMSE_C_MoveRQ *request, int responseCount, T_DIMSE_C_MoveRSP *response)
{
OFCondition cond = EC_Normal;
if (cancelAfterNResponse_ == responseCount)
{
cond = DIMSE_sendCancelRequest(assoc_, presId_, request->MessageID);
if (cond != EC_Normal)
{
// log << Cancel Request Failed
}
}
}
//------------------------------------------------------------------------------------------------------
// static function
static void storeSCPCallback(void *callbackData, T_DIMSE_StoreProgress *progress, T_DIMSE_C_StoreRQ *req, char *imageFileName, DcmDataset **imageDataSet, T_DIMSE_C_StoreRSP *rsp, DcmDataset **statusDetail)
{
dcm_cmove_storescp_callback *callback = reinterpret_cast<dcm_cmove_storescp_callback *>(callbackData);
if (callback)
{
callback->callback(progress, req, imageFileName, imageDataSet, rsp, statusDetail);
}
}
static void subOpCallback(void *callbackData, T_ASC_Network *aNet, T_ASC_Association **subAssoc)
{
dcm_cmove *cbdata = reinterpret_cast<dcm_cmove *>(callbackData);
if (cbdata == NULL)
{
return;
}
if (aNet == NULL)
{
return;
}
if (*subAssoc == NULL)
{
cbdata->acceptSubAssoc(aNet, subAssoc);
}
else
{
cbdata->subOpSCP(subAssoc);
}
}
//------------------------------------------------------------------------------------------------------
// c-store scp callback
dcm_cmove_storescp_callback::dcm_cmove_storescp_callback()
{
}
dcm_cmove_storescp_callback::~dcm_cmove_storescp_callback()
{
}
void dcm_cmove_storescp_callback::setImageFileName(char * imageFileName)
{
imageFile_ = imageFileName;
}
void dcm_cmove_storescp_callback::setDcmFileFormat(DcmFileFormat * dcmff)
{
dcmff_ = dcmff;
}
void dcm_cmove_storescp_callback::setAssoc(T_ASC_Association * assoc)
{
assoc_ = assoc;
}
////dcm_cmove_storescp_callback::dcm_cmove_storescp_callback(const dcm_cmove_storescp_callback& other)
////{
////}
////
////dcm_cmove_storescp_callback& dcm_cmove_storescp_callback::operator=(const dcm_cmove_storescp_callback& other)
////{
////}
// default implementation
dcm_cmove_storescp_callback_default::dcm_cmove_storescp_callback_default(std::string outputDirectory)
: dcm_cmove_storescp_callback()
, abortDuringStore_(false)
, abortAfterStore_(false)
, sleepDuring_(0)
, bitPreserving_(false)
, ignore_(false)
, writeTransferSyntax_(EXS_Unknown)
, sequenceType_(EET_ExplicitLength)
, groupLength_(EGL_recalcGL)
, paddingType_(EPD_withoutPadding)
, filepad_(0)
, itempad_(0)
, useMetaheader_(true)
{
outputDirectory_ = outputDirectory.c_str();
}
dcm_cmove_storescp_callback_default::~dcm_cmove_storescp_callback_default()
{
}
void dcm_cmove_storescp_callback_default::callback(T_DIMSE_StoreProgress *progress, T_DIMSE_C_StoreRQ *request, char *imageFileName, DcmDataset **imageDataSet, T_DIMSE_C_StoreRSP *response, DcmDataset **statusDetail)
{
DIC_UI sopClass;
DIC_UI sopInstance;
if ((abortDuringStore_ && progress->state != DIMSE_StoreBegin)
|| (abortAfterStore_ && progress->state == DIMSE_StoreEnd))
{
// log >> ABORT initiated
ASC_abortAssociation(assoc_);
response->DimseStatus = STATUS_STORE_Refused_OutOfResources;
return;
}
if (sleepDuring_ > 0)
{
OFStandard::sleep(static_cast<unsigned int>(sleepDuring_));
}
switch (progress->state)
{
case DIMSE_StoreBegin:
// log << "Recv: "
break;
case DIMSE_StoreEnd:
// log << "End"
break;
default:
// log << "."
break;
}
if (progress->state == DIMSE_StoreEnd)
{
*statusDetail = NULL;
if ((imageDataSet != NULL) && (*imageDataSet != NULL) && !bitPreserving_ && !ignore_)
{
std::string ofname;
OFStandard::combineDirAndFilename(ofname, outputDirectory_, imageFile_, true);
if (OFStandard::fileExists(ofname))
{
//log << "DICOM file already exists, overwriting:
}
E_TransferSyntax xfer = writeTransferSyntax_;
if (xfer == EXS_Unknown)
{
xfer = (*imageDataSet)->getOriginalXfer();
}
OFCondition cond = dcmff_->saveFile(ofname.c_str(), xfer, sequenceType_, groupLength_, paddingType_, static_cast<Uint32>(filepad_), static_cast<Uint32>(itempad_), useMetaheader_ ? EWM_fileformat : EWM_dataset);
if (cond.bad())
{
// log << cannot write DICOM file
response->DimseStatus = STATUS_STORE_Refused_OutOfResources;
OFStandard::deleteFile(ofname);
}
if ((response->DimseStatus == STATUS_Success) && (!ignore_))
{
if (!DU_findSOPClassAndInstanceInDataSet(*imageDataSet, sopClass, sizeof(sopClass), sopClass, sizeof(sopInstance), correctUIDPadding_))
{
// log << bad DICOM file
response->DimseStatus = STATUS_STORE_Error_CannotUnderstand;
}
else if (strcmp(sopClass, request->AffectedSOPClassUID) != 0)
{
response->DimseStatus = STATUS_STORE_Error_DataSetDoesNotMatchSOPClass;
}
else if (strcmp(sopInstance, request->AffectedSOPInstanceUID) != 0)
{
response->DimseStatus = STATUS_STORE_Error_DataSetDoesNotMatchSOPClass;
}
}
}
}
}
//--------------------------------------------------------------------------------------------------------
// dcm-cmove
typedef struct {
const char * findSyntax;
const char * moveSyntax;
} QuerySyntax;
static QuerySyntax querySyntax[3] =
{
{ UID_FINDPatientRootQueryRetrieveInformationModel, UID_MOVEPatientRootQueryRetrieveInformationModel },
{ UID_FINDStudyRootQueryRetrieveInformationModel, UID_MOVEStudyRootQueryRetrieveInformationModel },
{ UID_RETIRED_FINDPatientStudyOnlyQueryRetrieveInformationModel, UID_RETIRED_MOVEPatientStudyOnlyQueryRetrieveInformationModel }
};
dcm_cmove::dcm_cmove(const char *peerIp, unsigned long peerPort, const char *peerTitle, unsigned long ourPort, const char *ourTile)
: cmove_callback(NULL)
, storescp_callback(NULL)
, sleepAfter(0)
, sleepDuring(0)
, maxPDU(ASC_DEFAULTMAXPDU)
, useMetaheader(true)
, acceptAllXfer(true)
, in_networkTransferSyntax(EXS_Unknown)
, out_networkTransferSyntax(EXS_Unknown)
, bitPreserving(false)
, ignore(false)
, repeatCount(1)
, abortAssociation(false)
, queryModel(QMPatientRoot)
, blockMode(DIMSE_BLOCKING)
, dimse_timeout(0)
, acse_timeout(30)
, ignorePendingDatasets(true)
, net(NULL)
, overrideKeys(NULL)
{
peerIp_ = peerIp;
peerPort_ = peerPort;
peerTitle_ = peerTitle;
ourPort_ = ourPort;
ourTitle_ = new char[1024];
sprintf(ourTitle_, "%s", ourTile);
}
dcm_cmove::~dcm_cmove()
{
if (ourTitle_ != NULL)
{
delete[] ourTitle_;
}
}
void dcm_cmove::set_sleep_after(unsigned long after)
{
sleepAfter = after;
}
void dcm_cmove::set_sleep_during(unsigned long during)
{
sleepDuring = during;
}
void dcm_cmove::set_dimse_timeout(int timeout)
{
dimse_timeout = timeout;
}
void dcm_cmove::set_acse_timeout(int timeout)
{
acse_timeout = timeout;
}
void dcm_cmove::set_cmove_callback(dcm_cmove_callback * callback)
{
cmove_callback = callback;
}
void dcm_cmove::set_cmove_scp_callback(dcm_cmove_storescp_callback * callback)
{
storescp_callback = callback;
}
int dcm_cmove::move_by_patient_id(std::string patient_id)
{
queryModel = QMPatientRoot;
addOverrideKey("0008,0052=PATIENT");
std::string patient_id_ = "0010,0020=";
patient_id_ += patient_id;
addOverrideKey(patient_id_.c_str());
return docmove();
}
int dcm_cmove::move_by_study_uid(std::string study_uid)
{
queryModel = QMStudyRoot;
addOverrideKey("0008,0052=STUDY");
std::string studyinstance_uid_ = "0020,000D=";
studyinstance_uid_ += study_uid;
addOverrideKey(studyinstance_uid_.c_str());
return docmove();
}
int dcm_cmove::move_by_series_uid(std::string study_uid, std::string series_uid)
{
queryModel = QMStudyRoot;
addOverrideKey("0008,0052=SERIES");
std::string studyinstance_uid_ = "0020,000D=";
studyinstance_uid_ += study_uid;
addOverrideKey(studyinstance_uid_.c_str());
std::string seriesinstance_uid_ = "0020,000E=";
seriesinstance_uid_ += series_uid;
addOverrideKey(seriesinstance_uid_.c_str());
return docmove();
}
int dcm_cmove::move_by_image_uid(std::string study_uid, std::string series_uid, std::string image_uid)
{
queryModel = QMStudyRoot;
addOverrideKey("0008,0052=IMAGE");
std::string studyinstance_uid_ = "0020,000D=";
studyinstance_uid_ += study_uid;
addOverrideKey(studyinstance_uid_.c_str());
std::string seriesinstance_uid_ = "0020,000E=";
seriesinstance_uid_ += series_uid;
addOverrideKey(seriesinstance_uid_.c_str());
std::string image_uid_ = "0008,0018=";
image_uid_ += image_uid;
addOverrideKey(image_uid_.c_str());
return docmove();
}
void dcm_cmove::addOverrideKey(const char *s)
{
unsigned int g = 0xffff;
unsigned int e = 0xffff;
int n = 0;
std::string dicName, valStr;
n = sscanf(s, "%x,%x=", &g, &e);
std::string toParse = s;
size_t eqPos = toParse.find('=');
if (n < 2)
{
if (eqPos != std::string::npos)
{
dicName = toParse.substr(0, eqPos).c_str();
valStr = toParse.substr(eqPos + 1, toParse.length());
}
else
{
dicName = s;
}
DcmTagKey key(0xffff, 0xffff);
const DcmDataDictionary& globalDataDict = dcmDataDict.rdlock();
const DcmDictEntry * dicent = globalDataDict.findEntry(dicName.c_str());
dcmDataDict.rdunlock();
if (dicent != NULL)
{
key = dicent->getKey();
g = key.getGroup();
e = key.getElement();
}
else
{
// log << bad key format or dictionary name not found in dictionary
}
}
else
{
if (eqPos != std::string::npos)
{
valStr = toParse.substr(eqPos + 1, toParse.length());
}
}
DcmTag tag(g, e);
if (tag.error() != EC_Normal)
{
// log << unknown tag
}
DcmElement *elem = DcmItem::newDicomElement(tag);
if (elem == NULL)
{
// log << cannot create element for tag
}
if (!valStr.empty())
{
if (elem->putString(valStr.c_str()).bad())
{
// log << cannot put tag value
}
}
if (overrideKeys == NULL)
{
overrideKeys = new DcmDataset;
}
if (overrideKeys->insert(elem, true).bad())
{
// log << cannot insert tag
}
}
OFCondition dcm_cmove::addPresentationContext(T_ASC_Parameters * params, T_ASC_PresentationContextID pid, const char * abstractSyntax)
{
const char *transferSyntax[] = {NULL, NULL, NULL, NULL};
int numTransferSyntaxes = 0;
switch (out_networkTransferSyntax)
{
case EXS_LittleEndianImplicit:
transferSyntax[0] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 1;
break;
case EXS_LittleEndianExplicit:
transferSyntax[0] = UID_LittleEndianExplicitTransferSyntax;
transferSyntax[1] = UID_BigEndianExplicitTransferSyntax;
transferSyntax[2] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 3;
break;
case EXS_BigEndianExplicit:
transferSyntax[0] = UID_BigEndianExplicitTransferSyntax;
transferSyntax[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntax[2] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 3;
break;
default:
if (gLocalByteOrder == EBO_LittleEndian)
{
transferSyntax[0] = UID_LittleEndianExplicitTransferSyntax;
transferSyntax[1] = UID_BigEndianExplicitTransferSyntax;
}
else
{
transferSyntax[0] = UID_BigEndianExplicitTransferSyntax;
transferSyntax[1] = UID_LittleEndianExplicitTransferSyntax;
}
transferSyntax[2] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 3;
break;
}
return ASC_addPresentationContext(params, pid, abstractSyntax, transferSyntax, numTransferSyntaxes);
}
void dcm_cmove::substituteOverrideKeys(DcmDataset *dset)
{
if (overrideKeys == NULL)
return;
DcmDataset keys(*overrideKeys);
unsigned long elemCount = keys.card();
for (unsigned long i = 0; i < elemCount; i++)
{
DcmElement *elem = keys.remove(static_cast<unsigned long>(0));
dset->insert(elem, true);
}
}
OFCondition dcm_cmove::acceptSubAssoc(T_ASC_Network *aNet, T_ASC_Association **assoc)
{
const char *knownAbstractSyntaxes[] =
{
UID_VerificationSOPClass
};
const char* transferSyntaxes[] =
{
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, //10
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, //20
NULL //+1
};
int numTransferSyntaxes;
OFCondition cond = ASC_receiveAssociation(aNet, assoc, maxPDU);
if (cond.good())
{
switch (in_networkTransferSyntax)
{
case EXS_LittleEndianImplicit:
transferSyntaxes[0] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 1;
break;
case EXS_LittleEndianExplicit:
transferSyntaxes[0] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[1] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 3;
break;
case EXS_BigEndianExplicit:
transferSyntaxes[0] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 3;
break;
case EXS_JPEGProcess14SV1:
transferSyntaxes[0] = UID_JPEGProcess14SV1TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_JPEGProcess1:
transferSyntaxes[0] = UID_JPEGProcess1TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_JPEGProcess2_4:
transferSyntaxes[0] = UID_JPEGProcess2_4TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_JPEG2000LosslessOnly:
transferSyntaxes[0] = UID_JPEG2000LosslessOnlyTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_JPEG2000:
transferSyntaxes[0] = UID_JPEG2000TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_JPEGLSLossless:
transferSyntaxes[0] = UID_JPEGLSLosslessTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_JPEGLSLossy:
transferSyntaxes[0] = UID_JPEGLSLossyTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_MPEG2MainProfileAtMainLevel:
transferSyntaxes[0] = UID_MPEG2MainProfileAtMainLevelTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes;
break;
case EXS_MPEG2MainProfileAtHighLevel:
transferSyntaxes[0] = UID_MPEG2MainProfileAtHighLevelTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_MPEG4HighProfileLevel4_1:
transferSyntaxes[0] = UID_MPEG4HighProfileLevel4_1TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_MPEG4BDcompatibleHighProfileLevel4_1:
transferSyntaxes[0] = UID_MPEG4BDcompatibleHighProfileLevel4_1TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_MPEG4HighProfileLevel4_2_For2DVideo:
transferSyntaxes[0] = UID_MPEG4HighProfileLevel4_2_For2DVideoTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_MPEG4HighProfileLevel4_2_For3DVideo:
transferSyntaxes[0] = UID_MPEG4HighProfileLevel4_2_For3DVideoTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_MPEG4StereoHighProfileLevel4_2:
transferSyntaxes[0] = UID_MPEG4StereoHighProfileLevel4_2TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_HEVCMainProfileLevel5_1:
transferSyntaxes[0] = UID_HEVCMainProfileLevel5_1TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_HEVCMain10ProfileLevel5_1:
transferSyntaxes[0] = UID_HEVCMain10ProfileLevel5_1TransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
case EXS_RLELossless:
transferSyntaxes[0] = UID_RLELosslessTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[2] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[3] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 4;
break;
default:
if (acceptAllXfer)
{
transferSyntaxes[0] = UID_JPEG2000TransferSyntax;
transferSyntaxes[1] = UID_JPEG2000LosslessOnlyTransferSyntax;
transferSyntaxes[2] = UID_JPEGProcess2_4TransferSyntax;
transferSyntaxes[3] = UID_JPEGProcess1TransferSyntax;
transferSyntaxes[4] = UID_JPEGProcess14SV1TransferSyntax;
transferSyntaxes[5] = UID_JPEGLSLossyTransferSyntax;
transferSyntaxes[6] = UID_JPEGLSLosslessTransferSyntax;
transferSyntaxes[7] = UID_RLELosslessTransferSyntax;
transferSyntaxes[8] = UID_MPEG2MainProfileAtMainLevelTransferSyntax;
transferSyntaxes[9] = UID_MPEG2MainProfileAtHighLevelTransferSyntax;
transferSyntaxes[10] = UID_MPEG4HighProfileLevel4_1TransferSyntax;
transferSyntaxes[11] = UID_MPEG4BDcompatibleHighProfileLevel4_1TransferSyntax;
transferSyntaxes[12] = UID_MPEG4HighProfileLevel4_2_For2DVideoTransferSyntax;
transferSyntaxes[13] = UID_MPEG4HighProfileLevel4_2_For3DVideoTransferSyntax;
transferSyntaxes[14] = UID_MPEG4StereoHighProfileLevel4_2TransferSyntax;
transferSyntaxes[15] = UID_HEVCMainProfileLevel5_1TransferSyntax;
transferSyntaxes[16] = UID_HEVCMain10ProfileLevel5_1TransferSyntax;
transferSyntaxes[17] = UID_DeflatedExplicitVRLittleEndianTransferSyntax;
if (gLocalByteOrder == EBO_LittleEndian)
{
transferSyntaxes[18] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[19] = UID_BigEndianExplicitTransferSyntax;
}
else
{
transferSyntaxes[18] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[19] = UID_LittleEndianExplicitTransferSyntax;
}
transferSyntaxes[20] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 21;
}
else
{
if (gLocalByteOrder == EBO_LittleEndian)
{
transferSyntaxes[0] = UID_LittleEndianExplicitTransferSyntax;
transferSyntaxes[1] = UID_BigEndianExplicitTransferSyntax;
}
else
{
transferSyntaxes[0] = UID_BigEndianExplicitTransferSyntax;
transferSyntaxes[1] = UID_LittleEndianExplicitTransferSyntax;
}
transferSyntaxes[2] = UID_LittleEndianImplicitTransferSyntax;
numTransferSyntaxes = 3;
}
break;
}
cond = ASC_acceptContextsWithPreferredTransferSyntaxes((*assoc)->params, knownAbstractSyntaxes, DIM_OF(knownAbstractSyntaxes), transferSyntaxes, numTransferSyntaxes);
if (cond.good())
{
cond = ASC_acceptContextsWithPreferredTransferSyntaxes((*assoc)->params, dcmAllStorageSOPClassUIDs, numberOfDcmAllStorageSOPClassUIDs, transferSyntaxes, numTransferSyntaxes);
}
}
if (cond.good())
{
cond = ASC_acknowledgeAssociation(*assoc);
}
if (cond.good())
{
// log << Sub-Association Acknowledged Success
if (ASC_countAcceptedPresentationContexts((*assoc)->params) == 0)
{
// log << but no valid presentation contexes;
}
}
else
{
// log << Sub-Association Acknowleged Failed
ASC_dropAssociation(*assoc);
ASC_destroyAssociation(assoc);
}
return cond;
}
OFCondition dcm_cmove::echoSCP(T_ASC_Association *assoc, T_DIMSE_Message * msg, T_ASC_PresentationContextID presID)
{
T_DIMSE_C_EchoRQ *req = &msg->msg.CEchoRQ;
OFCondition cond = DIMSE_sendEchoResponse(assoc, presID, req, STATUS_Success, NULL);
if (cond.bad())
{
// log << Echo SCP Failed
}
return cond;
}
OFCondition dcm_cmove::storeSCP(T_ASC_Association *assoc, T_DIMSE_Message * msg, T_ASC_PresentationContextID presID)
{
OFCondition cond = EC_Normal;
T_DIMSE_C_StoreRQ *req;
char imageFileName[2048];
req = &msg->msg.CStoreRQ;
if (ignore)
{
#ifdef _WIN32
tmpnam(imageFileName);
#else
OFStandard::strlcpy(imageFileName, NULL_DEVICE_NAME, 2048);
#endif // _WIN32
}
else
{
sprintf(imageFileName, "%s.%s", dcmSOPClassUIDToModality(req->AffectedSOPClassUID), req->AffectedSOPInstanceUID);
}
if (storescp_callback == NULL)
storescp_callback = new dcm_cmove_storescp_callback_default(".");
//will not be called actually
storescp_callback->setAssoc(assoc);
DcmFileFormat dcmff; // ?
storescp_callback->setDcmFileFormat(&dcmff);
storescp_callback->setImageFileName(imageFileName);
if (assoc && assoc->params)
{
const char *aet = assoc->params->DULparams.callingAPTitle;
if (aet)
{
dcmff.getMetaInfo()->putAndInsertString(DCM_SourceApplicationEntityTitle, aet);
}
}
DcmDataset *dset = dcmff.getDataset();
if (bitPreserving)
{
cond = DIMSE_storeProvider(assoc, presID, req, imageFileName, useMetaheader,
NULL, storeSCPCallback, reinterpret_cast<void *>(storescp_callback),
blockMode, dimse_timeout);
}
else
{
cond = DIMSE_storeProvider(assoc, presID, req, NULL, useMetaheader,
&dset, storeSCPCallback, reinterpret_cast<void *>(storescp_callback),
blockMode, dimse_timeout);
}
if (cond.bad())
{
if (!ignore)
{
if (strcmp(imageFileName, NULL_DEVICE_NAME) != 0)
{
OFStandard::deleteFile(imageFileName);
}
}
#ifdef _WIN32
else if (ignore)
{
if (strcmp(imageFileName, NULL_DEVICE_NAME) != 0)
{
OFStandard::deleteFile(imageFileName);
}
}
#endif // _WIN32
}
if (sleepAfter > 0)
{
OFStandard::sleep(static_cast<unsigned int>(sleepDuring));
}
return cond;
}
OFCondition dcm_cmove::subOpSCP(T_ASC_Association **subAssoc)
{
T_DIMSE_Message msg;
T_ASC_PresentationContextID presID;
if (!ASC_dataWaiting(*subAssoc, 0))
return DIMSE_NODATAAVAILABLE;
OFCondition cond = DIMSE_receiveCommand(*subAssoc, blockMode, dimse_timeout, &presID, &msg, NULL);
if (cond == EC_Normal)
{
switch (msg.CommandField)
{
case DIMSE_C_ECHO_RQ:
cond = echoSCP(*subAssoc, &msg, presID);
break;
case DIMSE_C_STORE_RQ:
cond = storeSCP(*subAssoc, &msg, presID);
break;
default:
cond = DIMSE_BADCOMMANDTYPE;
break;
}
}
if (cond == DUL_PEERREQUESTEDRELEASE)
{
cond = ASC_acknowledgeRelease(*subAssoc);
ASC_dropSCPAssociation(*subAssoc);
ASC_destroyAssociation(subAssoc);
return cond;
}
else if (cond == DUL_PEERABORTEDASSOCIATION)
{
}
else if (cond != EC_Normal)
{
cond = ASC_abortAssociation(*subAssoc);
}
if (cond != EC_Normal)
{
ASC_dropAssociation(*subAssoc);
ASC_destroyAssociation(subAssoc);
}
return cond;
}
OFCondition dcm_cmove::moveSCU(T_ASC_Association * assoc, const char * fname)
{
T_ASC_PresentationContextID presID;
T_DIMSE_C_MoveRQ req;
T_DIMSE_C_MoveRSP rsp;
DIC_US msgId = assoc->nextMsgID;
DcmDataset *rspIds = NULL;
const char *sopClass;
DcmDataset *statusDetail = NULL;
DcmFileFormat dcmff;
if (fname != NULL)
{
if (dcmff.loadFile(fname).bad())
{
// log << bad DICOM file
return DIMSE_BADDATA;
}
}
substituteOverrideKeys(dcmff.getDataset());
sopClass = querySyntax[queryModel].moveSyntax;
presID = ASC_findAcceptedPresentationContextID(assoc, sopClass);
if (presID == 0)
{
return DIMSE_NOVALIDPRESENTATIONCONTEXTID;
}
if (cmove_callback == NULL)
cmove_callback = new dcm_cmove_callback_default();
cmove_callback->setAssoc(assoc);
cmove_callback->setPresetnationContextID(presID);
req.MessageID = msgId;
OFStandard::strlcpy(req.AffectedSOPClassUID, sopClass, sizeof(req.AffectedSOPClassUID));
req.Priority = DIMSE_PRIORITY_MEDIUM;
req.DataSetType = DIMSE_DATASET_PRESENT;
if (ourTitle_ == NULL)
{
ourTitle_ = new char[1024];
ASC_getAPTitles(assoc->params, req.MoveDestination, sizeof(req.MoveDestination), ourTitle_, 1023, NULL, 0);
}
else
{
OFStandard::strlcpy(req.MoveDestination, ourTitle_, sizeof(req.MoveDestination));
}
OFCondition cond = DIMSE_moveUser(assoc, presID, &req, dcmff.getDataset(), moveCallback, reinterpret_cast<void *>(cmove_callback),
blockMode, dimse_timeout, net, subOpCallback, reinterpret_cast<void *>(this), &rsp, &statusDetail, &rspIds, ignorePendingDatasets);
if (cond == EC_Normal)
{
if ((rsp.DimseStatus == STATUS_Success) || (rsp.DimseStatus == STATUS_MOVE_Cancel_SubOperationsTerminatedDueToCancelIndication))
{
}
else if (rsp.DimseStatus == STATUS_MOVE_Warning_SubOperationsCompleteOneOrMoreFailures)
{
// log << response with warning
}
else
{
// log << respone with error
}
}
else
{
// log << Move Request Failed
}
if (statusDetail != NULL)
delete statusDetail;
if (rspIds != NULL)
delete rspIds;
return cond;
}
OFCondition dcm_cmove::cmove(T_ASC_Association *assoc, const char *fname)
{
OFCondition cond = EC_Normal;
int n = static_cast<int>(repeatCount);
while (cond.good() && n--)
{
cond = moveSCU(assoc, fname);
}
return cond;
}
int dcm_cmove::docmove()
{
T_ASC_Parameters *params = NULL;
DIC_NODENAME peerHost;
T_ASC_Association *assoc = NULL;
OFStandard::initializeNetwork();
if (!dcmDataDict.isDictionaryLoaded())
return e_no_dictionary_loaded;
T_ASC_NetworkRole role = (ourPort_ > 0) ? NET_ACCEPTORREQUESTOR : NET_REQUESTOR;
OFCondition cond = ASC_initializeNetwork(role, static_cast<int>(ourPort_), acse_timeout, &net);
if (cond.bad())
{
return e_cannot_initialize_network;
}
if (OFStandard::dropPrivileges().bad())
{
return e_cannot_set_uid;
}
cond = ASC_createAssociationParameters(&params, maxPDU);
if (cond.bad())
{
return e_cannot_create_association_parameters;
}
ASC_setAPTitles(params, ourTitle_, peerTitle_, NULL);
sprintf(peerHost, "%s:%d", peerIp_, static_cast<int>(peerPort_));
ASC_setPresentationAddresses(params, OFStandard::getHostName().c_str(), peerHost);
cond = addPresentationContext(params, 1, querySyntax[queryModel].findSyntax);
cond = addPresentationContext(params, 3, querySyntax[queryModel].moveSyntax);
if (cond.bad())
{
return e_cannot_create_association_parameters;
}
cond = ASC_requestAssociation(net, params, &assoc);
if (cond.bad())
{
if (cond == DUL_ASSOCIATIONREJECTED)
{
return e_association_rejected;
}
else
{
return e_cannot_negotiate_association;
}
}
if (ASC_countAcceptedPresentationContexts(params) == 0)
{
return e_no_acceptable_presentation_context;
}
cond = EC_Normal;
cond = cmove(assoc, NULL);
if (cond == EC_Normal)
{
if (abortAssociation)
{
cond = ASC_abortAssociation(assoc);
if (cond.bad())
{
return e_cannot_abort_association;
}
}
else
{
cond = ASC_releaseAssociation(assoc);
if (cond.bad())
{
return e_cannot_release_association;
}
}
}
else if (cond == DUL_PEERREQUESTEDRELEASE)
{
cond = ASC_abortAssociation(assoc);
if (cond.bad())
{
return e_cannot_abort_association;
}
}
else if (cond == DUL_PEERABORTEDASSOCIATION)
{
}
else
{
cond = ASC_abortAssociation(assoc);
if (cond.bad())
{
return e_cannot_abort_association;
}
}
cond = ASC_destroyAssociation(&assoc);
if (cond.bad())
{
return e_cannot_destroy_association;
}
cond = ASC_dropNetwork(&net);
if (cond.bad())
{
return e_cannot_drop_network;
}
OFStandard::shutdownNetwork();
return e_ok;
}
Reference in New Issue View Git Blame Copy Permalink