private static DicomDataset ReadFragment(byte[] bytes, Endian endian, bool explicitVr)
{
var dataset = new DicomDataset();
var reader = new DicomReader { IsExplicitVR = explicitVr };
var byteSource = new ByteBufferByteSource(new MemoryByteBuffer(bytes)) { Endian = endian };
reader.Read(byteSource, new DicomDatasetReaderObserver(dataset));
return dataset;
}
public static BitDepth FromDataset(DicomDataset dataset)
{
var allocated = dataset.Get<ushort>(DicomTag.BitsAllocated);
var stored = dataset.Get<ushort>(DicomTag.BitsStored);
var signed = dataset.Get<PixelRepresentation>(DicomTag.PixelRepresentation) == PixelRepresentation.Signed;
return new BitDepth(allocated, stored, GetHighBit(stored, signed), signed);
}
public void Add_UniversalResourceElement_Succeeds()
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.URNCodeValue, "abc");
Assert.IsType(typeof(DicomUniversalResource), dataset.First());
Assert.Equal("abc", dataset.Get<string>(DicomTag.URNCodeValue));
}
public void FromDataset_WindowCenterWidth_ReturnsSameAsFromWindowLevel(
ushort bitsAllocated,
ushort bitsStored,
ushort pixelRepresentation,
double rescaleSlope,
double rescaleIntercept,
double windowWidth,
double windowCenter,
string voiLutFunction)
{
var dataset = new DicomDataset(
new DicomCodeString(DicomTag.PhotometricInterpretation, "MONOCHROME1"),
new DicomUnsignedShort(DicomTag.BitsAllocated, bitsAllocated),
new DicomUnsignedShort(DicomTag.BitsStored, bitsStored),
new DicomUnsignedShort(DicomTag.PixelRepresentation, pixelRepresentation),
new DicomDecimalString(DicomTag.RescaleSlope, (decimal)rescaleSlope),
new DicomDecimalString(DicomTag.RescaleIntercept, (decimal)rescaleIntercept),
new DicomDecimalString(DicomTag.WindowWidth, (decimal)windowWidth),
new DicomDecimalString(DicomTag.WindowCenter, (decimal)windowCenter),
new DicomCodeString(DicomTag.VOILUTFunction, voiLutFunction));
var expected = GrayscaleRenderOptions.FromWindowLevel(dataset);
var actual = GrayscaleRenderOptions.FromDataset(dataset);
Assert.Equal(expected.WindowWidth, actual.WindowWidth);
Assert.Equal(expected.WindowCenter, actual.WindowCenter);
}
public void Add_OtherDoubleElementWithMultipleDoubles_Succeeds()
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.DoubleFloatPixelData, 3.45, 6.78, 9.01);
Assert.IsType(typeof(DicomOtherDouble), dataset.First());
Assert.Equal(3, dataset.Get<double[]>(DicomTag.DoubleFloatPixelData).Length);
}
public void Add_UnlimitedCharactersElementWithMultipleStrings_Succeeds()
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.LongCodeValue, "a", "b", "c");
Assert.IsType(typeof(DicomUnlimitedCharacters), dataset.First());
Assert.Equal("c", dataset.Get<string>(DicomTag.LongCodeValue, 2));
}
public DicomFile()
{
FileMetaInfo = new DicomFileMetaInformation();
Dataset = new DicomDataset();
Format = DicomFileFormat.DICOM3;
IsPartial = false;
}
public static GrayscaleRenderOptions FromDataset(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get<double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get<double>(DicomTag.RescaleIntercept, 0.0);
if (dataset.Contains(DicomTag.WindowWidth) && dataset.Get<double>(DicomTag.WindowWidth) != 0.0) {
options.WindowWidth = dataset.Get<double>(DicomTag.WindowWidth);
options.WindowCenter = dataset.Get<double>(DicomTag.WindowCenter);
} else if (dataset.Contains(DicomTag.SmallestImagePixelValue) && dataset.Contains(DicomTag.LargestImagePixelValue)) {
var smallElement = dataset.Get<DicomElement>(DicomTag.SmallestImagePixelValue);
var largeElement = dataset.Get<DicomElement>(DicomTag.LargestImagePixelValue);
int smallValue = 0;
int largeValue = 0;
if (smallElement.ValueRepresentation == DicomVR.US) {
smallValue = smallElement.Get<ushort>(0);
largeValue = smallElement.Get<ushort>(0);
} else {
smallValue = smallElement.Get<short>(0);
largeValue = smallElement.Get<short>(0);
}
options.WindowWidth = largeValue - smallValue;
options.WindowCenter = (largeValue + smallValue) / 2.0;
}
options.Monochrome1 = dataset.Get<PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return options;
}
private static byte[] SerializeDicom_(DicomDataset dataset)
{
var stream = new MemoryStream();
var file = new DicomFile(dataset);
file.Save(stream);
return stream.ToArray();
}
public DicomCMoveRequest(string destinationAe, string studyInstanceUid, string seriesInstanceUid, DicomPriority priority = DicomPriority.Medium) : base(DicomCommandField.CMoveRequest, DicomUID.StudyRootQueryRetrieveInformationModelMOVE, priority) {
DestinationAE = destinationAe;
Dataset = new DicomDataset();
Level = DicomQueryRetrieveLevel.Series;
Dataset.Add(DicomTag.StudyInstanceUID, studyInstanceUid);
Dataset.Add(DicomTag.SeriesInstanceUID, seriesInstanceUid);
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null) {
var remove = dataset.EnumerateMasked(_mask).Select(x => x.Tag).ToList();
foreach (DicomTag tag in remove) {
dataset.CopyTo(modifiedAttributesSequenceItem, tag);
dataset.Remove(tag);
}
}
public void SerializeAndDeserializePrivateTags()
{
var privCreatorDictEntry = new DicomDictionaryEntry(new DicomTag(0x0011, 0x0010), "Private Creator", "PrivateCreator", DicomVM.VM_1, false, DicomVR.LO);
DicomDictionary.Default.Add(privCreatorDictEntry);
DicomPrivateCreator privateCreator1 = DicomDictionary.Default.GetPrivateCreator("TESTCREATOR1");
DicomDictionary privDict1 = DicomDictionary.Default[privateCreator1];
var dictEntry = new DicomDictionaryEntry(DicomMaskedTag.Parse("0011", "xx01"), "TestPrivTagName", "TestPrivTagKeyword", DicomVM.VM_1, false, DicomVR.CS);
privDict1.Add(dictEntry);
var ds = new DicomDataset();
ds.Add(dictEntry.Tag, "VAL1");
ds.Add(DicomTag.SOPClassUID, DicomUID.CTImageStorage);
ds.Add(DicomTag.SOPInstanceUID, "2.25.123");
Assert.Equal(DicomVR.CS, ds.Get<DicomVR>(dictEntry.Tag));
var bytes = SerializeDicom_(ds);
File.OpenWrite("C:\\Temp\\x.dcm").Write(bytes, 0, bytes.Length);
var ds2 = ParseDicom_(bytes);
Assert.Equal(DicomVR.CS, ds2.Get<DicomVR>(dictEntry.Tag));
}
public DicomFileMetaInformation(DicomDataset dataset)
: this()
{
MediaStorageSOPClassUID = dataset.Get<DicomUID>(DicomTag.SOPClassUID);
MediaStorageSOPInstanceUID = dataset.Get<DicomUID>(DicomTag.SOPInstanceUID);
TransferSyntax = dataset.InternalTransferSyntax;
}
/// <summary>
/// Creates a DICOM overlay from a GDI+ Bitmap.
/// </summary>
/// <param name="ds">Dataset</param>
/// <param name="bitmap">Bitmap</param>
/// <param name="mask">Color mask for overlay</param>
/// <returns>DICOM overlay</returns>
public static DicomOverlayData FromBitmap(DicomDataset ds, Bitmap bitmap, Color mask)
{
ushort group = 0x6000;
while (ds.Contains(new DicomTag(group, DicomTag.OverlayBitPosition.Element))) group += 2;
var overlay = new DicomOverlayData(ds, group)
{
Type = DicomOverlayType.Graphics,
Rows = bitmap.Height,
Columns = bitmap.Width,
OriginX = 1,
OriginY = 1,
BitsAllocated = 1,
BitPosition = 1
};
var array = new BitList { Capacity = overlay.Rows * overlay.Columns };
int p = 0;
for (var y = 0; y < bitmap.Height; y++)
{
for (var x = 0; x < bitmap.Width; x++, p++)
{
if (bitmap.GetPixel(x, y).ToArgb() == mask.ToArgb()) array[p] = true;
}
}
overlay.Data = EvenLengthBuffer.Create(new MemoryByteBuffer(array.Array));
return overlay;
}
public void Contains_PrivateTag_SufficientlyFound()
{
var dataset = new DicomDataset();
dataset.Add(new DicomTag(0x0021, 0x0010, "TEST"), "TEST");
var found = dataset.Contains(new DicomTag(0x0021, 0x0010, "TEST"));
Assert.True(found);
}
public DicomDatasetWalkerTest()
{
var dataset = new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPClassUID, DicomUID.RTDoseStorage),
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
new DicomDate(DicomTag.AcquisitionDate, DateTime.Today),
new DicomPersonName(DicomTag.ConsultingPhysicianName, "Doe", "John"),
new DicomDecimalString(DicomTag.GridFrameOffsetVector, 1.0m, 2.0m, 3.0m, 4.0m, 5.0m, 6.0m),
new DicomSequence(
DicomTag.BeamSequence,
new DicomDataset(
new DicomIntegerString(DicomTag.BeamNumber, 1),
new DicomDecimalString(DicomTag.FinalCumulativeMetersetWeight, 1.0m),
new DicomLongString(DicomTag.BeamName, "Ant")),
new DicomDataset(
new DicomIntegerString(DicomTag.BeamNumber, 2),
new DicomDecimalString(DicomTag.FinalCumulativeMetersetWeight, 100.0m),
new DicomLongString(DicomTag.BeamName, "Post")),
new DicomDataset(
new DicomIntegerString(DicomTag.BeamNumber, 3),
new DicomDecimalString(DicomTag.FinalCumulativeMetersetWeight, 2.0m),
new DicomLongString(DicomTag.BeamName, "Left"))),
new DicomIntegerString(DicomTag.NumberOfContourPoints, 120));
this.walker = new DicomDatasetWalker(dataset);
this.walkerImpl = new DatasetWalkerImpl();
}
public void Add_OtherDoubleElement_Succeeds()
{
var tag = DicomTag.DoubleFloatPixelData;
var dataset = new DicomDataset();
dataset.Add(tag, 3.45);
Assert.IsType<DicomOtherDouble>(dataset.First(item => item.Tag.Equals(tag)));
}
public void FromWindowLevel_ValidInput_CorrectOutput(
ushort bitsAllocated,
ushort bitsStored,
ushort pixelRepresentation,
double rescaleSlope,
double rescaleIntercept,
double windowWidth,
double windowCenter,
string voiLutFunction)
{
var dataset = new DicomDataset(
new DicomUnsignedShort(DicomTag.BitsAllocated, bitsAllocated),
new DicomUnsignedShort(DicomTag.BitsStored, bitsStored),
new DicomUnsignedShort(DicomTag.PixelRepresentation, pixelRepresentation),
new DicomDecimalString(DicomTag.RescaleSlope, (decimal)rescaleSlope),
new DicomDecimalString(DicomTag.RescaleIntercept, (decimal)rescaleIntercept),
new DicomDecimalString(DicomTag.WindowWidth, (decimal)windowWidth),
new DicomDecimalString(DicomTag.WindowCenter, (decimal)windowCenter),
new DicomCodeString(DicomTag.VOILUTFunction, voiLutFunction));
var actual = GrayscaleRenderOptions.FromWindowLevel(dataset);
Assert.Equal(windowWidth, actual.WindowWidth);
Assert.Equal(windowCenter, actual.WindowCenter);
}
public DicomFile(DicomDataset dataset)
{
Dataset = dataset;
FileMetaInfo = new DicomFileMetaInformation(Dataset);
Format = DicomFileFormat.DICOM3;
IsPartial = false;
}
public void Add_UnlimitedCharactersElementWithMultipleStrings_Succeeds()
{
var tag = DicomTag.LongCodeValue;
var dataset = new DicomDataset();
dataset.Add(tag, "a", "b", "c");
Assert.IsType<DicomUnlimitedCharacters>(dataset.First(item => item.Tag.Equals(tag)));
Assert.Equal("c", dataset.Get<string>(tag, 2));
}
public void Add_OtherDoubleElementWithMultipleDoubles_Succeeds()
{
var tag = DicomTag.DoubleFloatPixelData;
var dataset = new DicomDataset();
dataset.Add(tag, 3.45, 6.78, 9.01);
Assert.IsType<DicomOtherDouble>(dataset.First(item => item.Tag.Equals(tag)));
Assert.Equal(3, dataset.Get<double[]>(tag).Length);
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null) {
if (_conditions != null)
if (!_conditions.Match(dataset))
return;
foreach (IDicomTransformRule rule in _transformRules)
rule.Transform(dataset);
}
public void DicomDateTime_FractionalSecondsAndTimezone_SupportedFormat()
{
var dt = DateTime.Now.ToString("yyyyMMddHHmmss.ffffffzzz");
var dataset = new DicomDataset { new DicomDateTime(DicomTag.ScheduledProcedureStepStartDateTime, dt) };
var exception = Record.Exception(() => dataset.Get<DicomDateRange>(DicomTag.ScheduledProcedureStepStartDateTime));
Assert.Null(exception);
}
public PresentationLut(DicomUID sopInstance, DicomDataset dataset)
{
if (dataset == null)
{
throw new ArgumentNullException("dataset");
}
dataset.CopyTo(this);
}
public void Add_UniversalResourceElement_Succeeds()
{
var tag = DicomTag.URNCodeValue;
var dataset = new DicomDataset();
dataset.Add(tag, "abc");
Assert.IsType<DicomUniversalResource>(dataset.First(item => item.Tag.Equals(tag)));
Assert.Equal("abc", dataset.Get<string>(tag));
}
public void OnBeginSequenceItem(IByteSource source, uint length) {
DicomSequence sq = _sequences.Peek();
DicomDataset item = new DicomDataset();
sq.Items.Add(item);
_datasets.Push(item);
}
public DicomDatasetReaderObserver(DicomDataset dataset) {
_datasets = new Stack<DicomDataset>();
_datasets.Push(dataset);
_encodings = new Stack<Encoding>();
_encodings.Push(DicomEncoding.Default);
_sequences = new Stack<DicomSequence>();
}
public void OnElement_ValidData_AddsCorrectTypeToDataset(DicomTag tag, DicomVR vr, string data, Type expected)
{
var dataset = new DicomDataset();
var observer = new DicomDatasetReaderObserver(dataset);
var buffer = new MemoryByteBuffer(Encoding.ASCII.GetBytes(data));
observer.OnElement(null, tag, vr, buffer);
Assert.IsType(expected, dataset.First());
}
public void GetDateTime_DateAndTimeMissing_ReturnsMinimumDateTime()
{
var expected = DateTime.MinValue;
var dataset = new DicomDataset();
var actual = dataset.GetDateTime(DicomTag.CreationDate, DicomTag.CreationTime);
Assert.Equal(expected, actual);
}
/// <summary>
/// Initializes a new instance of the <see cref="DicomCGetRequest"/> class.
/// </summary>
/// <param name="studyInstanceUid">
/// The Study Instance UID confining the C-GET operation.
/// </param>
/// <param name="priority">
/// The priority of the C-GET operation.
/// </param>
public DicomCGetRequest(
string studyInstanceUid,
DicomPriority priority = DicomPriority.Medium)
: base(DicomCommandField.CGetRequest, DicomUID.StudyRootQueryRetrieveInformationModelGET, priority)
{
Dataset = new DicomDataset();
Level = DicomQueryRetrieveLevel.Study;
Dataset.Add(DicomTag.StudyInstanceUID, studyInstanceUid);
}
public bool OnBeginSequenceItem(DicomDataset dataset)
{
_log.Log(_level, _pad + "Item:");
IncreaseDepth();
return(true);
}
/// <summary>
/// Inititalizes an instance of the <see cref="DicomCMoveRequest"/> class.
/// </summary>
/// <param name="command">Request command.</param>
public DicomCMoveRequest(DicomDataset command)
: base(command)
{
}
public void TagElevation_SiblingConditionals(string conditional, string conditionalMatch, string expectedResults)
{
expectedResults = expectedResults.Replace("\r\n", Environment.NewLine);
var ds = new DicomDataset
(
//root->PatientInsurancePlanCodeSequence [array of 3 sibling sequences]
new DicomSequence
(DicomTag.PatientInsurancePlanCodeSequence,
new DicomDataset
{
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3_0.1"),
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3_0.2")
}),
//root->PatientInsurancePlanCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2_0.1")
},
new DicomDataset
{
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3_1.1"),
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3_1.2")
}),
//root->PatientInsurancePlanCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2_1.1")
},
new DicomDataset
{
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3_2.1"),
//root->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3_2.2")
}),
//root->PatientInsurancePlanCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2_2.1")
}
)
);
var elevator = new TagElevator("PatientInsurancePlanCodeSequence->SpecimenShortDescription+", conditional, conditionalMatch);
ShowContentSequence(ds, DicomTag.PatientInsurancePlanCodeSequence);
object value = elevator.GetValue(ds);
Assert.AreEqual(expectedResults, value);
}
private DicomDirectoryRecord CreateRecordSequenceItem(DicomDirectoryRecordType recordType, DicomDataset dataset)
{
if (recordType == null)
{
throw new ArgumentNullException("recordType");
}
if (dataset == null)
{
throw new ArgumentNullException("dataset");
}
var sequenceItem = new DicomDirectoryRecord();
//add record item attributes
sequenceItem.Add <uint>(DicomTag.OffsetOfTheNextDirectoryRecord, 0);
sequenceItem.Add <ushort>(DicomTag.RecordInUseFlag, 0xFFFF);
sequenceItem.Add <uint>(DicomTag.OffsetOfReferencedLowerLevelDirectoryEntity, 0);
sequenceItem.Add <string>(DicomTag.DirectoryRecordType, recordType.ToString());
//copy the current dataset character set
sequenceItem.Add(dataset.FirstOrDefault(d => d.Tag == DicomTag.SpecificCharacterSet));
foreach (var tag in recordType.Tags)
{
if (dataset.Contains(tag))
{
sequenceItem.Add(dataset.Get <DicomItem>(tag));
}
else
{
System.Diagnostics.Debug.WriteLine("Cannot find tag {0} for record type {1}", tag, recordType);
}
}
return(sequenceItem);
}
public bool SendStore(Object directory)
{
var client = new DicomClient();
string Directory = directory as string;
var dcmFiles = System.IO.Directory.GetFiles(Directory, "*.DCM", System.IO.SearchOption.AllDirectories);
var sopIds = new List <KeyValuePair <string, string> >();
if (dcmFiles == null || dcmFiles.Count() == 0)
{
return(false);
}
var first = dcmFiles.ElementAt(0);
var fi = DicomFile.Open(first);
string temp = fi.Dataset.Get <string>(DicomTag.StudyInstanceUID);
foreach (var df in dcmFiles)
{
var file = DicomFile.Open(df);
sopIds.Add(new KeyValuePair <string, string>(file.Dataset.Get <string>(DicomTag.SOPClassUID),
file.Dataset.Get <string>(DicomTag.SOPInstanceUID)));
string st = file.Dataset.Get <string>(DicomTag.StudyInstanceUID);
var dicomCStoreReQuest = new DicomCStoreRequest(df);
dicomCStoreReQuest.OnResponseReceived = (DicomCStoreRequest request, DicomCStoreResponse response) =>
{
if (response.Status == DicomStatus.Success)
{
if (!StudyInstanceList.Find(x => { x == st }))
{
StudyInstanceList.Add(st);
}
}
};
client.AddRequest(dicomCStoreReQuest);
// string se = file.Dataset.Get<string>(DicomTag.SeriesInstanceUID);
}
client.Send(remoteserver.RemoteIP, remoteserver.RemotePort, false, localserver.LocalAE, remoteserver.RemoteAE);
var cmdDataset = new DicomDataset();
var refImgSeq = new DicomSequence(DicomTag.ReferencedSOPSequence);
foreach (var ax in sopIds)
{
var rImg = new DicomDataset();
rImg.Add(DicomTag.ReferencedSOPClassUID, ax.Key);
rImg.Add(DicomTag.ReferencedSOPInstanceUID, ax.Value);
refImgSeq.Items.Add(rImg);
}
var cmb = new DicomUIDGenerator();
cmdDataset.Add(refImgSeq);
cmdDataset.Add <string>(DicomTag.TransactionUID, cmb.Generate().UID);
var nActionReq = new DicomNActionRequest(DicomUID.StorageCommitmentPushModelSOPClass, cmb.Generate(), 0x0001);
nActionReq.Dataset = cmdDataset;
nActionReq.OnResponseReceived = (DicomNActionRequest request, DicomNActionResponse response) =>
{
};
client.AddRequest(nActionReq);
client.Send(remoteserver.RemoteIP, remoteserver.RemotePort, false, localserver.LocalAE, remoteserver.RemoteAE);
return(true);
}
public DicomContentItem(DicomDataset dataset)
{
Dataset = dataset;
}
/// <inheritdoc />
public override DicomConstraintResult Check(DicomDataset dataSet)
{
throw new NotImplementedException();
}
/// <summary>
/// Initialize new instance of <seealso cref="DicomPixelData"/> using passed <paramref name="dataset"/>
/// </summary>
/// <param name="dataset"></param>
protected DicomPixelData(DicomDataset dataset)
{
Dataset = dataset;
Syntax = dataset.InternalTransferSyntax;
}
/// <summary>
/// Initializes an instance of the <see cref="DicomNEventReportRequest"/> class.
/// </summary>
/// <param name="command">N-EVENTREPORT request command.</param>
public DicomNEventReportRequest(DicomDataset command)
: base(command)
{
}
private async Task ProcessDicomInstanceEntryAsync(int index, CancellationToken cancellationToken)
{
IDicomInstanceEntry dicomInstanceEntry = _dicomInstanceEntries[index];
DicomDataset dicomDataset = null;
try
{
// Open and validate the DICOM instance.
dicomDataset = await dicomInstanceEntry.GetDicomDatasetAsync(cancellationToken);
_dicomDatasetValidator.Validate(dicomDataset, _requiredStudyInstanceUid);
}
catch (Exception ex)
{
ushort failureCode = FailureReasonCodes.ProcessingFailure;
switch (ex)
{
case DicomValidationException _:
failureCode = FailureReasonCodes.ValidationFailure;
break;
case DatasetValidationException dicomDatasetValidationException:
failureCode = dicomDatasetValidationException.FailureCode;
break;
case ValidationException _:
failureCode = FailureReasonCodes.ValidationFailure;
break;
}
LogValidationFailedDelegate(_logger, index, failureCode, ex);
_storeResponseBuilder.AddFailure(dicomDataset, failureCode);
return;
}
try
{
// Store the instance.
await _storeOrchestrator.StoreDicomInstanceEntryAsync(
dicomInstanceEntry,
cancellationToken);
LogSuccessfullyStoredDelegate(_logger, index, null);
_storeResponseBuilder.AddSuccess(dicomDataset);
}
catch (Exception ex)
{
ushort failureCode = FailureReasonCodes.ProcessingFailure;
switch (ex)
{
case PendingInstanceException _:
failureCode = FailureReasonCodes.PendingSopInstance;
break;
case InstanceAlreadyExistsException _:
failureCode = FailureReasonCodes.SopInstanceAlreadyExists;
break;
}
LogFailedToStoreDelegate(_logger, index, failureCode, ex);
_storeResponseBuilder.AddFailure(dicomDataset, failureCode);
}
}
/// <summary>
/// Initializes an instance of the <see cref="DicomPriorityRequest"/> base class.
/// </summary>
/// <param name="command">Command dataset.</param>
protected DicomPriorityRequest(DicomDataset command)
: base(command)
{
}
private DicomDataset DoAnonymization(DicomDataset oldds, Stack <TagOrIndex> stack, Mode m)
{
foreach (var th in _postprocesses)
{
th.NextDataset();
}
var newds = ModeSwitch(oldds, m);
var arr = oldds.ToList();
for (int i = 0; i < arr.Count; i++)
{
var item = arr[i];
// Use DFS to reach leaves first and then decide if we want
// to keep the sequence. This is not unoptimized code. The
// user might still need to visit the children even if it
// deletes the Seq. Eventually we should support Enter
// and Exit methods for Seqs.
if (item is DicomSequence)
{
DicomSequence nseq = new DicomSequence(item.Tag);
stack.Push(new TagOrIndex(item.Tag));
// Visit sequence's children
foreach (var tuple in (item as DicomSequence).Items.ToList().Select((value, j) => new { j, value }))
{
var seqds = tuple.value;
var index = tuple.j;
stack.Push(new TagOrIndex(index));
var n = DoAnonymization(seqds, stack, m);
// The only reason we get an empty DicomDataset is because
// we deleted its tags during recursion.
if (n.Count() > 0) // So we skip it
{
nseq.Items.Add(n);
}
if (seqds.Count() == 0) // AND we remove it from the original seq (this is for inplace mode)
{
(item as DicomSequence).Items.Remove(seqds);
}
stack.Pop();
}
item = nseq;
stack.Pop();
}
AnonFunc handler = null;
// First we try to see if there is a string tag handler
if (_tagFuncs.ContainsKey(item.Tag))
{
handler = _tagFuncs[item.Tag];
}
else // If no string tag exists, check for regex
{
var tag = item.Tag.ToString().Trim(_parenthesis);
// Check against regex is rather slow as we need to visit all of them linearly
var regAct = _regexFuncs.FirstOrDefault(pair => pair.Key.IsMatch(tag));
if (regAct.Key != null)
{
handler = regAct.Value;
}
}
// No registered handler found
if (handler == null)
{
continue;
}
// Item handler found
if (item is DicomElement || item is DicomSequence || item is DicomFragmentSequence)
{
// We don't include the item's tag in the path.
var r = handler(oldds, stack.Reverse().ToList(), item);
if (r != null)
{
newds.AddOrUpdate(r);
}
else
{
newds.Remove(item.Tag);
}
}
else
{
throw new InvalidOperationException($"Can't handle type: {item.GetType()}");
}
// TODO: Log which is the current iterated tag, and which function was invoked
}
foreach (var th in _postprocesses)
{
th.Postprocess(newds);
}
return(newds);
}
private (string SopInstanceUid, string SopClassUid, ushort FailureReason) ConvertToFailedSopSequenceEntry(DicomDataset dicomDataset, ushort failureReason)
{
return(dicomDataset.GetSingleValue <string>(DicomTag.SOPInstanceUID),
dicomDataset.GetSingleValue <string>(DicomTag.SOPClassUID),
failureReason);
}
public async Task ValidateAsync(DicomDataset dicomDataset, string requiredStudyInstanceUid, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(dicomDataset, nameof(dicomDataset));
// Ensure required tags are present.
EnsureRequiredTagIsPresent(DicomTag.PatientID);
EnsureRequiredTagIsPresent(DicomTag.SOPClassUID);
// The format of the identifiers will be validated by fo-dicom.
string studyInstanceUid = EnsureRequiredTagIsPresent(DicomTag.StudyInstanceUID);
string seriesInstanceUid = EnsureRequiredTagIsPresent(DicomTag.SeriesInstanceUID);
string sopInstanceUid = EnsureRequiredTagIsPresent(DicomTag.SOPInstanceUID);
// Ensure the StudyInstanceUid != SeriesInstanceUid != sopInstanceUid
if (studyInstanceUid == seriesInstanceUid ||
studyInstanceUid == sopInstanceUid ||
seriesInstanceUid == sopInstanceUid)
{
throw new DatasetValidationException(
FailureReasonCodes.ValidationFailure,
DicomCoreResource.DuplicatedUidsNotAllowed);
}
// If the requestedStudyInstanceUid is specified, then the StudyInstanceUid must match.
if (requiredStudyInstanceUid != null &&
!studyInstanceUid.Equals(requiredStudyInstanceUid, StringComparison.OrdinalIgnoreCase))
{
throw new DatasetValidationException(
FailureReasonCodes.MismatchStudyInstanceUid,
string.Format(
CultureInfo.InvariantCulture,
DicomCoreResource.MismatchStudyInstanceUid,
studyInstanceUid,
requiredStudyInstanceUid));
}
string EnsureRequiredTagIsPresent(DicomTag dicomTag)
{
if (dicomDataset.TryGetSingleValue(dicomTag, out string value))
{
return(value);
}
throw new DatasetValidationException(
FailureReasonCodes.ValidationFailure,
string.Format(
CultureInfo.InvariantCulture,
DicomCoreResource.MissingRequiredTag,
dicomTag.ToString()));
}
// validate input data elements
if (_enableFullDicomItemValidation)
{
ValidateAllItems(dicomDataset);
}
else
{
await ValidateIndexedItems(dicomDataset, cancellationToken);
}
}
public static DicomDataset CreateRandomInstanceDataset(
PatientInstance pI)
{
Random rand = new Random();
var studyTime = DateTime.Parse(pI.PerformedProcedureStepStartDate).AddMinutes(-10);
var dicomTime = studyTime.ToString("HHmmss.fffff");
var procedureTime = DateTime.Parse(pI.PerformedProcedureStepStartDate);
var procedureDate = studyTime.ToString("yyyyMMdd");
var dicomProcedureTime = studyTime.ToString("HHmmss.fffff");
var age = int.Parse(pI.PatientAge);
string dicomAge = null;
if (age > 9)
{
dicomAge = "0" + age.ToString() + "Y";
}
else
{
dicomAge = "00" + age.ToString() + "Y";
}
var occupation = pI.PatientOccupation.Length > 16 ? pI.PatientOccupation.Substring(0, 16) : pI.PatientOccupation;
var laterality = new List <string> {
"R", "L"
};
var physicianName = pI.PhysicianName.Split()[0] + "^" + pI.PhysicianName.Split()[1];
var name = pI.Name.Split()[0] + "^" + pI.Name.Split()[1];
var ds = new DicomDataset(DicomTransferSyntax.ExplicitVRLittleEndian)
{
{ DicomTag.StudyInstanceUID, pI.StudyUid ?? TestUidGenerator.Generate() },
{ DicomTag.SeriesInstanceUID, pI.SeriesUid ?? TestUidGenerator.Generate() },
{ DicomTag.SOPInstanceUID, pI.InstanceUid ?? TestUidGenerator.Generate() },
{ DicomTag.SOPClassUID, TestUidGenerator.Generate() },
{ DicomTag.BitsAllocated, (ushort)8 },
{ DicomTag.PhotometricInterpretation, PhotometricInterpretation.Monochrome2.Value },
{ DicomTag.PatientID, pI.PatientId ?? TestUidGenerator.Generate() },
{ DicomTag.SpecificCharacterSet, "ISO_IR 100" },
{ DicomTag.StudyDate, procedureDate },
{ DicomTag.SeriesDate, procedureDate },
{ DicomTag.StudyTime, dicomTime },
{ DicomTag.SeriesTime, dicomTime },
{ DicomTag.AccessionNumber, pI.AccessionNumber },
{ DicomTag.InstanceAvailability, "ONLINE" },
{ DicomTag.Modality, pI.Modality },
{ DicomTag.StudyDescription, pI.StudyDescription },
{ DicomTag.SeriesDescription, pI.StudyDescription },
{ DicomTag.NameOfPhysiciansReadingStudy, physicianName },
{ DicomTag.ReferringPhysicianName, physicianName },
{ DicomTag.PatientName, name },
{ DicomTag.PatientBirthDate, pI.PatientBirthDate },
{ DicomTag.PatientSex, pI.PatientSex },
{ DicomTag.PatientAge, dicomAge },
{ DicomTag.PatientWeight, pI.PatientWeight },
{ DicomTag.Occupation, occupation },
{ DicomTag.StudyID, rand.Next(10000000, 100000000).ToString() },
{ DicomTag.SeriesNumber, pI.SeriesIndex },
{ DicomTag.InstanceNumber, pI.InstanceIndex },
{ DicomTag.Laterality, laterality.RandomElement() },
{ DicomTag.PerformedProcedureStepStartDate, procedureDate },
{ DicomTag.PerformedProcedureStepStartTime, dicomProcedureTime },
};
return(ds);
}
public WebStoreDatasetProcessedMessage(WebStoreRequest request, DicomDataset dataset)
: base(request, dataset)
{
}
private (string SopInstanceUid, string RetrieveUri, string SopClassUid) ConvertToReferencedSopSequenceEntry(DicomDataset dicomDataset)
{
string studyInstanceUid = dicomDataset.GetSingleValue <string>(DicomTag.StudyInstanceUID);
string seriesInstanceUid = dicomDataset.GetSingleValue <string>(DicomTag.SeriesInstanceUID);
string sopInstanceUid = dicomDataset.GetSingleValue <string>(DicomTag.SOPInstanceUID);
string relativeUri = $"/studies/{studyInstanceUid}/series/{seriesInstanceUid}/instances/{sopInstanceUid}";
return(dicomDataset.GetSingleValue <string>(DicomTag.SOPInstanceUID),
new Uri(_client.HttpClient.BaseAddress, relativeUri).ToString(),
dicomDataset.GetSingleValue <string>(DicomTag.SOPClassUID));
}
/// <summary>
/// Handler for traversing beginning of sequence item.
/// </summary>
/// <param name="dataset">Item dataset.</param>
/// <returns>true if traversing completed without issues, false otherwise.</returns>
public bool OnBeginSequenceItem(DicomDataset dataset)
{
_log.AppendLine(_pad + "Item:");
IncreaseDepth();
return(true);
}
private async Task ValidateIndexedItems(DicomDataset dicomDataset, CancellationToken cancellationToken)
{
IReadOnlyCollection <QueryTag> queryTags = await _queryTagService.GetQueryTagsAsync(cancellationToken);
ValidateTags(dicomDataset, queryTags);
}
public DicomNActionResponse OnNActionRequest(DicomNActionRequest request)
{
if (_filmSession == null)
{
this.Logger.Error("A basic film session does not exist for this association {0}", CallingAE);
return(new DicomNActionResponse(request, DicomStatus.InvalidObjectInstance));
}
lock (_synchRoot)
{
try
{
var filmBoxList = new List <FilmBox>();
if (request.SOPClassUID == DicomUID.BasicFilmSessionSOPClass && request.ActionTypeID == 0x0001)
{
this.Logger.Info("Creating new print job for film session {0}", _filmSession.SOPInstanceUID.UID);
filmBoxList.AddRange(_filmSession.BasicFilmBoxes);
}
else if (request.SOPClassUID == DicomUID.BasicFilmBoxSOPClass && request.ActionTypeID == 0x0001)
{
this.Logger.Info("Creating new print job for film box {0}", request.SOPInstanceUID.UID);
var filmBox = _filmSession.FindFilmBox(request.SOPInstanceUID);
if (filmBox != null)
{
filmBoxList.Add(filmBox);
}
else
{
this.Logger.Error(
"Received N-ACTION request for invalid film box {0} from {1}",
request.SOPInstanceUID.UID,
CallingAE);
return(new DicomNActionResponse(request, DicomStatus.NoSuchObjectInstance));
}
}
else
{
if (request.ActionTypeID != 0x0001)
{
this.Logger.Error(
"Received N-ACTION request for invalid action type {0} from {1}",
request.ActionTypeID,
CallingAE);
return(new DicomNActionResponse(request, DicomStatus.NoSuchActionType));
}
else
{
this.Logger.Error(
"Received N-ACTION request for invalid SOP class {0} from {1}",
request.SOPClassUID,
CallingAE);
return(new DicomNActionResponse(request, DicomStatus.NoSuchSOPClass));
}
}
var printJob = new PrintJob(null, Printer, CallingAE, this.Logger);
printJob.SendNEventReport = _sendEventReports;
printJob.StatusUpdate += OnPrintJobStatusUpdate;
printJob.Print(filmBoxList);
if (printJob.Error == null)
{
var result = new DicomDataset();
result.Add(
new DicomSequence(
new DicomTag(0x2100, 0x0500),
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.ReferencedSOPClassUID, DicomUID.PrintJobSOPClass)),
new DicomDataset(
new DicomUniqueIdentifier(
DicomTag.ReferencedSOPInstanceUID,
printJob.SOPInstanceUID))));
var response = new DicomNActionResponse(request, DicomStatus.Success);
response.Command.Add(DicomTag.AffectedSOPInstanceUID, printJob.SOPInstanceUID);
response.Dataset = result;
return(response);
}
else
{
throw printJob.Error;
}
}
catch (Exception ex)
{
this.Logger.Error(
"Error occured during N-ACTION {0} for SOP class {1} and instance {2}",
request.ActionTypeID,
request.SOPClassUID.UID,
request.SOPInstanceUID.UID);
this.Logger.Error(ex.Message);
return(new DicomNActionResponse(request, DicomStatus.ProcessingFailure));
}
}
}
/// <summary>
/// Constructor for DICOM C-Store request received from SCU.
/// </summary>
/// <remarks>
/// In most use cases this constructor will only be called by the library.
/// </remarks>
/// <param name="command">DICOM Command Dataset</param>
public DicomCStoreRequest(DicomDataset command)
: base(command)
{
}
public void ComplexTagNestingTests(string pathway, string conditional, string conditionalMatch, object expectedResults)
{
if (!string.IsNullOrWhiteSpace((string)expectedResults))
{
expectedResults = ((string)expectedResults).Replace("\r\n", Environment.NewLine);
}
// Arrange
var ds = new DicomDataset
{
//root->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "Root"),
//root->PseudoColorPaletteInstanceReferenceSequence
new DicomSequence(DicomTag.PseudoColorPaletteInstanceReferenceSequence,
new DicomDataset()
{
// Text multiplicity
//root->PseudoColorPaletteInstanceReferenceSequence->TextString
new DicomShortString(DicomTag.TextString, "abcd", "efgh"),
//root->PseudoColorPaletteInstanceReferenceSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "1.1"),
//root->PseudoColorPaletteInstanceReferenceSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence,
new DicomDataset
{
//root->PseudoColorPaletteInstanceReferenceSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2.1"),
//root->PseudoColorPaletteInstanceReferenceSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "2.2")
},
//root->PseudoColorPaletteInstanceReferenceSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomDataset
{
new DicomShortText(DicomTag.SpecimenShortDescription, "2.1")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->AbstractPriorCodeSequence
new DicomSequence(DicomTag.AbstractPriorCodeSequence,
new DicomDataset
{
//root->PseudoColorPaletteInstanceReferenceSequence->AbstractPriorCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PseudoColorPaletteInstanceReferenceSequence->AbstractPriorCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3.1"),
//root->PseudoColorPaletteInstanceReferenceSequence->AbstractPriorCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3.2")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->AbstractPriorCodeSequence
new DicomSequence(DicomTag.AbstractPriorCodeSequence,
new DicomDataset()
{
}),
//root->PseudoColorPaletteInstanceReferenceSequence->AbstractPriorCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2.1")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence
new DicomSequence(DicomTag.PatientGantryRelationshipCodeSequence,
new DicomDataset
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3.1"),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3.2")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2.1")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence [array of 3 sequences]
new DicomSequence(DicomTag.PatientInsurancePlanCodeSequence,
new DicomDataset[]
{
new DicomDataset
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3_0_.1"),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3_0_.2")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2_0_.1")
},
new DicomDataset
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3_1_.1"),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3_1_.2")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientInsurancePlanCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2_1_.1")
},
new DicomDataset
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->ProbeDriveEquipmentSequence
new DicomSequence(DicomTag.ProbeDriveEquipmentSequence, new DicomDataset()
{
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->ProbeDriveEquipmentSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "3_2_.1"),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->ProbeDriveEquipmentSequence->PatientID
new DicomShortString(DicomTag.PatientID, "3_2_.2")
}),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientGantryRelationshipCodeSequence->SpecimenShortDescription
new DicomShortText(DicomTag.SpecimenShortDescription, "2_2.1")
}
}),
//root->PseudoColorPaletteInstanceReferenceSequence->PatientID
new DicomDataset {
new DicomShortText(DicomTag.PatientID, "1.2")
}
}),
};
var elevator = new TagElevator(pathway, conditional, conditionalMatch);
ShowContentSequence(ds, DicomTag.PseudoColorPaletteInstanceReferenceSequence);
object value = elevator.GetValue(ds);
Assert.AreEqual(expectedResults, value);
}
/// <summary> /// Check that the dataset conforms to this constraint. /// </summary> /// <param name="dataSet"></param> /// <returns></returns> public abstract DicomConstraintResult Check(DicomDataset dataSet);
public DicomNSetRequest(DicomDataset command)
: base(command)
{
}
public static void ValidateReferencedSopSequence(DicomDataset actualDicomDataset, params (string SopInstanceUid, string RetrieveUri, string SopClassUid)[] expectedValues)
/// <summary>
/// Initializes a new instance of the <see cref="DicomCGetResponse"/> class.
/// </summary>
/// <param name="command">
/// The command associated with the C-GET operation.
/// </param>
public DicomCGetResponse(DicomDataset command)
: base(command)
{
}
public IAsyncResult BeginWrite(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset, AsyncCallback callback, object state)
{
_target = target;
_fileMetaInfo = fileMetaInfo;
_dataset = dataset;
_async = new EventAsyncResult(callback, state);
byte[] preamble = new byte[132];
preamble[128] = (byte)'D';
preamble[129] = (byte)'I';
preamble[130] = (byte)'C';
preamble[131] = (byte)'M';
_target.Write(preamble, 0, 132, OnCompletePreamble, null);
return(_async);
}
/// <summary>Creates DICOM image object from dataset</summary>
/// <param name="dataset">Source dataset</param>
/// <param name="frame">Zero indexed frame number</param>
public DicomImage(DicomDataset dataset, int frame = 0)
{
_scale = 1.0;
ShowOverlays = true;
Load(dataset, frame);
}
public void Write(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset)
{
EndWrite(BeginWrite(target, fileMetaInfo, dataset, null, null));
}
public DicomCEchoResponse(DicomDataset command)
: base(command)
{
}
