DCMTK

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_StudyInstanceUID))

{

OFLOG_INFO(dump2dcmLogger, "generating new Study Instance UID");

}

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_SeriesInstanceUID))

{

OFLOG_INFO(dump2dcmLogger, "generating new Series Instance UID");

}

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_SOPInstanceUID))

{

OFLOG_INFO(dump2dcmLogger, "generating new SOP Instance UID");

/* make sure that the file meta information is updated correspondingly */

if (opt_writeMode == EWM_fileformat)

opt_writeMode = EWM_updateMeta;

if (overwriteUIDs || !dataset->tagExistsWithValue(DCM_StudyInstanceUID))

{

OFLOG_INFO(json2dcmLogger, "generating new Study Instance UID");

}

if (overwriteUIDs || !dataset->tagExistsWithValue(DCM_SeriesInstanceUID))

{

OFLOG_INFO(json2dcmLogger, "generating new Series Instance UID");

}

if (overwriteUIDs || !dataset->tagExistsWithValue(DCM_SOPInstanceUID))

{

OFLOG_INFO(json2dcmLogger, "generating new SOP Instance UID");

/* make sure that the file meta information is updated correspondingly */

if (writeMode == EWM_fileformat)

OFCondition result;

char uid[100];

if (uidKey == DCM_StudyInstanceUID)

else if (uidKey == DCM_SeriesInstanceUID)

else if (uidKey == DCM_SOPInstanceUID)

{

// force meta-header to refresh SOP Class/Instance UIDs.

DcmItem* meta_info = dfile->getMetaInfo();

if (meta_info)

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_StudyInstanceUID))

{

OFLOG_INFO(xml2dcmLogger, "generating new Study Instance UID");

}

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_SeriesInstanceUID))

{

OFLOG_INFO(xml2dcmLogger, "generating new Series Instance UID");

}

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_SOPInstanceUID))

{

OFLOG_INFO(xml2dcmLogger, "generating new SOP Instance UID");

}

}

OFLOG_INFO(xml2dcmLogger, "writing DICOM output file: " << opt_ofname);

DcmFileFormat fileformat;

DcmDataset *dataset = fileformat.getDataset();

dataset->putAndInsertString(DCM_SOPClassUID, UID_SecondaryCaptureImageStorage);

dataset->putAndInsertString(DCM_PatientName, "Doe^John");

/* ... */

dataset->putAndInsertUint8Array(DCM_PixelData, pixelData, pixelLength);

#include "dcmtk/config/osconfig.h" /* make sure OS specific configuration is included first */

#include "dcmtk/ofstd/oftypes.h"

#include "dcmtk/dcmdata/dcdefine.h"

// include this file in doxygen documentation

*/

DCMTK_DCMDATA_EXPORT OFBool dcmIsImageStorageSOPClassUID(const char* uid);

* that the generated UID is 64 characters or less.

* If a prefix string is not passed as the second argument a

* default of SITE_INSTANCE_UID_ROOT (see below) will be used.

* Otherwise the supplied prefix string will appear at the beginning

* The UID is created by appending to the prefix the following:

* - the host ID (if obtainable, zero otherwise),

* - the process ID (if obtainable, zero otherwise),

* - the system calendar time, and

* - an accumulating counter for this process.

*/

DCMTK_DCMDATA_EXPORT char *dcmGenerateUniqueIdentifier(char *uid, const char* prefix=NULL);

