public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (_match.Match(dataset))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _match.Tag);
dataset.AddOrUpdate(_match.Tag, _value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_src))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _dst);
dataset.AddOrUpdate(_dst, dataset.GetDicomItem <DicomElement>(_src).Buffer);
}
}
public void ConstraintsTestOrder()
{
var o0 = new OrderedIntConstraint(Order.Never, 42, DicomTag.SeriesNumber);
var o1 = new OrderedIntConstraint(Order.LessThan, 42, DicomTag.SeriesNumber);
var o2 = new OrderedIntConstraint(Order.LessThanOrEqual, 42, DicomTag.SeriesNumber);
var o3 = new OrderedIntConstraint(Order.Equal, 42, DicomTag.SeriesNumber);
var o4 = new OrderedIntConstraint(Order.GreaterThan, 42, DicomTag.SeriesNumber);
var o5 = new OrderedIntConstraint(Order.GreaterThanOrEqual, 42, DicomTag.SeriesNumber);
var o6 = new OrderedIntConstraint(Order.NotEqual, 42, DicomTag.SeriesNumber);
var o7 = new OrderedIntConstraint(Order.Always, 42, DicomTag.SeriesNumber);
DicomDataset ds = new DicomDataset
{
{ DicomTag.SeriesNumber, 41 },
};
Assert.IsFalse(o0.Check(ds).Result);
Assert.IsTrue(o1.Check(ds).Result);
Assert.IsTrue(o2.Check(ds).Result);
Assert.IsFalse(o3.Check(ds).Result);
Assert.IsFalse(o4.Check(ds).Result);
Assert.IsFalse(o5.Check(ds).Result);
Assert.IsTrue(o6.Check(ds).Result);
Assert.IsTrue(o7.Check(ds).Result);
ds.AddOrUpdate(DicomTag.SeriesNumber, 42);
Assert.IsFalse(o0.Check(ds).Result);
Assert.IsFalse(o1.Check(ds).Result);
Assert.IsTrue(o2.Check(ds).Result);
Assert.IsTrue(o3.Check(ds).Result);
Assert.IsFalse(o4.Check(ds).Result);
Assert.IsTrue(o5.Check(ds).Result);
Assert.IsFalse(o6.Check(ds).Result);
Assert.IsTrue(o7.Check(ds).Result);
ds.AddOrUpdate(DicomTag.SeriesNumber, 43);
Assert.IsFalse(o0.Check(ds).Result);
Assert.IsFalse(o1.Check(ds).Result);
Assert.IsFalse(o2.Check(ds).Result);
Assert.IsFalse(o3.Check(ds).Result);
Assert.IsTrue(o4.Check(ds).Result);
Assert.IsTrue(o5.Check(ds).Result);
Assert.IsTrue(o6.Check(ds).Result);
Assert.IsTrue(o7.Check(ds).Result);
}
public void ConstraintsTime()
{
var o0 = new TimeOrderConstraint(Order.Never, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
var o1 = new TimeOrderConstraint(Order.LessThan, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
var o2 = new TimeOrderConstraint(Order.LessThanOrEqual, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
var o3 = new TimeOrderConstraint(Order.Equal, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
var o4 = new TimeOrderConstraint(Order.GreaterThan, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
var o5 = new TimeOrderConstraint(Order.GreaterThanOrEqual, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
var o6 = new TimeOrderConstraint(Order.NotEqual, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
var o7 = new TimeOrderConstraint(Order.Always, new TimeSpan(11, 11, 11), DicomTag.SeriesTime);
DicomDataset ds = new DicomDataset
{
{ DicomTag.SeriesTime, new DateTime(2017, 2, 14, 10, 11, 11) },
};
Assert.IsFalse(o0.Check(ds).Result);
Assert.IsTrue(o1.Check(ds).Result);
Assert.IsTrue(o2.Check(ds).Result);
Assert.IsFalse(o3.Check(ds).Result);
Assert.IsFalse(o4.Check(ds).Result);
Assert.IsFalse(o5.Check(ds).Result);
Assert.IsTrue(o6.Check(ds).Result);
Assert.IsTrue(o7.Check(ds).Result);
ds.AddOrUpdate(DicomTag.SeriesTime, new DateTime(2017, 2, 14, 11, 11, 11));
Assert.IsFalse(o0.Check(ds).Result);
Assert.IsFalse(o1.Check(ds).Result);
Assert.IsTrue(o2.Check(ds).Result);
Assert.IsTrue(o3.Check(ds).Result);
Assert.IsFalse(o4.Check(ds).Result);
Assert.IsTrue(o5.Check(ds).Result);
Assert.IsFalse(o6.Check(ds).Result);
Assert.IsTrue(o7.Check(ds).Result);
ds.AddOrUpdate(DicomTag.SeriesTime, new DateTime(2017, 2, 14, 13, 11, 11));
Assert.IsFalse(o0.Check(ds).Result);
Assert.IsFalse(o1.Check(ds).Result);
Assert.IsFalse(o2.Check(ds).Result);
Assert.IsFalse(o3.Check(ds).Result);
Assert.IsTrue(o4.Check(ds).Result);
Assert.IsTrue(o5.Check(ds).Result);
Assert.IsTrue(o6.Check(ds).Result);
Assert.IsTrue(o7.Check(ds).Result);
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.GetString(_tag);
dataset.AddOrUpdate(_tag, value.ToLower());
}
}
public void AddOrUpdate_NonDefaultEncodedStringElement_StringIsPreserved()
{
var encoding = Encoding.GetEncoding("SHIFT_JIS");
var tag = DicomTag.AdditionalPatientHistory;
const string expected = "YamadaTarou山田太郎ﾔﾏﾀﾞﾀﾛｳ";
var dataset = new DicomDataset();
dataset.AddOrUpdate(DicomTag.SpecificCharacterSet, DicomEncoding.GetCharset(encoding));
dataset.AddOrUpdate(tag, expected);
// simulate some kind of serialization, so that the buffer data is created correctly
dataset.OnBeforeSerializing();
var actual = encoding.GetString(dataset.GetDicomItem <DicomElement>(tag).Buffer.Data);
Assert.Equal(expected, actual);
}
/// <summary>
/// Post-process step for the anonymised DICOM dataset.
/// </summary>
/// <param name="newds">The DICOM dataset.</param>
public void Postprocess(DicomDataset newds)
{
if (newds == null)
{
throw new ArgumentNullException(nameof(newds));
}
newds.TryGetValues(DicomTag.DeidentificationMethod, out string[] values);
var dicomDatasetDeidentificationMethods = values?.ToList() ?? new List <string>();
// The VR is LO - therefore chopping this down to 64 characters
dicomDatasetDeidentificationMethods.Add(DeidentificationMethodString.Substring(0, Math.Min(DeidentificationMethodString.Length, 64)));
newds.AddOrUpdate(DicomTag.DeidentificationMethod, dicomDatasetDeidentificationMethods.ToArray());
newds.AddOrUpdate(DicomTag.PatientIdentityRemoved, "YES");
newds.AddOrUpdate(DicomTag.LongitudinalTemporalInformationModified, "MODIFIED");
}
public void DicomValidation_ValidateUID()
{
var ds = new DicomDataset();
var validUid = "1.2.315.6666.0.0.0.8965.19187632.1";
ds.Add(DicomTag.StudyInstanceUID, validUid);
Assert.Equal(validUid, ds.GetSingleValue <string>(DicomTag.StudyInstanceUID));
var tooLongUid = validUid + "." + validUid;
var ex = Assert.ThrowsAny <DicomValidationException>(() => ds.AddOrUpdate(DicomTag.StudyInstanceUID, tooLongUid));
Assert.Contains("length", ex.Message);
var leadingZeroUid = validUid + ".03";
var ex2 = Assert.ThrowsAny <DicomValidationException>(() => ds.AddOrUpdate(DicomTag.SeriesInstanceUID, leadingZeroUid));
Assert.Contains("leading zero", ex2.Message);
}
public void Process(DicomDataset dicomDataset, DicomItem item, Dictionary <string, object> settings = null)
{
if (DateShiftScope == DateShiftScope.StudyInstance)
{
DateShiftFunction.DateShiftKeyPrefix = dicomDataset.GetSingleValue <string>(DicomTag.StudyInstanceUID);
}
else if (DateShiftScope == DateShiftScope.SeriesInstance)
{
DateShiftFunction.DateShiftKeyPrefix = dicomDataset.GetSingleValue <string>(DicomTag.SeriesInstanceUID);
}
else if (DateShiftScope == DateShiftScope.SopInstance)
{
DateShiftFunction.DateShiftKeyPrefix = dicomDataset.GetSingleValue <string>(DicomTag.SOPInstanceUID);
}
if (item.ValueRepresentation == DicomVR.DA)
{
var values = ((DicomDate)item).Get <string[]>().Select(x => DateShiftFunction.ShiftDateTime(Utility.ParseDicomDate(x))).Where(x => !DateTimeUtility.IndicateAgeOverThreshold(x));
dicomDataset.AddOrUpdate(item.Tag, values.Select(x => Utility.GenerateDicomDateString(x)).ToArray());
}
else if (item.ValueRepresentation == DicomVR.DT)
{
var results = new List <string>();
var values = ((DicomDate)item).Get <string[]>();
foreach (var value in values)
{
var dateObject = Utility.ParseDicomDateTime(value);
dateObject.DateValue = DateShiftFunction.ShiftDateTime(dateObject.DateValue);
if (!DateTimeUtility.IndicateAgeOverThreshold(dateObject.DateValue))
{
results.Add(Utility.GenerateDicomDateTimeString(dateObject));
}
}
if (results.Count != 0)
{
dicomDataset.AddOrUpdate(item.Tag, results.ToArray());
}
}
else
{
throw new Exception($"Dateshift is not supported for {item.ValueRepresentation}");
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.GetString(_tag);
value = Regex.Replace(value, _pattern, _replacement);
dataset.AddOrUpdate(_tag, value);
}
}
public void OnEndFragmentSequence()
{
if (_fragment != null)
{
// only add the dicomtag if no fragment has been skipped due to SkipLargeTags
DicomDataset ds = _datasets.Peek();
ds.AddOrUpdate(_fragment);
}
_fragment = null;
}
public void OnBeginSequence(IByteSource source, DicomTag tag, uint length)
{
var sq = new DicomSequence(tag);
_sequences.Push(sq);
DicomDataset ds = _datasets.Peek();
ds.AddOrUpdate(sq);
}
public void OnElement(IByteSource source, DicomTag tag, DicomVR vr, IByteBuffer data)
{
DicomElement element = vr.Code switch
{
"AE" => new DicomApplicationEntity(tag, data),
"AS" => new DicomAgeString(tag, data),
"AT" => new DicomAttributeTag(tag, data),
"CS" => new DicomCodeString(tag, data),
"DA" => new DicomDate(tag, data),
"DS" => new DicomDecimalString(tag, data),
"DT" => new DicomDateTime(tag, data),
"FD" => new DicomFloatingPointDouble(tag, data),
"FL" => new DicomFloatingPointSingle(tag, data),
"IS" => new DicomIntegerString(tag, data),
"LO" => new DicomLongString(tag, _encodings.Peek(), data),
"LT" => new DicomLongText(tag, _encodings.Peek(), data),
"OB" => new DicomOtherByte(tag, data),
"OD" => new DicomOtherDouble(tag, data),
"OF" => new DicomOtherFloat(tag, data),
"OL" => new DicomOtherLong(tag, data),
"OV" => new DicomOtherVeryLong(tag, data),
"OW" => new DicomOtherWord(tag, data),
"PN" => new DicomPersonName(tag, _encodings.Peek(), data),
"SH" => new DicomShortString(tag, _encodings.Peek(), data),
"SL" => new DicomSignedLong(tag, data),
"SS" => new DicomSignedShort(tag, data),
"ST" => new DicomShortText(tag, _encodings.Peek(), data),
"SV" => new DicomSignedVeryLong(tag, data),
"TM" => new DicomTime(tag, data),
"UC" => new DicomUnlimitedCharacters(tag, _encodings.Peek(), data),
"UI" => new DicomUniqueIdentifier(tag, data),
"UL" => new DicomUnsignedLong(tag, data),
"UN" => new DicomUnknown(tag, data),
"UR" => new DicomUniversalResource(tag, _encodings.Peek(), data),
"US" => new DicomUnsignedShort(tag, data),
"UT" => new DicomUnlimitedText(tag, _encodings.Peek(), data),
"UV" => new DicomUnsignedVeryLong(tag, data),
_ => throw new DicomDataException($"Unhandled VR in DICOM parser observer: {vr.Code}"),
};
if (element.Tag == DicomTag.SpecificCharacterSet)
{
Encoding[] encodings = _encodings.Peek();
if (element.Count > 0)
{
encodings = DicomEncoding.GetEncodings(element.Get <string[]>(0));
}
_encodings.Pop();
_encodings.Push(encodings);
}
DicomDataset ds = _datasets.Peek();
ds.AddOrUpdate(element);
}
public static void WriteStudy(this DicomDataset dataset, DicomStudy study)
{
dataset.AddOrUpdate(DicomTag.PatientName, study.Paitent.PatientName);
dataset.AddOrUpdate(DicomTag.PatientID, study.Paitent.PatientID);
dataset.AddOrUpdate(DicomTag.PatientSex, study.Paitent.PatientSex);
dataset.AddOrUpdate(DicomTag.StudyInstanceUID, study.StudyUID);
dataset.AddOrUpdate(DicomTag.StudyID, study.StudyID);
dataset.AddOrUpdate(DicomTag.StudyDate, study.StudyDate);
dataset.AddOrUpdate(DicomTag.StudyTime, study.StudyTime);
dataset.AddOrUpdate(DicomTag.NumberOfStudyRelatedInstances, study.SeriesCollection.Count.ToString());
}
public void Process(DicomDataset dicomDataset, DicomItem item, Dictionary <string, object> settings = null)
{
// var values = Utility.SplitValues(Encoding.UTF8.GetString(((DicomElement)item).Buffer.Data));
var redactedValues = new List <string>()
{
};
if (item.ValueRepresentation == DicomVR.AS)
{
var values = ((DicomAgeString)item).Get <string[]>();
foreach (var value in values)
{
var result = Utility.AgeToString(RedactFunction.RedactAge(Utility.ParseAge(value)));
if (result != null)
{
redactedValues.Add(result);
}
}
}
if (item.ValueRepresentation == DicomVR.DA)
{
var values = ((DicomDate)item).Get <string[]>();
foreach (var value in values)
{
var result = RedactFunction.RedactDateTime(Utility.ParseDicomDate(value));
if (result != null)
{
redactedValues.Add(Utility.GenerateDicomDateString((DateTimeOffset)result));
}
}
}
if (item.ValueRepresentation == DicomVR.DT)
{
var values = ((DicomDateTime)item).Get <string[]>();
foreach (var value in values)
{
var result = RedactFunction.RedactDateTime(Utility.ParseDicomDateTime(value));
if (result != null)
{
redactedValues.Add(Utility.GenerateDicomDateTimeString(result));
}
}
}
dicomDataset.Remove(item.Tag);
if (redactedValues.Count() != 0)
{
dicomDataset.AddOrUpdate(item.Tag, redactedValues.ToArray());
}
}
public void ConstraintCodeString()
{
DicomDataset ds = new DicomDataset();
ds.AddOrUpdate(DicomTag.BodyPartExamined, "PELVIS");
var d0 = new OrderedStringConstraint(Order.NotEqual, "SKULL", DicomTag.BodyPartExamined);
var c0 = new RequiredTagConstraint(TagRequirement.Optional, d0);
Assert.IsTrue(c0.Check(ds).Result);
}
public async Task GivenDicomTagWithDifferentVR_WhenValidated_ThenShouldSkip()
{
var featureConfiguration = Options.Create(new FeatureConfiguration()
{
EnableFullDicomItemValidation = false
});
DicomTag tag = DicomTag.Date;
DicomElement element = new DicomDateTime(tag, DateTime.Now);
_dicomDataset.AddOrUpdate(element);
_queryTags.Clear();
_queryTags.Add(new QueryTag(tag.BuildExtendedQueryTagStoreEntry()));
IDicomElementMinimumValidator validator = Substitute.For <IDicomElementMinimumValidator>();
_dicomDatasetValidator = new DicomDatasetValidator(featureConfiguration, validator, _queryTagService);
await _dicomDatasetValidator.ValidateAsync(_dicomDataset, requiredStudyInstanceUid : null);
validator.DidNotReceive().Validate(Arg.Any <DicomElement>());
}
public void ConstraintUID()
{
DicomDataset ds = new DicomDataset();
ds.AddOrUpdate(DicomTag.SOPClassUID, DicomUID.CTImageStorage);
var s0 = new UIDStringOrderConstraint(Order.Equal, DicomUID.CTImageStorage.UID, DicomTag.SOPClassUID);
var c0 = new RequiredTagConstraint(TagRequirement.PresentNotEmpty, s0);
Assert.IsTrue(c0.Check(ds).Result);
}
public void ConstraintRegex()
{
var c0 = new RegexConstraint(DicomTag.SeriesDescription, @"(hog)", RegexOptions.ECMAScript);
var c0R = new RequiredTagConstraint(TagRequirement.Optional, c0);
DicomDataset ds = new DicomDataset();
ds.AddOrUpdate(DicomTag.SeriesDescription, @"hog protocol v1");
Assert.IsTrue(c0R.Check(ds).Result);
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.GetString(_tag);
string[] parts = value.Split(_seperators);
value = string.Format(_format, parts);
dataset.AddOrUpdate(_tag, value);
}
}
/// <summary>Blanks an item to value suitable for the concrete item type.</summary>
/// <param name="dataset">Reference to the dataset</param>
/// <param name="item">DICOM item subject to blanking.</param>
/// <param name="nonZeroLength">Require that new value is non-zero length (dummy) value?</param>
private static void BlankItem(DicomDataset dataset, DicomItem item, bool nonZeroLength)
{
var tag = item.Tag;
if (item is DicomSequence)
{
dataset.AddOrUpdate <DicomDataset>(DicomVR.SQ, tag);
return;
}
// Special date/time cases
if (item is DicomDateTime)
{
dataset.AddOrUpdate(nonZeroLength
? new DicomDateTime(tag, DateTime.MinValue)
: new DicomDateTime(tag, Array.Empty <string>()));
return;
}
if (item is DicomDate)
{
dataset.AddOrUpdate(nonZeroLength
? new DicomDate(tag, DateTime.MinValue)
: new DicomDate(tag, Array.Empty <string>()));
return;
}
if (item is DicomTime)
{
dataset.AddOrUpdate(nonZeroLength
? new DicomTime(tag, DateTime.MinValue)
: new DicomTime(tag, Array.Empty <string>()));
return;
}
if (item is DicomStringElement stringElement)
{
dataset.AddOrUpdate(stringElement.ValueRepresentation, tag, string.Empty);
return;
}
if (IsOtherElement(item)) // Replaces with an empty array
{
var ctor = GetConstructor(item, typeof(DicomTag), typeof(IByteBuffer));
var updated = (DicomItem)ctor.Invoke(new object[] { tag, EmptyBuffer.Value });
dataset.AddOrUpdate(updated);
return;
}
var valueType = ElementValueType(item); // Replace with the default value
if (valueType != null)
{
var ctor = GetConstructor(item, typeof(DicomTag), valueType);
var updated = (DicomItem)ctor.Invoke(new[] { tag, Activator.CreateInstance(valueType) });
dataset.AddOrUpdate(updated);
}
}
public void CopyTo(DicomDataset dataset)
{
dataset.AddOrUpdate(DicomTag.PatientName, PatientName);
dataset.AddOrUpdate(DicomTag.PatientID, PatientId);
dataset.AddOrUpdate(DicomTag.AccessionNumber, AccessionNumber);
dataset.AddOrUpdate(DicomTag.ModalitiesInStudy, Modality);
dataset.AddOrUpdate(DicomTag.StudyDate, new DicomDateRange(StartDate, EndDate));
dataset.AddOrUpdate(DicomTag.StudyDescription, Description);
dataset.AddOrUpdate(DicomTag.NumberOfStudyRelatedInstances, "");
}
public void DicomValidation_ValidateDS()
{
var ds = new DicomDataset();
var validDS = "0.333333333333 "; // 16 chars
ds.Add(DicomTag.RescaleSlope, validDS);
Assert.Equal(validDS, ds.GetSingleValue <string>(DicomTag.RescaleSlope));
var notValidDS = "0.333333333333 "; // 17 chars
Assert.Throws <DicomValidationException>(() => ds.AddOrUpdate(DicomTag.RescaleSlope, notValidDS));
}
public void AddOrUpdatePixelData_InternalTransferSyntax_Succeeds()
{
var ds = new DicomDataset();
var data = new MemoryByteBuffer(new byte[] { 255 }); //dummy data
ds.AddOrUpdate(DicomTag.BitsAllocated, (ushort)8);
var pixelData = DicomPixelData.Create(ds, true);
pixelData.AddFrame(data);
Assert.Equal(DicomTransferSyntax.ExplicitVRLittleEndian, ds.InternalTransferSyntax);
}
internal void AddIfExistsInRequest <T>(DicomDataset dataset, DicomDataset request, DicomTag tag, T value)
{
if (request.Contains(tag))
{
if (value == null)
{
value = default(T);
}
dataset.AddOrUpdate(tag, value);
}
}
internal static void AddIfExistsInRequest <T>(DicomDataset result, DicomDataset request, DicomTag tag, T value)
{
// Only send items which have been requested
if (request.Contains(tag))
{
if (value == null)
{
value = default(T);
}
result.AddOrUpdate(tag, value);
}
}
private void CreateElement(string tagString, DicomDataset dicomRequest, string value)
{
// special include fields. Server include all by default.
if (tagString.ToLower() == "all")
{
return;
}
uint tag = GetTagValue(tagString);
dicomRequest.AddOrUpdate(tag, value);
}
public RoutedItem Dicomize(RoutedItem ri)
{
var routedItem = (RoutedItemEx)ri;
try
{
_logger.Log(LogLevel.Information, $"Attempting to DICOMIZE {routedItem.sourceFileName}");
DicomDataset data = new DicomDataset();
data.AddOrUpdate(DicomTag.PatientID, routedItem.PatientID);
data.AddOrUpdate(DicomTag.StudyInstanceUID, routedItem.Study);
data.AddOrUpdate(DicomTag.AccessionNumber, routedItem.AccessionNumber);
data.AddOrUpdate(DicomTag.SeriesInstanceUID, routedItem.AccessionNumber);
data.AddOrUpdate(DicomTag.SOPInstanceUID, routedItem.Sop);
data.AddOrUpdate(DicomTag.IssuerOfPatientID, routedItem.PatientIDIssuer);
data.Add(DicomTag.SOPClassUID, DicomUID.EncapsulatedPDFStorage);
byte[] fileData = _util.ReadBytesFromFile(routedItem.sourceFileName);
if (fileData.Length > 0)
{
data.Add(DicomTag.EncapsulatedDocument, fileData);
routedItem.sourceDicomFile = new DicomFile(data);
routedItem.sourceDicomFile.Save(routedItem.sourceFileName);
}
}
catch (Exception e)
{
_logger.Log(LogLevel.Critical, $"{routedItem.sourceFileName} cannot be DICOMIZED {e.Message} {e.StackTrace}");
}
return(routedItem);
}
static internal unsafe void Start(string[] args)
{
const string sourceFilePath = "/media/nikolaev_ov/CEFE3C54FE3C36D5/DICOM/gsps.pre";
const string destFilePath = "/media/nikolaev_ov/CEFE3C54FE3C36D5/DICOM/gsps2.pre";
DicomDataset sourceDataset = DicomFile.Open(sourceFilePath).Dataset;
HashSet <DicomTag> notRemovingTags = new HashSet <DicomTag>
{
DicomTag.StudyInstanceUID,
DicomTag.SeriesInstanceUID,
DicomTag.SOPInstanceUID,
DicomTag.SOPClassUID,
DicomTag.Modality,
DicomTag.SpecificCharacterSet,
DicomTag.ReferencedSeriesSequence,
DicomTag.GraphicAnnotationSequence,
DicomTag.GraphicLayerSequence,
DicomTag.DisplayedAreaSelectionSequence,
DicomTag.SoftcopyVOILUTSequence,
};
string StudyInstanceUID = sourceDataset.GetSingleValue <string>(DicomTag.StudyInstanceUID); //1.3.6.1.4.1.14519.5.2.1.6279.6001.298806137288633453246975630178
string SeriesInstanceUID = sourceDataset.GetSingleValue <string>(DicomTag.SeriesInstanceUID); //1.3.6.1.4.1.14519.5.2.1.6279.6001.298806137288633453246.1.2
string SOPInstanceUID = sourceDataset.GetSingleValue <string>(DicomTag.SOPInstanceUID); //1.3.6.1.4.1.14519.5.2.1.6279.6001.179049373636438705059.1.2
string SOPClassUID = sourceDataset.GetSingleValue <string>(DicomTag.SOPClassUID); //1.2.840.10008.5.1.4.1.1.11.1
string Modality = sourceDataset.GetSingleValue <string>(DicomTag.Modality); //1.2.840.10008.5.1.4.1.1.11.1
List <DicomTag> removingTags = new List <DicomTag>();
foreach (DicomItem item in sourceDataset)
{
if (!notRemovingTags.Contains(item.Tag))
{
removingTags.Add(item.Tag);
}
}
sourceDataset.Remove(removingTags.ToArray());
sourceDataset.AddOrUpdate(DicomTag.StudyInstanceUID, new DicomUID
(
"1.3.6.1.4.1.14519.5.2.1.6279.6001.298806137288633453246975630178",
"Study Instance UID",
DicomUidType.SOPInstance
));
sourceDataset.AddOrUpdate(DicomTag.SeriesInstanceUID, new DicomUID
(
"1.3.6.1.4.1.14519.5.2.1.6279.6001.298806137288633453246.1.2",
"Series Instance UID",
DicomUidType.SOPInstance
));
sourceDataset.AddOrUpdate(DicomTag.SOPInstanceUID, new DicomUID
(
"1.3.6.1.4.1.14519.5.2.1.6279.6001.179049373636438705059.1.2",
"SOP Instance UID",
DicomUidType.SOPInstance
));
sourceDataset.AddOrUpdate(DicomTag.SOPClassUID, "1.2.840.10008.5.1.4.1.1.11.1");
sourceDataset.AddOrUpdate(DicomTag.Modality, "PR");
sourceDataset.AddOrUpdate(DicomTag.SpecificCharacterSet, "ISO_IR 192");
new DicomFile(sourceDataset).Save(destFilePath);
}
public async Task StoreJpegs(string baseUri, string bearerToken, string patientId, string studyId,
string modality, string studyDate, params string[] files)
{
//Arrange
Assert.True(ValidateParameters(baseUri, bearerToken, patientId, studyId));
var httpClient = _stowRsTestFixture
.UseBaseUri(baseUri)
.UseBearerToken(bearerToken)
.Build();
var dataset = new DicomDataset();
dataset.AddOrUpdate(DicomTag.PatientID, patientId);
dataset.AddOrUpdate(DicomTag.StudyID, studyId);
//for JPEG you MUST define "Modality" and "StudyDate" tags
dataset.AddOrUpdate(DicomTag.Modality, modality);
dataset.AddOrUpdate(DicomTag.StudyDate, studyDate);
var dataToStore = TestHelper.FillDataWithBlobDataUris(dataset, files.Select(Path.GetFullPath));
var request = new HttpRequestMessage(HttpMethod.Post, _stowRsTestFixture.RequestUri)
{
Content = TestHelper.CreateMultipartContent(dataToStore)
};
//Act
var result = await httpClient.SendAsync(request);
//Assert
if (result.IsSuccessStatusCode == false)
{
_output.WriteLine(result.ReasonPhrase);
_output.WriteLine(await result.Content.ReadAsStringAsync());
}
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
}
/// <summary>
/// Regenerate all UIDs in a DICOM dataset.
/// </summary>
/// <param name="dataset">Dataset in which UIDs should be regenerated.</param>
public void RegenerateAll(DicomDataset dataset)
{
foreach (var ui in dataset.Where(x => x.ValueRepresentation == DicomVR.UI).ToArray())
{
var uid = dataset.Get<DicomUID>(ui.Tag);
if (uid.Type == DicomUidType.SOPInstance || uid.Type == DicomUidType.Unknown) dataset.AddOrUpdate(ui.Tag, this.Generate(uid));
}
foreach (var sq in dataset.Where(x => x.ValueRepresentation == DicomVR.SQ).Cast<DicomSequence>().ToArray())
{
foreach (var item in sq)
{
this.RegenerateAll(item);
}
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_src))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _dst);
dataset.AddOrUpdate(_dst, dataset.Get<IByteBuffer>(_src));
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag) && dataset.Get<string>(_tag, -1, String.Empty) == _match)
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
dataset.AddOrUpdate(_tag, _value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.Get<string>(_tag, -1, String.Empty);
if (_position == DicomTrimPosition.Start || _position == DicomTrimPosition.Both) while (value.StartsWith(_trim)) value = value.Substring(_trim.Length);
if (_position == DicomTrimPosition.End || _position == DicomTrimPosition.Both) while (value.EndsWith(_trim)) value = value.Substring(0, value.Length - _trim.Length);
dataset.AddOrUpdate(_tag, value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.Get<string>(_tag, -1, String.Empty);
value = Regex.Replace(value, _pattern, _replacement);
dataset.AddOrUpdate(_tag, value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.Get<string>(_tag, -1, String.Empty);
if (_totalLength < 0) value = value.PadLeft(-_totalLength, _paddingChar);
else value = value.PadRight(_totalLength, _paddingChar);
dataset.AddOrUpdate(_tag, value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.Get<string>(_tag, -1, String.Empty);
if (_position == DicomTrimPosition.Both)
{
if (_trim != null) value = value.Trim(_trim);
else value = value.Trim();
}
else if (_position == DicomTrimPosition.Start)
{
if (_trim != null) value = value.TrimStart(_trim);
else value = value.TrimStart();
}
else
{
if (_trim != null) value = value.TrimEnd(_trim);
else value = value.TrimEnd();
}
dataset.AddOrUpdate(_tag, value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.Get<string>(_tag, -1, String.Empty);
string[] parts = value.Split(_seperators);
value = String.Format(_format, parts);
dataset.AddOrUpdate(_tag, value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.Get<string>(_tag, -1, String.Empty);
string[] parts = value.Split('\\');
for (int i = 0; i < parts.Length; i++)
{
if (parts[i].Length > _length) parts[i] = parts[i].Substring(0, _length);
}
value = String.Join("\\", parts);
dataset.AddOrUpdate(_tag, value);
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
if (dataset.Contains(_tag))
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var value = dataset.Get<string>(_tag, -1, String.Empty);
dataset.AddOrUpdate(_tag, value.ToLower());
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
var uid = dataset.Get<DicomUID>(_tag);
dataset.AddOrUpdate(_tag, _generator.Generate(uid));
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
dataset.CopyTo(modifiedAttributesSequenceItem, _tag);
dataset.AddOrUpdate(_tag, _value);
}
private static void ProcessOverlays(DicomDataset input, DicomDataset output)
{
var overlays = DicomOverlayData.FromDataset(input.InternalTransferSyntax.IsEncapsulated ? output : input);
foreach (var overlay in overlays)
{
var dataTag = new DicomTag(overlay.Group, DicomTag.OverlayData.Element);
// Don't run conversion on non-embedded overlays.
if (output.Contains(dataTag)) continue;
// If embedded overlay, Overlay Bits Allocated should equal Bits Allocated (#110).
var bitsAlloc = output.Get(DicomTag.BitsAllocated, (ushort)0);
output.AddOrUpdate(new DicomTag(overlay.Group, DicomTag.OverlayBitsAllocated.Element), bitsAlloc);
var data = overlay.Data;
if (output.InternalTransferSyntax.IsExplicitVR) output.AddOrUpdate(new DicomOtherByte(dataTag, data));
else output.AddOrUpdate(new DicomOtherWord(dataTag, data));
}
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null)
{
IDbConnection connection = null;
try
{
if (_dbType == DatabaseType.MsSql) connection = new SqlConnection(_connectionString);
#if !__IOS__ && !__ANDROID__ && !NETSTANDARD
else if (_dbType == DatabaseType.Odbc) connection = new OdbcConnection(_connectionString);
#endif
using (IDbCommand command = connection.CreateCommand())
{
command.Connection = connection;
command.CommandText = _query;
for (int i = 0; i < _params.Count; i++)
{
var str = dataset.Get<string>(_params[i], -1, String.Empty);
SqlParameter prm = new SqlParameter(String.Format("@{0}", i), str);
command.Parameters.Add(prm);
}
connection.Open();
if (_output.Count == 0)
{
command.ExecuteNonQuery();
}
else
{
using (IDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
for (int i = 0; i < _output.Count; i++)
{
dataset.CopyTo(modifiedAttributesSequenceItem, _output[i]);
string str = reader.GetString(i);
dataset.AddOrUpdate(_output[i], str);
}
}
}
}
connection.Close();
connection = null;
}
}
finally
{
if (connection != null)
{
if (connection.State == ConnectionState.Closed || connection.State == ConnectionState.Broken) connection.Close();
connection.Dispose();
}
}
}
