public DicomFile CreateEncapsulatedPdf(string filePath)
{
var dataset = new DicomDataset();
dataset.AddOrUpdate(DicomTag.PatientName, PatientName);
dataset.AddOrUpdate(DicomTag.PatientID, PatientId);
dataset.AddOrUpdate(DicomTag.AccessionNumber, AccessionNumber);
if (Date != null)
{
dataset.AddOrUpdate(DicomTag.StudyDate, Date.Value);
}
dataset.AddOrUpdate(DicomTag.StudyDescription, Description);
dataset.AddOrUpdate(DicomTag.StudyInstanceUID, Uid);
dataset.AddOrUpdate(DicomTag.Modality, "DOC");
dataset.AddOrUpdate(DicomTag.ConversionType, "WSD");
dataset.AddOrUpdate(DicomTag.SeriesInstanceUID, DicomUID.Generate());
dataset.AddOrUpdate(DicomTag.SOPClassUID, DicomUID.EncapsulatedPDFStorage);
dataset.AddOrUpdate(DicomTag.SOPInstanceUID, DicomUID.Generate());
dataset.AddOrUpdate(DicomTag.DocumentTitle, Path.GetFileNameWithoutExtension(filePath));
dataset.AddOrUpdate(DicomTag.MIMETypeOfEncapsulatedDocument, "application/pdf");
dataset.AddOrUpdate(DicomTag.EncapsulatedDocument, File.ReadAllBytes(filePath));
return(new DicomFile(dataset));
}
public void ReadWithCustomLargeObjectSize()
{
var ds = new DicomDataset
{
{ DicomTag.SOPInstanceUID, DicomUID.Generate() },
{ DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage },
{ DicomTag.ImageComments, " ".PadLeft(8000) }
};
var df = new DicomFile(ds);
var memoryStream = new MemoryStream();
df.Save(memoryStream);
// read with default option
memoryStream.Position = 0;
var defaultFile = DicomFile.Open(memoryStream);
var imageComment = defaultFile.Dataset.GetDicomItem <DicomLongText>(DicomTag.ImageComments);
Assert.IsType <MemoryByteBuffer>(imageComment.Buffer);
// read with custom option
memoryStream.Position = 0;
var customFile = DicomFile.Open(memoryStream, largeObjectSize: 4000);
imageComment = customFile.Dataset.GetDicomItem <DicomLongText>(DicomTag.ImageComments);
Assert.IsType <StreamByteBuffer>(imageComment.Buffer);
}
public static DicomFile GetRtStructFile(RadiotherapyStruct rtStruct)
{
var file = new DicomFile();
var ds = file.Dataset;
// We must use the same UID for SOPInstanceUID & MediaStorageSOPInstanceUID
DicomUID sopInstanceUID = DicomUID.Generate();
file.FileMetaInfo.MediaStorageSOPClassUID = DicomUID.RTStructureSetStorage;
file.FileMetaInfo.MediaStorageSOPInstanceUID = sopInstanceUID;
// Fo-Dicom has a sub-optimal policy for this - using the machine name - we remove this
file.FileMetaInfo.Remove(DicomTag.SourceApplicationEntityTitle);
// It is very important that we only use ImplicitVRLittleEndian here, otherwise large contours
// can exceed the maximum length of a an explicit VR.
file.FileMetaInfo.TransferSyntax = DicomTransferSyntax.ImplicitVRLittleEndian;
//WRITE INSTANCE UID AND SOP CLASS UID
ds.Add(DicomTag.SOPClassUID, DicomUID.RTStructureSetStorage);
ds.Add(DicomTag.SOPInstanceUID, sopInstanceUID);
RadiotherapyStruct.Write(ds, rtStruct);
return(file);
}
public async Task AcceptStoreContexts()
{
int port = Ports.GetNext();
using (DicomServerFactory.Create <AcceptOnlyEchoStoreProvider>(port))
{
var echoReq = new DicomCEchoRequest();
DicomStatus echoStatus = DicomStatus.Pending;
echoReq.OnResponseReceived += (req, resp) => echoStatus = resp.Status;
var storeReq = new DicomCStoreRequest(TestData.Resolve("CT1_J2KI"));
DicomStatus storeStatus = DicomStatus.Pending;
storeReq.OnResponseReceived += (req, resp) => storeStatus = resp.Status;
var filmSession = new FilmSession(DicomUID.BasicFilmSession, DicomUID.Generate());
var printReq = new DicomNCreateRequest(filmSession.SOPClassUID, filmSession.SOPInstanceUID);
DicomStatus printStatus = DicomStatus.Pending;
printReq.OnResponseReceived += (req, resp) => printStatus = resp.Status;
var client = DicomClientFactory.Create("127.0.0.1", port, false, "SCU", "ANY-SCP");
await client.AddRequestsAsync(new DicomRequest[] { echoReq, storeReq, printReq });
await client.SendAsync();
Assert.Equal(DicomStatus.Success, echoStatus);
Assert.Equal(DicomStatus.Success, storeStatus);
Assert.Equal(DicomStatus.SOPClassNotSupported, printStatus);
}
}
private UpdateData createUpdateObject(string studyFilePath, int fileSeriesNumber)
{
UpdateData updateData = new UpdateData();
DicomUID newSOPInstanceId = DicomUID.Generate(_studyID, fileSeriesNumber);
DicomUID newSeriesInstanceId = DicomUID.Generate(_studyID, fileSeriesNumber);
DicomUID newMediaStorageSOPInstanceId = DicomUID.Generate(_studyID, fileSeriesNumber);
//Set File Path
updateData.DicomFileName = studyFilePath;
//Add in the user input
updateData.UpdateDataset.Add(_patientNameTag, txtPatientNameInput.Text);
updateData.UpdateDataset.Add(_patientIdTag, _patientId);
updateData.UpdateDataset.Add(_patientDOBTag, txtPatientDOBInput.Text);
updateData.UpdateDataset.Add(_studyDescriptionTag, txtStudyDescrptionInput.Text);
updateData.UpdateDataset.Add(_studyDateTag, txtStudyDateInput.Text);
updateData.UpdateDataset.Add(_accessionNumberTag, _accessionNumber);
updateData.UpdateDataset.Add(_referringPhysiciansNameTag, txtReferringPhysicianNameInput.Text);
updateData.UpdateDataset.Add(new DicomTag(DicomConstTags.StudyInstanceUID), _studyID.UID);
updateData.UpdateDataset.Add(new DicomTag(DicomConstTags.SOPInstanceUID), newSOPInstanceId.UID);
updateData.UpdateDataset.Add(new DicomTag(DicomConstTags.SeriesInstanceUID), newSeriesInstanceId.UID);
//Add in the Meta Info
updateData.UpdateMetadata.Add(new DicomTag(DicomConstTags.MediaStorageSOPInstanceUID), newMediaStorageSOPInstanceId.UID);
return(updateData);
}
private List <UpdateData> generateUpdateObjectList(string studyDir)
{
toolstripStatuslbl.Text = "Preparing files for anonymization";
Random randomNumber = new Random();
List <UpdateData> updateList = new List <UpdateData>();
//Set Study ID
_studyID = DicomUID.Generate();
//Set Patient ID and Accession Number based on user random request
if (chkbxRandomPatientId.Checked == true)
{
_patientId = randomNumber.Next(1000, 99999).ToString();
}
if (chkbxRandomAccessionNumber.Checked == true)
{
_accessionNumber = randomNumber.Next(1000, 99999).ToString();
}
foreach (string dcmFile in Directory.GetFiles(studyDir, "*", SearchOption.AllDirectories))
{
if (dcmFile.EndsWith(".dcm"))
{
int seriesNumber = getSeriesNumberFromDcm(dcmFile);
updateList.Add(createUpdateObject(dcmFile, seriesNumber));
}
}
return(updateList);
}
/// <summary>
/// Construct new film session from scratch
/// </summary>
/// <param name="sopClassUID">Film session SOP Class UID</param>
/// <param name="sopInstance">Film session SOP instance UID</param>
/// <param name="isColor">Color images?</param>
public FilmSession(DicomUID sopClassUID, DicomUID sopInstance = null, bool isColor = false)
{
InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
if (sopClassUID == null)
{
throw new ArgumentNullException(nameof(sopClassUID));
}
SOPClassUID = sopClassUID;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
#if NET35
SOPInstanceUID = DicomUID.Generate();
#else
SOPInstanceUID = DicomUIDGenerator.GenerateDerivedFromUUID();
#endif
}
else
{
SOPInstanceUID = sopInstance;
}
Add(DicomTag.SOPClassUID, SOPClassUID);
Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
BasicFilmBoxes = new List <FilmBox>();
PresentationLuts = new List <PresentationLut>();
IsColor = isColor;
}
/// <summary>
/// Initializes a new instance of the <see cref="PresentationLut"/> class.
/// </summary>
/// <param name="sopInstance">SOP Instance UID associated with the Presentation LUT information object. If <code>null</code>,
/// a UID will be automatically generated.</param>
public PresentationLut(DicomUID sopInstance = null)
{
InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
SopInstanceUid = string.IsNullOrEmpty(sopInstance?.UID) ? DicomUID.Generate() : sopInstance;
CreateLutSequence();
}
public void Generate_ReturnsValidUid()
{
var uid = DicomUID.Generate();
Assert.True(DicomUID.IsValidUid(uid.UID));
Assert.True(uid.UID.Length <= 64); // Currently not checked by DicomUID.IsValid
}
/// <summary>
/// Construct new film session from scratch
/// </summary>
public FilmSession(DicomUID sopClassUID, DicomUID sopInstance = null, bool isColor = false)
: base()
{
this.InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
if (sopClassUID == null)
{
throw new ArgumentNullException("sopClassUID");
}
SOPClassUID = sopClassUID;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
this.Add(DicomTag.SOPClassUID, SOPClassUID);
this.Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
BasicFilmBoxes = new List <FilmBox>();
PresentationLuts = new List <PresentationLut>();
IsColor = isColor;
}
public void Constructor_FromDataset_SopInstanceUidMaintained()
{
var expected = DicomUID.Generate();
var presentationLut = new PresentationLut(expected, new DicomDataset());
var actual = presentationLut.SopInstanceUid;
Assert.Equal(expected, actual);
}
public void Generate_ReturnsDifferentUidsEachTime()
{
// Note: it is statistically not possible to verify that all returned Uids
// are unique in a unit test. Just verify that 2 calls result in 2 different values.
var uidA = DicomUID.Generate();
var uidB = DicomUID.Generate();
Assert.NotEqual(uidA, uidB);
}
public DcmPrintJob(DicomUID sopInst)
{
_sopInst = sopInst;
if (_sopInst == null || _sopInst.UID == String.Empty)
{
_sopInst = DicomUID.Generate();
}
_dataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
}
/// <summary>
/// Initializes new Basic Film Session
/// </summary>
/// <param name="sessionClass">Color or Grayscale Basic Print Management UID</param>
/// <param name="sopInstance">SOP Instance UID</param>
/// <param name="dataset">Dataset</param>
public DcmFilmSession(DicomUID sessionClass, DicomUID sopInstance, DcmDataset dataset)
{
_sessionClass = sessionClass;
_sopInstance = sopInstance;
_dataset = dataset;
_boxes = new List <DcmFilmBox>();
if (_sopInstance == null || _sopInstance.UID == String.Empty)
{
_sopInstance = DicomUID.Generate();
}
}
/// <summary>
/// Called when we are creating a new structure set from an existing 3D scan.
/// </summary>
/// <param name="identifiers">The identifiers from 1 of the images of the 3D scan</param>
/// <returns>A new structure set with a new SeriesUID</returns>
public static RadiotherapyStruct CreateDefault(IReadOnlyList <DicomIdentifiers> identifiers)
{
var firstIdentifier = identifiers.First();
var newSeriesUID = DicomUID.Generate().UID;
return(new RadiotherapyStruct(
DicomRTStructureSet.CreateDefault(identifiers),
firstIdentifier.Patient,
DicomEquipment.CreateEmpty(),
firstIdentifier.Study,
new DicomRTSeries(DicomRTSeries.RtModality, newSeriesUID, string.Empty),
new List <RadiotherapyContour>()));
}
public DcmFilmBox CreateFilmBox(DicomUID sopInstance, DcmDataset dataset)
{
var uid = sopInstance;
if (uid == null || uid.UID == String.Empty)
{
uid = DicomUID.Generate(SOPInstanceUID, _boxes.Count + 1);
}
var box = new DcmFilmBox(this, uid, dataset);
_boxes.Add(box);
return(box);
}
public PresentationLut(DicomUID sopInstance = null)
{
InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SopInstanceUid = DicomUID.Generate();
}
else
{
SopInstanceUid = sopInstance;
}
CreateLutSequence();
}
/// <summary>
/// Returns a new random dicom image for the <paramref name="p"/> with tag values that make sense for that person
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public DicomDataset GenerateTestDataset(Person p, Series series)
{
var ds = new DicomDataset();
ds.AddOrUpdate(DicomTag.StudyInstanceUID, series.Study.StudyUID);
ds.AddOrUpdate(DicomTag.SeriesInstanceUID, series.SeriesUID);
DicomUID sopInstanceUID = DicomUID.Generate();
ds.AddOrUpdate(DicomTag.SOPInstanceUID, sopInstanceUID);
ds.AddOrUpdate(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage);
//patient details
ds.AddOrUpdate(DicomTag.PatientID, p.CHI);
ds.AddOrUpdate(DicomTag.PatientName, p.Forename + " " + p.Surname);
ds.AddOrUpdate(DicomTag.PatientBirthDate, p.DateOfBirth);
ds.AddOrUpdate(DicomTag.PatientAddress, p.Address.Line1 + " " + p.Address.Line2 + " " + p.Address.Line3 + " " + p.Address.Line4 + " " + p.Address.Postcode.Value);
ds.AddOrUpdate(new DicomDate(DicomTag.StudyDate, series.Study.StudyDate));
ds.AddOrUpdate(new DicomTime(DicomTag.StudyTime, DateTime.Today + series.Study.StudyTime));
ds.AddOrUpdate(new DicomDate(DicomTag.SeriesDate, series.SeriesDate));
ds.AddOrUpdate(DicomTag.Modality, series.ModalityStats.Modality);
if (series.Study.StudyDescription != null)
{
ds.AddOrUpdate(DicomTag.StudyDescription, series.Study.StudyDescription);
}
// Calculate the age of the patient at the time the series was taken
var age = series.SeriesDate.Year - p.DateOfBirth.Year;
// Go back to the year the person was born in case of a leap year
if (p.DateOfBirth.Date > series.SeriesDate.AddYears(-age))
{
age--;
}
ds.AddOrUpdate(new DicomAgeString(DicomTag.PatientAge, age.ToString("000") + "Y"));
if (!NoPixels)
{
drawing.DrawBlackBoxWithWhiteText(ds, 500, 500, sopInstanceUID.UID);
}
return(ds);
}
/// <summary>
/// Create new basic film box and add it to the film session
/// </summary>
/// <param name="sopInstance">The new film box SOP instance UID</param>
/// <param name="dataset">The new film box dataset</param>
/// <returns>The created film box instance</returns>
public FilmBox CreateFilmBox(DicomUID sopInstance, DicomDataset dataset)
{
DicomUID uid = sopInstance;
if (uid == null || uid.UID == string.Empty)
{
uid = DicomUID.Generate();
}
var filmBox = new FilmBox(this, uid, dataset);
BasicFilmBoxes.Add(filmBox);
return(filmBox);
}
/// <summary>
/// Initializes a new instance of the <see cref="PresentationLut"/> class.
/// </summary>
/// <param name="sopInstance">SOP Instance UID associated with the Presentation LUT information object. If <code>null</code>,
/// a UID will be automatically generated.</param>
/// <param name="dataset">Dataset presumed to contain Presentation LUT data.</param>
public PresentationLut(DicomUID sopInstance, DicomDataset dataset)
{
if (dataset == null)
{
throw new ArgumentNullException(nameof(dataset));
}
dataset.CopyTo(this);
if (!dataset.Contains(DicomTag.PresentationLUTSequence))
{
CreateLutSequence();
}
SopInstanceUid = string.IsNullOrEmpty(sopInstance?.UID) ? DicomUID.Generate() : sopInstance;
AddOrUpdate(DicomTag.SOPInstanceUID, SopInstanceUid);
}
private async Task AddDicomFileContent(MultipartContent multipartContent)
{
var dicomDataset = new DicomDataset(DicomTransferSyntax.ExplicitVRLittleEndian);
dicomDataset.Add(DicomTag.PatientName, PatientName);
dicomDataset.Add(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage);
dicomDataset.Add(DicomTag.SOPInstanceUID, DicomUID.Generate());
var dicomFile = new DicomFile(dicomDataset);
using (var ms = new MemoryStream())
{
await dicomFile.SaveAsync(ms);
multipartContent.Add(new ByteArrayContent(ms.ToArray()));
}
}
private void CreateFilmSession()
{
DcmDataset fimSessionDataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
_filmSession = new DcmFilmSession(DcmFilmSession.SOPClassUID,
DicomUID.Generate(), fimSessionDataset.Clone());
_filmSession.FilmDestination = _filmDestination;
_filmSession.FilmSessionLabel = _filmSessionLabel;
_filmSession.MediumType = _mediumType;
_filmSession.NumberOfCopies = _numberOfCopies;
_filmSession.OwnerID = _ownerID;
_filmSession.PrintPriority = _printPriority;
byte pcid = Associate.FindAbstractSyntax(DicomUID.BasicGrayscalePrintManagementMetaSOPClass);
SendNCreateRequest(pcid, NextMessageID(), DcmFilmSession.SOPClassUID, _filmSession.SOPInstanceUID, _filmSession.Dataset);
}
public DicomDirectory() : base()
{
FileMetaInfo.Add <byte>(DicomTag.FileMetaInformationVersion, new byte[] { 0x00, 0x01 });
FileMetaInfo.MediaStorageSOPClassUID = DicomUID.MediaStorageDirectoryStorage;
FileMetaInfo.MediaStorageSOPInstanceUID = DicomUID.Generate();
FileMetaInfo.SourceApplicationEntityTitle = string.Empty;
FileMetaInfo.TransferSyntax = DicomTransferSyntax.ImplicitVRLittleEndian;
FileMetaInfo.ImplementationClassUID = DicomImplementation.ClassUID;
FileMetaInfo.ImplementationVersionName = DicomImplementation.Version;
_directoryRecordSequence = new DicomSequence(DicomTag.DirectoryRecordSequence);
Dataset.Add <string>(DicomTag.FileSetID, string.Empty)
.Add <ushort>(DicomTag.FileSetConsistencyFlag, 0)
.Add <uint>(DicomTag.OffsetOfTheFirstDirectoryRecordOfTheRootDirectoryEntity, 0)
.Add <uint>(DicomTag.OffsetOfTheLastDirectoryRecordOfTheRootDirectoryEntity, 0);
}
/// <summary>
/// Construct new ImageBox for specified filmBox using specified SOP class UID and SOP instance UID
/// </summary>
/// <param name="filmBox"></param>
/// <param name="sopClass"></param>
/// <param name="sopInstance"></param>
public ImageBox(FilmBox filmBox, DicomUID sopClass, DicomUID sopInstance)
{
InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
FilmBox = filmBox;
SOPClassUID = sopClass;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
Add(DicomTag.SOPClassUID, SOPClassUID);
Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
}
/// <summary>
/// Construct new print job using specified SOP instance UID. If passed SOP instance UID is missing, new UID will
/// be generated
/// </summary>
/// <param name="sopInstance">New print job SOP instance uID</param>
public PrintJob(DicomUID sopInstance, string callingIP, string callingAETitle, string calledAETitle)
: base()
{
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
Status = PrintStatus.Pending;
CallingAETitle = callingAETitle;
CalledAETitle = calledAETitle;
CallingIP = callingIP;
}
/// <summary>
/// Create baisc film box for specified film session
/// </summary>
/// <param name="filmSession">Film session instance</param>
/// <param name="sopInstance">Basic film box SOP Instance UID</param>
/// <param name="transferSyntax">Requested internal transfer syntax.</param>
public FilmBox(FilmSession filmSession, DicomUID sopInstance, DicomTransferSyntax transferSyntax)
{
this.InternalTransferSyntax = transferSyntax;
_filmSession = filmSession;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
this.Add(DicomTag.SOPClassUID, SOPClassUID);
this.Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
BasicImageBoxes = new List <ImageBox>();
}
private void CreateImageBox()
{
DicomUID classUid = DicomUID.BasicGrayscaleImageBoxSOPClass;
if (_session.SessionClassUID == DicomUID.BasicColorPrintManagementMetaSOPClass)
{
classUid = DicomUID.BasicColorImageBoxSOPClass;
}
DicomUID instUid = DicomUID.Generate(SOPInstanceUID, _boxes.Count + 1);
DcmImageBox box = new DcmImageBox(this, classUid, instUid);
box.ImageBoxPosition = (ushort)(_boxes.Count + 1);
_boxes.Add(box);
_dataset.AddReferenceSequenceItem(DicomTags.ReferencedImageBoxSequence, classUid, instUid);
}
public async Task GetUploadProcessingResultsAsyncTest_ExhaustRetries()
{
int testNumber = 10;
// Create a ProKnowApi with one small retry delay
var proKnow = new ProKnowApi(TestSettings.BaseUrl, TestSettings.CredentialsFile);
proKnow.Uploads.RetryDelays = new int[] { 1 }.ToList();
// Create a workspace
var workspaceItem = await TestHelper.CreateWorkspaceAsync(_testClassName, testNumber);
// Read a DICOM file to use as a template
var templatePath = Path.Combine(TestSettings.TestDataRootDirectory, "Becker^Matthew", "RD.dcm");
var dicomFile = DicomFile.Open(templatePath, FileReadOption.ReadAll);
var dicomDataset = dicomFile.Dataset;
// Upload enough DICOM objects so that some reach terminal status and others don't
var numberToUpload = 20;
var allUploadResults = new List <UploadResult>();
for (var i = 0; i < numberToUpload; i++)
{
dicomDataset.AddOrUpdate <string>(DicomTag.SOPInstanceUID, DicomUID.Generate().UID);
var tempPath = Path.GetTempFileName();
dicomFile.Save(tempPath);
var thisUploadResults = await proKnow.Uploads.UploadAsync(workspaceItem, tempPath);
allUploadResults.AddRange(thisUploadResults);
File.Delete(tempPath);
}
// Wait for processing and get processing results
var uploadProcessingResults = await proKnow.Uploads.GetUploadProcessingResultsAsync(workspaceItem, allUploadResults);
// Verify processing results were successfully retrieved for all uploaded files, i.e., that query parameters were
// properly applied to page through upload results returned by ProKnow
Assert.AreEqual(numberToUpload, uploadProcessingResults.Results.Count);
Assert.IsTrue(uploadProcessingResults.Results.Any(t => t.Status == "completed"));
Assert.IsTrue(uploadProcessingResults.Results.Any(t => t.Status == "processing"));
Assert.IsTrue(uploadProcessingResults.WereRetryDelaysExhausted);
Assert.AreEqual(1, uploadProcessingResults.TotalRetryDelayInMsec);
}
public async Task UploadAsyncTest_LongProcessingTimes()
{
int testNumber = 13;
// Create a workspace
var workspaceItem = await TestHelper.CreateWorkspaceAsync(_testClassName, testNumber);
// Read a DICOM file to use as a template
var templatePath = Path.Combine(TestSettings.TestDataRootDirectory, "Becker^Matthew", "RD.dcm");
var dicomFile = DicomFile.Open(templatePath, FileReadOption.ReadAll);
var dicomDataset = dicomFile.Dataset;
// Upload more than 200 unique DICOM objects (maximum batch size of upload results returned by ProKnow)
var allUploadResults = new List <UploadResult>();
for (var i = 0; i < 205; i++)
{
dicomDataset.AddOrUpdate <string>(DicomTag.SOPInstanceUID, DicomUID.Generate().UID);
var tempPath = Path.GetTempFileName();
dicomFile.Save(tempPath);
allUploadResults.AddRange(await _proKnow.Uploads.UploadAsync(workspaceItem, tempPath));
File.Delete(tempPath);
}
// Upload another DICOM object that will take a long time to process
var path = Path.Combine(TestSettings.TestDataRootDirectory, "StructureSet", "RS.Large.dcm");
allUploadResults.AddRange(await _proKnow.Uploads.UploadAsync(workspaceItem, path));
// Upload one more DICOM object that won't take a long time to process
path = Path.Combine(TestSettings.TestDataRootDirectory, "Becker^Matthew", "RD.dcm");
allUploadResults.AddRange(await _proKnow.Uploads.UploadAsync(workspaceItem, path));
// Wait for processing and get processing results
var uploadProcessingResults = await _proKnow.Uploads.GetUploadProcessingResultsAsync(workspaceItem, allUploadResults);
// Verify processing results were successfully retrieved for all uploaded files, i.e., that query parameters were
// properly applied to page through upload results returned by ProKnow
Assert.AreEqual(207, uploadProcessingResults.Results.Count);
Assert.AreEqual(0, uploadProcessingResults.Results.Count(t => t.Status != "completed"));
Assert.IsFalse(uploadProcessingResults.WereRetryDelaysExhausted);
Assert.AreEqual(30000, uploadProcessingResults.TotalRetryDelayInMsec);
}
/// <summary>
/// Construct new print job using specified SOP instance UID. If passed SOP instance UID is missing, new UID will
/// be generated
/// </summary>
/// <param name="sopInstance">New print job SOP instance uID</param>
public PrintJob(DicomUID sopInstance, Printer printer, string originator, Dicom.Log.Logger log)
: base()
{
if (printer == null)
{
throw new ArgumentNullException("printer");
}
Log = log;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
this.Add(DicomTag.SOPClassUID, SOPClassUID);
this.Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
Printer = printer;
Status = PrintJobStatus.Pending;
PrinterName = Printer.PrinterAet;
Originator = originator;
if (CreationDateTime == DateTime.MinValue)
{
CreationDateTime = DateTime.Now;
}
PrintJobFolder = SOPInstanceUID.UID;
var receivingFolder = Environment.CurrentDirectory + @"\PrintJobs";
FullPrintJobFolder = string.Format(@"{0}\{1}", receivingFolder.TrimEnd('\\'), PrintJobFolder);
FilmBoxFolderList = new List <string>();
}