/** performs a table lookup and returns a short modality identifier

* that can be used for building file names etc.

* Identifiers are defined for all storage SOP classes.

if (cond.bad() || value.empty())

{

char newUID[100];

cond = dset->putAndInsertOFStringArray(DCM_SeriesInstanceUID, newUID);

if (cond.bad())

return makeOFCondition(OFM_dcmdata, 18, OF_error, "Unable to write Series Instance UID to file");

if (cond.bad() || value.empty())

{

char newUID[100];

cond = dset->putAndInsertOFStringArray(DCM_StudyInstanceUID, newUID);

if (cond.bad())

return makeOFCondition(OFM_dcmdata, 18, OF_error, "Unable to write Study Instance UID to file");

if (cond.bad() || value.empty())

{

char newUID[100];

cond = dset->putAndInsertOFStringArray(DCM_SOPInstanceUID, newUID);

if (cond.bad())

return makeOFCondition(OFM_dcmdata, 18, OF_error, "Unable to write SOP Instance UID to file");

// compute defaults for some type 1 attributes

char newUID[70];

OFDateTime now = OFDateTime::getCurrentDateTime();

OFString contentDate;

OFString contentTime;

if (result.good()) result = dataset->putAndInsertString(DCM_SOPClassUID, UID_SecondaryCaptureImageStorage);

// SOP Instance UID - only insert if missing.

if (result.good()) result = insertStringIfMissing(dataset, DCM_SOPInstanceUID, buf);

// Type 1 attributes - insert with value if missing

if (result.good()) result = insertStringIfMissing(dataset, DCM_StudyInstanceUID, buf);

if (result.good()) result = insertStringIfMissing(dataset, DCM_SeriesInstanceUID, buf);

if (result.good()) result = insertStringIfMissing(dataset, DCM_ConversionType, "WSD");

if (result.good()) result = insertStringIfMissing(dataset, DCM_Modality, "OT");

DcmElement *elem = new DcmUniqueIdentifier(DCM_SOPInstanceUID);

if (elem)

{

dataset->insert(elem, OFTrue); // replace SOP Instance UID

else delete elem;

} else result = EC_MemoryExhausted;

if (studyUID_.empty())

{

studyUID_ = buf;

}

if (seriesUID_.empty())

{

seriesUID_ = buf;

}

{

DCMDATA_DEBUG("Frame of Reference UID " << DCM_FrameOfReferenceUID << " value missing, generating a new one."

);

frameOfReferenceUID_ = buf;

}

else

{

DCMDATA_DEBUG("Frame of Reference UID " << DCM_FrameOfReferenceUID << " value was faulty, generating a new one."

);

frameOfReferenceUID_ = buf;

}

}

if (result.good()) result = dataset->putAndInsertString(DCM_BurnedInAnnotation, annotation_ ? "YES" : "NO");

OFStandard::snprintf(buf, sizeof(buf), "%ld", OFstatic_cast(long, instance_));

if (result.good()) result = dataset->putAndInsertString(DCM_InstanceNumber, buf);

if (result.good()) result = dataset->putAndInsertString(DCM_StudyInstanceUID, studyUID_.c_str());

if (result.good()) result = dataset->putAndInsertString(DCM_SeriesInstanceUID, seriesUID_.c_str());

if (result.good()) result = dataset->putAndInsertString(DCM_SOPInstanceUID, buf);

else if (elem->getLength() == 0)

{

char uid[128];

OFstatic_cast(DcmUniqueIdentifier *, elem)->putString(uid);

DCMDATA_DEBUG("DcmFileFormat::checkMetaHeaderValue() use new generated SOPInstanceUID [" << uid << "]");

}

#include "dcmtk/dcmdata/dcpxitem.h" /* for class DcmPixelItem */

#include "dcmtk/dcmdata/dcvrpobw.h" /* for class DcmPolymorphOBOW */

#include "dcmtk/dcmdata/dcswap.h" /* for swapIfNecessary() */

DcmRLECodecDecoder::DcmRLECodecDecoder()

END_EXTERN_C

#include "dcmtk/ofstd/ofstream.h"

#include "dcmtk/dcmdata/dcuid.h"

#include "dcmtk/dcmdata/dctypes.h"

#include "dcmtk/ofstd/ofthread.h"

#include "dcmtk/ofstd/ofvector.h"

#include "dcmtk/ofstd/ofsockad.h"

/** struct for mapping UID values to keywords, names and properties

*/

struct UIDNameMap {

* Global variable storing the return value of gethostid().

* Since the variable is not declared in the header file it can only be used

* within this source file. Any access to or modification of its value is

*/

static unsigned long hostIdentifier = 0;

static void

addUIDComponent(char* uid, const char* s)

{

if (OFStandard::strlcat(uid, s, maxUIDLen + 1) >= maxUIDLen + 1) // maxUIDLen+1 because strlcat() wants the size of the buffer, not the permitted number of characters.

{

}

stripTrailing(uid, '.');

}

return (i < 0) ? OFstatic_cast(unsigned long, -i) : OFstatic_cast(unsigned long, i);

}

{

char buf[128]; /* be very safe */

uidCounterMutex.unlock();

#endif

addUIDComponent(uid, SITE_INSTANCE_UID_ROOT);

}

OFStandard::snprintf(buf, sizeof(buf), ".%lu", hostIdentifier);

addUIDComponent(uid, buf);

OFStandard::snprintf(buf, sizeof(buf), ".%u", counter);

addUIDComponent(uid, buf);

return uid;

}

OFTEST_REGISTER(dcmdata_attribute_matching);

OFTEST_REGISTER(dcmdata_newDicomElementPrivate);

OFTEST_REGISTER(dcmdata_generateUniqueIdentifier);

OFTEST_REGISTER(dcmdata_xferLookup_1);

OFTEST_REGISTER(dcmdata_xferLookup_2);

OFTEST_REGISTER(dcmdata_xferLookup_3);

*

* Author: Marco Eichelberg

*

*

*/

#include "dcmtk/config/osconfig.h" /* make sure OS specific configuration is included first */

#include "dcmtk/ofstd/oftest.h"

#include "dcmtk/dcmdata/dcuid.h"

OFTEST(dcmdata_generateUniqueIdentifier)

{

// test generation of UIDs. We generate 10000 UIDs in quick

// succession and check if they are pair-wise different.

// This will also catch any application error during UID generation.

for (size_t i = 0; i < 10000; ++i)

{

// generate UID

// compare with the previously generated UID, should be different.

generated_uid_is_not_unique = (previousuid != uid);

if (result.good())

{

char buf[100];

result = dstDataset.putAndInsertOFStringArray(DCM_SOPInstanceUID, buf);

}

return result;

// Create Concatenation UID

char buf[65];

// Set initial context, i.e. initialize for first frame

m_currentPerFrameItem = OFstatic_cast(DcmItem*, m_srcPerFrameFG->nextInContainer(NULL));

if (uid.empty())

{

char buf[100];

uid = buf;

DCMFG_WARN("SOP Instance UID of Concatenation Source (0020,0242) not set, created new SOP Instance UID "

<< uid);

}

// create new SOP instance UID

char new_uid[100];

}

// ======================================================================

OFString seriesInstanceUID;

OFString laterality;

OFString seriesNumber = "1";

cond = diffImage->putAndInsertOFStringArray(DCM_Modality, modality);

if (cond.bad()) return cond;

OFString instanceCreatorUID = "1.2.276.0.7230010.3.1.2.1787205428.20064.1535731842.951308";

OFString InstanceNumber = "1";

if (src->findAndGetOFStringArray(DCM_SpecificCharacterSet, specificCharacterSet).bad()) specificCharacterSet = "";

cond = diffImage->putAndInsertOFStringArray(DCM_SOPInstanceUID, sOPInstanceUID);

if (cond.bad()) return cond;

#include "dcmtk/dcmdata/dcdeftag.h" /* for tag constants */

#include "dcmtk/dcmdata/dcpixel.h" /* for DcmPixelData */

#include "dcmtk/dcmdata/dcsequen.h" /* for DcmSequenceOfItems */

#include "dcmtk/ofstd/ofstd.h"

switch (level)

{

case 0:

break;

case 1:

break;

case 2:

break;

default:

}

return uid;

}

return OFFalse;

}

char forUID[100];

{

OFCHECK_FAIL("Cannot set SOP Instance UID");

return OFFalse;

{

// create unique filename by generating a temporary UID and using ".X." as an infix

char buf[70];

OFStandard::snprintf(imageFileName, sizeof(imageFileName), "%s%c%s.X.%s%s", opt_outputDirectory.c_str(), PATH_SEPARATOR,

dcmSOPClassUIDToModality(req->AffectedSOPClassUID, "UNKNOWN"),

buf, opt_fileNameExtension.c_str());

{

OFString prefix = basePrefix + "." + intToString(counter);

char uidbuf[65];

return uid;

}

case FGM_UniqueFromNewUID:

{

char uidBuffer[70];

OFOStringStream stream;

stream << dcmSOPClassUIDToModality(sopClassUID.c_str(), "UNKNOWN")

<< ".X." << uidBuffer << FilenameExtension << OFStringStream_ends;

// a generated UID contains the process ID and current time.

// Adding it to the PRNG seed guarantees that we have different seeds for different processes.

char randomUID[65];

tLayer->addPRNGseed(randomUID, strlen(randomUID));

}

// Adding it to the PRNG seed guarantees that we have different seeds for

// different child processes.

char randomUID[65];

if (tLayer) tLayer->addPRNGseed(randomUID, strlen(randomUID));

#endif

handleClient(&assoc, dbfolder, networkBitPreserving, useTLS, opt_correctUIDPadding);

// a generated UID contains the process ID and current time.

// Adding it to the PRNG seed guarantees that we have different seeds for different processes.

char randomUID[65];

tLayer->addPRNGseed(randomUID, strlen(randomUID));

}

#define SET_UID(a_name) \

if (result==EC_Normal) \

{ \

}

#endif

OFString aString;

char *puid = NULL;

DVPSHelper::currentDate(aString);

DVPSHelper::setDefault(result, instanceCreationDate, aString.c_str());

DVPSHelper::currentTime(aString);

if ((result==EC_Normal)&&(replaceSOPInstanceUID ||(sOPInstanceUID.getLength()==0)))

{

DVPSHelper::currentDate(aString);

DVPSHelper::setDefault(result, instanceCreationDate, aString.c_str() );

DVPSHelper::currentTime(aString);

DVPSHelper::currentTime(aString);

result = presentationCreationTime.putString(aString.c_str());

}

if (result==EC_Normal) result = seriesNumber.putString(DEFAULT_seriesNumber);

/* If no other character set is specified by the image, we use ISO_IR 100 as the default */

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_Modality, "OT");

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_ConversionType, "WSD");

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_PhotometricInterpretation, "MONOCHROME2");

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_SOPInstanceUID, (instanceUID ? instanceUID : newuid));

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_SeriesInstanceUID, newuid);

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_StudyInstanceUID, newuid);

if (EC_Normal==status) status = DVPSHelper::putUint16Value(dataset, DCM_SamplesPerPixel, 1);

if (EC_Normal==status) status = DVPSHelper::putUint16Value(dataset, DCM_Rows, rows);

releaseDatabase();

char uid[100];

DcmQueryRetrieveDatabaseStatus dbStatus(STATUS_Success);

char imageFileName[MAXPATHLEN+1];

// SOP Common Module

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_SOPClassUID, UID_RETIRED_HardcopyGrayscaleImageStorage);

theInstanceUID = (instanceUID ? instanceUID : newuid);

if (EC_Normal==status) status = DVPSHelper::putStringValue(dataset, DCM_SOPInstanceUID, theInstanceUID.c_str());

DVPSHelper::currentDate(aString);

releaseDatabase();

char uid[100];

DcmQueryRetrieveDatabaseStatus dbStatus(STATUS_Success);

char imageFileName[MAXPATHLEN+1];

{

if (instanceUID) status = pPrint->setInstanceUID(instanceUID); else

{

status = pPrint->setInstanceUID(newuid);

}

if (EC_Normal == status) status = pPrint->write(*dataset, writeRequestedImageSize, OFTrue, OFTrue, OFFalse);

releaseDatabase();

char uid[100];

DcmQueryRetrieveDatabaseStatus dbStatus(STATUS_Success);

char imageFileName[MAXPATHLEN+1];

// SOP Common Module

if (EC_Normal==writeresult) writeresult = DVPSHelper::putStringValue(rspDataset, DCM_SOPClassUID, UID_RETIRED_HardcopyGrayscaleImageStorage);

if (EC_Normal==writeresult) writeresult = referencedSOPClassUID.putString(UID_RETIRED_HardcopyGrayscaleImageStorage);

if (EC_Normal==writeresult) writeresult = DVPSHelper::putStringValue(rspDataset, DCM_SOPInstanceUID, newuid);

if (EC_Normal==writeresult) writeresult = referencedSOPInstanceUID.putString(newuid);

DVPSHelper::currentDate(aString);

OFListConstIterator(DVPSImageBoxContent *) first = arg.list_.begin();

OFListConstIterator(DVPSImageBoxContent *) last = arg.list_.end();

while (first != last)

list_.push_back((*first)->clone());

++first;

}

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

OFListIterator(DVPSImageBoxContent *) last = list_.end();

while (first != last)

delete (*first);

first = list_.erase(first);

}

DVPSImageBoxContent *newImage = NULL;

DcmSequenceOfItems *dseq=NULL;

DcmItem *ditem=NULL;

if (EC_Normal == dset.search(DCM_RETIRED_ImageBoxContentSequence, stack, ESM_fromHere, OFFalse) && (stack.top()->ident() == EVR_SQ))

{

dseq=(DcmSequenceOfItems *)stack.top();

} else result = EC_MemoryExhausted;

}

}

return result;

}

OFCondition DVPSImageBoxContent_PList::write(

DcmItem &dset,

size_t numItems,

OFBool ignoreEmptyImages,

OFBool writeReferencedPLUTSQ)

DcmItem *ditem=NULL;

OFBool working = OFTrue;

unsigned long numWritten = 0;

dseq = new DcmSequenceOfItems(DCM_RETIRED_ImageBoxContentSequence);

if (dseq)

{

if (ditem)

{

result = (*first)->write(*ditem, writeRequestedImageSize, writeReferencedPLUTSQ);

{

numWritten++;

} else delete ditem;

} else result = EC_MemoryExhausted;

if (size()==0) return EC_IllegalCall; // can't write if sequence is empty

OFCondition result = EC_Normal;

unsigned long counter = 1;

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

OFListIterator(DVPSImageBoxContent *) last = list_.end();

while ((first != last)&&(EC_Normal == result))

result = (*first)->createDefaultValues(renumber, counter++, ignoreEmptyImages);

++first;

}

OFCondition DVPSImageBoxContent_PList::addImageBox(DVPSImageBoxContent * box)

{

list_.push_back(box);

}

OFCondition DVPSImageBoxContent_PList::setRequestedDecimateCropBehaviour(DVPSDecimateCropBehaviour value)

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

OFListIterator(DVPSImageBoxContent *) last = list_.end();

while (first != last)

result = (*first)->setRequestedDecimateCropBehaviour(value);

if (EC_Normal != result) return result;

++first;

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->hasAdditionalSettings();

}

OFCondition DVPSImageBoxContent_PList::setImagePolarity(size_t idx, const char *value)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->setPolarity(value);

}

OFCondition DVPSImageBoxContent_PList::setImageRequestedSize(size_t idx, const char *value)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->setRequestedImageSize(value);

}

OFCondition DVPSImageBoxContent_PList::setImageMagnificationType(size_t idx, const char *value)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->setMagnificationType(value);

}

OFCondition DVPSImageBoxContent_PList::setImageSmoothingType(size_t idx, const char *value)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->setSmoothingType(value);

}

OFCondition DVPSImageBoxContent_PList::setImageConfigurationInformation(size_t idx, const char *value)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->setConfigurationInformation(value);

}

OFCondition DVPSImageBoxContent_PList::setImageSOPInstanceUID(size_t idx, const char *value)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->setSOPInstanceUID(value);

}

const char *DVPSImageBoxContent_PList::getImagePolarity(size_t idx)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getPolarity();

}

const char *DVPSImageBoxContent_PList::getImageRequestedSize(size_t idx)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getRequestedImageSize();

}

const char *DVPSImageBoxContent_PList::getImageMagnificationType(size_t idx)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getMagnificationType();

}

const char *DVPSImageBoxContent_PList::getImageSmoothingType(size_t idx)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getSmoothingType();

}

const char *DVPSImageBoxContent_PList::getImageConfigurationInformation(size_t idx)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getConfigurationInformation();

}

const char *DVPSImageBoxContent_PList::getSOPInstanceUID(size_t idx)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getSOPInstanceUID();

}

const char *DVPSImageBoxContent_PList::getReferencedPresentationLUTInstanceUID(size_t idx)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getReferencedPresentationLUTInstanceUID();

}

OFCondition DVPSImageBoxContent_PList::setAllImagesToDefault()

++first;

if (EC_Normal != result) return result;

}

}

OFCondition DVPSImageBoxContent_PList::getImageReference(size_t idx, const char *&studyUID, const char *&seriesUID, const char *&instanceUID)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->getImageReference(studyUID, seriesUID, instanceUID);

}

OFCondition DVPSImageBoxContent_PList::prepareBasicImageBox(size_t idx, DcmItem &dset)

{

DVPSImageBoxContent *box = getImageBox(idx);

if (box) return box->prepareBasicImageBox(dset);

}

OFBool DVPSImageBoxContent_PList::presentationLUTInstanceUIDisUsed(const char *uid)

OFString uidS;

if (uid) uidS = uid;

const char *c;

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

while (first != last)

{

c = (*first)->getReferencedPresentationLUTInstanceUID();

OFString aString;

OFBool found;

OFListIterator(char *) uidfirst;

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

while (first != last)

{

c = (*first)->getReferencedPresentationLUTInstanceUID();

if ((c == NULL)||(strlen(c)==0)) c = filmBox;

aString = c; // aString now contains the UID of the P-LUT to be used for this image, if any.

uidfirst = uidList.begin();

found = OFFalse;

while (uidfirst != uidlast)

{

{

found = OFTrue;

break;

OFBool DVPSImageBoxContent_PList::printSCPCreate(

unsigned long numBoxes,

const char *aetitle)

{

clear();

box = new DVPSImageBoxContent();

if (box)

{

(EC_Normal == box->setUIDsAndAETitle(studyUID, seriesUID, aetitle)))

{

list_.push_back(box);

DcmItem *ditem=NULL;

DcmUniqueIdentifier *uid=NULL;

const char *instanceUID=NULL;

dseq = new DcmSequenceOfItems(DCM_ReferencedImageBoxSequence);

if (dseq)

{

if (ditem)

{

uid = new DcmUniqueIdentifier(DCM_ReferencedSOPClassUID);

if (EC_Normal == result) result = ditem->insert(uid, OFTrue /*replaceOld*/); else delete uid;

uid = new DcmUniqueIdentifier(DCM_ReferencedSOPInstanceUID);

instanceUID = (*first)->getSOPInstanceUID();

if (EC_Normal == result) result = ditem->insert(uid, OFTrue /*replaceOld*/); else delete uid;

if (result==EC_Normal) dseq->insert(ditem); else delete ditem;

{

OFBool result = OFTrue;

OFListConstIterator(DVPSImageBoxContent *) first = list_.begin();

while (first != last)

{

result = result && (*first)->matchesPresentationLUT(align);

++first;

return result;

}

DVPSImageBoxContent *DVPSImageBoxContent_PList::duplicateImageBox(const char *uid)

{

if (uid == NULL) return NULL;

OFString aString(uid);

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

while (first != last)

{

if (aString == (*first)->getSOPInstanceUID()) return (*first)->clone();

++first;

return NULL;

}

OFBool DVPSImageBoxContent_PList::haveImagePositionClash(const char *uid, Uint16 position)

{

if (uid == NULL) return OFFalse;

OFString aString(uid);

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

while (first != last)

{

if (((*first)->getImageBoxPosition() == position)&&(aString != (*first)->getSOPInstanceUID())) return OFTrue; //clash

++first;

return OFFalse;

}

OFString aString(newImageBox->getSOPInstanceUID());

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

while (first != last)

{

if (aString == (*first)->getSOPInstanceUID())

first = list_.erase(first);

}

else ++first;

list_.push_back(newImageBox);

}

OFBool DVPSImageBoxContent_PList::emptyPageWarning()

{

OFListIterator(DVPSImageBoxContent *) first = list_.begin();

while (first != last)

{

if ((*first)->getImageBoxPosition() > 0) return OFFalse;

// no match, store new LUT

char uid[100];

myLUT->setSOPInstanceUID(uid);

list_.push_back(myLUT);

result = myLUT->getSOPInstanceUID();

strncpy(rsp.msg.NCreateRSP.AffectedSOPInstanceUID, rq.msg.NCreateRQ.AffectedSOPInstanceUID, sizeof(DIC_UI));

} else {

// we generate our own instance UID

}

rsp.msg.NCreateRSP.DataSetType = DIMSE_DATASET_NULL;

OFBool omitFlag = dviface.getTargetPrintSCPOmitSOPClassUIDFromCreateResponse(cfgname);

peerTitle, usePLUTinFilmSession, presentationLUTList))

filmSession = newSession;

char uid[100];

} else {

DCMPSTAT_WARN("cannot create film session, out of memory.");

rsp.msg.NCreateRSP.DimseStatus = STATUS_N_ProcessingFailure;

}

DVPSHelper::putStringValue(dset, DCM_SOPClassUID, PSTAT_DIMSE_LOG_STORAGE_UID);

DVPSHelper::currentDate(aString);

DVPSHelper::putStringValue(dset, DCM_InstanceCreationDate, aString.c_str());

DVPSHelper::currentTime(aString);

if ((result==EC_Normal)&&(sOPInstanceUID.getLength()==0))

{

DVPSHelper::currentDate(aString);

if (result==EC_Normal) result = instanceCreationDate.putString(aString.c_str());

DVPSHelper::currentTime(aString);

if ((result==EC_Normal)&&(studyInstanceUID.getLength()==0))

{

DVPSHelper::currentDate(aString);

if (result==EC_Normal) result = studyDate.putString(aString.c_str());

DVPSHelper::currentTime(aString);

{

// generate a new UID for the "global" presentation LUT

char uid[100];

globalPresentationLUT.setSOPInstanceUID(uid);

result = referencedPresentationLUTInstanceUID.putString(uid);

}

{

char instanceuid[100];

const char *lutUID = presentationLUTList.addPresentationLUT(presentationlut, inversePLUT);

retrieveaetitle, refstudyuid, refseriesuid, refsopclassuid,

refsopinstanceuid, requestedimagesize, patientid, lutUID);

}

if (displayformat && text)

{

char newuid[70];

deleteAnnotations();

result = annotationContentList.addAnnotationBox(newuid, text, position);

if (EC_Normal==result) result = annotationDisplayFormatID.putString(displayformat);

if (result.good())

{

char newUID[66];

DcmUniqueIdentifier *elemSigUID = new DcmUniqueIdentifier(DCM_DigitalSignatureUID);

if (elemSigUID)

{

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_StudyInstanceUID))

{

OFLOG_INFO(xml2dsrLogger, "generating new Study Instance UID");

}

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_SeriesInstanceUID))

{

OFLOG_INFO(xml2dsrLogger, "generating new Series Instance UID");

}

if (opt_overwriteUIDs || !dataset->tagExistsWithValue(DCM_SOPInstanceUID))

{

OFLOG_INFO(xml2dsrLogger, "generating new SOP Instance UID");

}

}

/* write DICOM file */

{

if (verboseMode)

DCMSR_DEBUG(" Generating new value for SOP Instance UID");

/* set instance creation date to current date (YYYYMMDD) */

InstanceCreationDate.putOFStringArray(currentDate(tmpString));

/* set instance creation time to current time (HHMMSS) */

{

if (verboseMode)

DCMSR_DEBUG(" Generating new value for Study Instance UID");

}

/* create new series instance UID if required */

if (SeriesInstanceUID.isEmpty())

{

if (verboseMode)

DCMSR_DEBUG(" Generating new value for Series Instance UID");

}

/* check and set content date if required */

} Notation;

/**

*/

static OFUUID const nil;

/**

*/

static OFUUID const max;

/**

* Checks if this OFUUID is equal to @ref OFUUID::max.

* section 5.10 for details.

*

* @return OFTrue iff all bits of @ref data_ are one (1).

/**

* Checks if this OFUUID is equal to @ref OFUUID::nil.

* section 5.9 for details.

*

* @return OFTrue iff all bits of @ref data_ are zero (0).

*

* @return A OFshared_ptr encapsulating a newly created OFUUID instance.

* @warning The returned object may contain a null pointer (@ref

*/

static OFshared_ptr<OFUUID> create(rnd8 const & = getRND8);

ms_since_unix_epoch.ladd(OFstatic_cast(Uint32, uli.LowPart));

ms_since_unix_epoch.hadd(OFstatic_cast(Uint32, uli.HighPart));

// struct timeval {

// time_t tv_sec; /* seconds */