/// <summary>
/// Read properties from the given DicomDataset, throwing if Type 1 parameters are not present.
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
public static DicomCommonImage Read(DicomDataset ds)
{
var sopCommon = DicomSOPCommon.Read(ds);
//throw
// Changed for new OSS fo-dicom-desktop
var position = ds.GetValues <double>(DicomTag.ImagePositionPatient);
var pixelSpacing = ds.GetValues <double>(DicomTag.PixelSpacing);
var rows = ds.GetSingleValue <int>(DicomTag.Rows);
var columns = ds.GetSingleValue <int>(DicomTag.Columns);
var imageType = ds.GetValues <string>(DicomTag.ImageType);
//var position = ds.Get<double[]>(DicomTag.ImagePositionPatient);
//var pixelSpacing = ds.Get<double[]>(DicomTag.PixelSpacing);
//var rows = ds.Get<int>(DicomTag.Rows);
//var columns = ds.Get<int>(DicomTag.Columns);
//var imageType = ds.Get<string[]>(DicomTag.ImageType);
var pPosition = new Point3D(position);
// Note that DICOM encodes this as (Y,X)!!!
var pSpacing = new Point2D(pixelSpacing[1], pixelSpacing[0]);
// no throw
// Changed for new OSS fo-dicom-desktop
var location = ds.GetSingleValueOrDefault <double>(DicomTag.SliceLocation, 0d);
var windowCenter = ds.GetSingleValueOrDefault <double>(DicomTag.WindowCenter, 0d);
var windowWidth = ds.GetSingleValueOrDefault <double>(DicomTag.WindowWidth, 0d);
//var location = ds.Get(DicomTag.SliceLocation, 0d);
//var windowCenter = ds.Get(DicomTag.WindowCenter, 0d);
//var windowWidth = ds.Get(DicomTag.WindowWidth, 0d);
return(new DicomCommonImage(sopCommon, pPosition, pSpacing, location, imageType, rows, columns, windowCenter, windowWidth));
}
public FrameGeometry(DicomDataset image)
{
FrameOfReferenceUid = image.GetSingleValueOrDefault(DicomTag.FrameOfReferenceUID, string.Empty);
FrameSize = new Point2(image.GetSingleValueOrDefault <int>(DicomTag.Columns, 0), image.GetSingleValueOrDefault <int>(DicomTag.Rows, 0));
if (image.Contains(DicomTag.ImagerPixelSpacing))
{
var imagerPixelSpacing = image.GetValues <double>(DicomTag.ImagerPixelSpacing);
PixelSpacingBetweenRows = imagerPixelSpacing[0];
PixelSpacingBetweenColumns = imagerPixelSpacing[1];
}
else if (image.Contains(DicomTag.PixelSpacing))
{
var pixelSpacing = image.GetValues <double>(DicomTag.PixelSpacing);
PixelSpacingBetweenRows = pixelSpacing[0];
PixelSpacingBetweenColumns = pixelSpacing[1];
}
else if (image.Contains(DicomTag.NominalScannedPixelSpacing))
{
var nominalPixelSpacing = image.GetValues <double>(DicomTag.NominalScannedPixelSpacing);
PixelSpacingBetweenRows = nominalPixelSpacing[0];
PixelSpacingBetweenColumns = nominalPixelSpacing[1];
}
var patientPosition = image.TryGetValues <double>(DicomTag.ImagePositionPatient, out var pos) ? pos : new double[] { };
var patientOrientation = image.TryGetValues <double>(DicomTag.ImageOrientationPatient, out var orient) ? orient : new double[] { };
InitializeCalcualtedVolumeData(patientPosition, patientOrientation);
InitializeTranformationMatrizes();
}
/// <inheritdoc />
public void AddFailure(DicomDataset dicomDataset, ushort failureReasonCode)
{
CreateDatasetIfNeeded();
if (!_dataset.TryGetSequence(DicomTag.FailedSOPSequence, out DicomSequence failedSopSequence))
{
failedSopSequence = new DicomSequence(DicomTag.FailedSOPSequence);
_dataset.Add(failedSopSequence);
}
var failedSop = new DicomDataset()
{
{ DicomTag.FailureReason, failureReasonCode },
};
// We want to turn off auto validation for FailedSOPSequence item
// because the failure might be caused by invalid UID value.
#pragma warning disable CS0618 // Type or member is obsolete
failedSop.AutoValidate = false;
#pragma warning restore CS0618 // Type or member is obsolete
failedSop.AddValueIfNotNull(
DicomTag.ReferencedSOPClassUID,
dicomDataset?.GetSingleValueOrDefault <string>(DicomTag.SOPClassUID));
failedSop.AddValueIfNotNull(
DicomTag.ReferencedSOPInstanceUID,
dicomDataset?.GetSingleValueOrDefault <string>(DicomTag.SOPInstanceUID));
failedSopSequence.Items.Add(failedSop);
}
public static PatientRecord ToPatient(DicomDataset record)
{
PatientRecord patient = new PatientRecord();
patient.PatientName = record.GetSingleValueOrDefault <string>(DicomTag.PatientName, null);
patient.PatientID = record.GetSingleValueOrDefault <string>(DicomTag.PatientID, null);
patient.PatientBirthDate = record.GetSingleValueOrDefault <string>(DicomTag.PatientBirthDate, null);
patient.PatientSex = record.GetSingleValueOrDefault <string>(DicomTag.PatientSex, null);
return(patient);
}
private static InstanceIdentifier ToInstanceIdentifier(DicomDataset dicomDataset)
{
EnsureArg.IsNotNull(dicomDataset, nameof(dicomDataset));
// Note: Here we 'GetSingleValueOrDefault' and let the constructor validate the identifier.
return(new InstanceIdentifier(
dicomDataset.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, string.Empty),
dicomDataset.GetSingleValueOrDefault(DicomTag.SeriesInstanceUID, string.Empty),
dicomDataset.GetSingleValueOrDefault(DicomTag.SOPInstanceUID, string.Empty)));
}
private SimpleWorklistResult GetWorklistResultFromDataset(DicomDataset dataset)
{
string name = dataset.GetSingleValueOrDefault(DicomTag.PatientName, string.Empty);
string sex = dataset.GetSingleValueOrDefault(DicomTag.PatientSex, string.Empty);
string age = dataset.GetSingleValueOrDefault(DicomTag.PatientAge, string.Empty);
string patId = dataset.GetSingleValueOrDefault(DicomTag.PatientID, string.Empty);
string studyUid = dataset.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, string.Empty);
return(new SimpleWorklistResult(name, sex, age, patId, studyUid));
}
/// <summary>
/// Creates an instance of <see cref="VersionedInstanceIdentifier"/> from <see cref="DicomDataset"/>.
/// </summary>
/// <param name="dicomDataset">The DICOM dataset to get the identifiers from.</param>
/// <param name="version">The version.</param>
/// <returns>An instance of <see cref="InstanceIdentifier"/> representing the <paramref name="dicomDataset"/>.</returns>
public static VersionedInstanceIdentifier ToVersionedInstanceIdentifier(this DicomDataset dicomDataset, long version)
{
EnsureArg.IsNotNull(dicomDataset, nameof(dicomDataset));
// Note: Here we 'GetSingleValueOrDefault' and let the constructor validate the identifier.
return(new VersionedInstanceIdentifier(
dicomDataset.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, string.Empty),
dicomDataset.GetSingleValueOrDefault(DicomTag.SeriesInstanceUID, string.Empty),
dicomDataset.GetSingleValueOrDefault(DicomTag.SOPInstanceUID, string.Empty),
version));
}
public static SeriesRecord ToSeries(DicomDataset record)
{
SeriesRecord series = new SeriesRecord();
series.SeriesUID = record.GetSingleValue <string>(DicomTag.SeriesInstanceUID);
series.SeriesNumber = record.GetSingleValueOrDefault <string>(DicomTag.SeriesNumber, null);
series.SeriesDate = record.GetSingleValueOrDefault <string>(DicomTag.SeriesDate, null);
series.SeriesTime = record.GetSingleValueOrDefault <string>(DicomTag.SeriesTime, null);
series.Modality = record.GetSingleValueOrDefault <string>(DicomTag.Modality, null);
return(series);
}
public DicomSeries(DicomDataset dataset)
{
Modality = dataset.GetSingleValueOrDefault(DicomTag.Modality, "");
Number = dataset.GetSingleValueOrDefault(DicomTag.SeriesNumber, "");
Description = dataset.GetSingleValueOrDefault(DicomTag.SeriesDescription, "");
Uid = dataset.GetSingleValueOrDefault(DicomTag.SeriesInstanceUID, "");
if (dataset.TryGetSingleValue(DicomTag.NumberOfSeriesRelatedInstances, out int instanceCount))
{
InstanceCount = instanceCount;
}
}
private ProcessContext InitContext(DicomDataset dataset)
{
var context = new ProcessContext
{
StudyInstanceUID = dataset.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, string.Empty),
SopInstanceUID = dataset.GetSingleValueOrDefault(DicomTag.SOPInstanceUID, string.Empty),
SeriesInstanceUID = dataset.GetSingleValueOrDefault(DicomTag.SeriesInstanceUID, string.Empty),
};
return(context);
}
public async Task Send_PrivateTags_DataSufficientlyTransported()
{
var port = Ports.GetNext();
using var _ = DicomServerFactory.Create <SimpleCStoreProvider>(port);
DicomDataset command = null, requestDataset = null, responseDataset = null;
var request = new DicomCStoreRequest(new DicomDataset
{
{ DicomTag.CommandField, (ushort)DicomCommandField.CStoreRequest },
{ DicomTag.AffectedSOPClassUID, DicomUID.CTImageStorage },
{ DicomTag.MessageID, (ushort)1 },
{ DicomTag.AffectedSOPInstanceUID, "1.2.3" },
});
var privateCreator = DicomDictionary.Default.GetPrivateCreator("Testing");
var privTag1 = new DicomTag(4013, 0x008, privateCreator);
var privTag2 = new DicomTag(4013, 0x009, privateCreator);
DicomDictionary.Default.Add(new DicomDictionaryEntry(privTag1, "testTag1", "testKey1", DicomVM.VM_1, false, DicomVR.CS));
DicomDictionary.Default.Add(new DicomDictionaryEntry(privTag2, "testTag2", "testKey2", DicomVM.VM_1, false, DicomVR.CS));
request.Dataset = new DicomDataset
{
{ DicomTag.Modality, "CT" },
{ privTag1, "TESTA" },
new DicomCodeString(privTag2, "TESTB")
};
request.OnResponseReceived = (req, res) =>
{
command = req.Command;
requestDataset = req.Dataset;
responseDataset = res.Dataset;
};
var client = DicomClientFactory.Create("127.0.0.1", port, false, "SCU", "ANY-SCP");
await client.AddRequestAsync(request).ConfigureAwait(false);
await client.SendAsync().ConfigureAwait(false);
Assert.Equal((ushort)1, command.GetSingleValue <ushort>(DicomTag.CommandField));
Assert.Equal("CT", requestDataset.GetString(DicomTag.Modality));
Assert.Equal("TESTB", requestDataset.GetSingleValueOrDefault <string>(privTag2, null));
Assert.Equal("TESTA", requestDataset.GetSingleValueOrDefault <string>(privTag1, null));
Assert.Equal("CT", responseDataset.GetSingleValue <string>(DicomTag.Modality));
Assert.Equal("TESTB", responseDataset.GetValueOrDefault <string>(privTag2, 0, null));
Assert.Equal("TESTA", responseDataset.GetSingleValueOrDefault <string>(privTag1, null));
}
private DicomDataset GetReferencedInstsance(DicomDataset ds)
{
var classUID = ds.GetSingleValueOrDefault <string> (DicomTag.SOPClassUID, null);
var sopUID = ds.GetSingleValueOrDefault <string> (DicomTag.SOPInstanceUID, null);
var dataset = new DicomDataset( )
{
AutoValidate = false
};
dataset.AddOrUpdate(DicomTag.SOPClassUID, classUID);
dataset.AddOrUpdate(DicomTag.SOPInstanceUID, sopUID);
return(dataset);
}
private static Patient GetPatient(DicomDataset dataSet)
{
var result = new Patient();
string name = dataSet.GetSingleValueOrDefault(DicomTag.PatientName, string.Empty);
var id = dataSet.GetSingleValueOrDefault(DicomTag.PatientID, string.Empty);
var dateOfBirth = dataSet.GetSingleValueOrDefault(DicomTag.PatientBirthDate, string.Empty);
result.ParseDicomPersonName(name);
result.ParseDicomDateOfBirth(dateOfBirth);
result.Id = id;
return(result);
}
private IStorageLocation RetrieveSopInstance(DicomDataset query)
{
var seriesInstanceUID = query.GetSingleValueOrDefault(DicomTag.SeriesInstanceUID, string.Empty);
var sOPInstanceUID = query.GetSingleValueOrDefault(DicomTag.SOPInstanceUID, string.Empty);
var studyInstanceUID = query.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, string.Empty);
IObjectId odjId = new ObjectId()
{
SeriesInstanceUID = seriesInstanceUID,
SOPInstanceUID = sOPInstanceUID,
StudyInstanceUID = studyInstanceUID
};
return(PacsServer.RetrieveService.RetrieveSopInstance(odjId, new DicomMediaProperties(MimeMediaTypes.DICOM, "1.2.840.10008.1.2.1")));
}
public ImageRecord AddImageItem(DicomDataset dicom)
{
string seriesUID = dicom.GetSingleValue <string>(DicomTag.SeriesInstanceUID);
var series = SeriesCollection.FirstOrDefault(s => s.SeriesUID == seriesUID);
if (series == null)
{
series = DicomRecord.ToSeries(dicom);
_seriesItems.Add(series);
// Add new series.
AddNewSeriesEvent(this);
}
string imageUID = dicom.GetSingleValue <string>(DicomTag.SOPInstanceUID);
ImageRecord image = series.ImageCollection.FirstOrDefault(i => i.SOPInstanceUID == imageUID);
if (image == null)
{
image = new ImageRecord();
image.SOPInstanceUID = dicom.GetSingleValue <string>(DicomTag.SOPInstanceUID);
image.ImageNumber = dicom.GetSingleValueOrDefault <string>(DicomTag.InstanceNumber, null);
// Add new image.
series.AddImage(image);
AddNewImageEvent(this);
}
else
{
}
return(image);
}
public static bool IsOutOfRange(DicomDataset request)
{
if (request.Contains(DicomTag.ScheduledProcedureStepSequence))
{
DicomDataset procedureStep = request.GetSequence(DicomTag.ScheduledProcedureStepSequence).First();
var scheduledProcedureStepStartDate = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepStartDate, string.Empty);
Logger.Info($"scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
Log.Loger($"scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
if (!string.IsNullOrEmpty(scheduledProcedureStepStartDate) && scheduledProcedureStepStartDate != "*")
{
var index = scheduledProcedureStepStartDate.IndexOf("-");
if (index >= 0)
{
scheduledProcedureStepStartDate = scheduledProcedureStepStartDate.Substring(0, index);
Logger.Info($"New scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
Log.Loger($"New scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
}
if (string.IsNullOrEmpty(scheduledProcedureStepStartDate))
{
return(true);
}
DateTime endDate = System.DateTime.Today.AddDays(1).AddSeconds(-1);
DateTime startDate = endDate.AddDays(_cacheDays * -1);
//DicomDateRange range = new DicomDateTime(DicomTag.ScheduledProcedureStepStartDate, startDate).Get<DicomDateRange>();
DicomDateRange range = new DicomDateRange(startDate, endDate);
DateTime queryStartDate = new DicomDateTime(DicomTag.ScheduledProcedureStepStartDate, scheduledProcedureStepStartDate).Get <DateTime>();
return(!range.Contains(queryStartDate));
}
}
return(false);
}
/// <summary>获取时间类型
/// </summary>
public static DateTime?GetTime(this DicomDataset dataset, DicomTag tag, DateTime?defaultValue = null)
{
var timeStringValue = dataset.GetSingleValueOrDefault(tag, "");
if (timeStringValue.IsNullOrWhiteSpace())
{
return(defaultValue);
}
if (Regex.IsMatch(timeStringValue, @"^[\d]{6}$"))
{
if (DateTime.TryParseExact(timeStringValue, "HHmmss", CultureInfo.CurrentCulture, DateTimeStyles.None, out DateTime d1))
{
return(d1);
}
}
else if (Regex.IsMatch(timeStringValue, @"^[\d]{4}$"))
{
if (DateTime.TryParseExact(timeStringValue, "HHmm", CultureInfo.CurrentCulture, DateTimeStyles.None, out DateTime d1))
{
return(d1);
}
}
if (DateTime.TryParse(timeStringValue, out DateTime d2))
{
return(d2);
}
return(defaultValue);
}
protected virtual void WriteVR_Default(DicomDataset ds, DicomElement element, XmlWriter writer)
{
DicomVR dicomVr = element.ValueRepresentation;
for (int index = 0; index < element.Count; index++)
{
writer.WriteStartElement(Constants.ATTRIBUTE_VALUE_NAME);
WriteNumberAttrib(writer, index);
if (dicomVr.Equals(DicomVR.AT))
{
var atElement = ds.GetSingleValueOrDefault <DicomElement> (element.Tag, null);
if (null != atElement)
{
var tagValue = atElement.Get <DicomTag> ( );
string stringValue = tagValue.ToString("J", null);
writer.WriteString(stringValue);
}
else
{
writer.WriteString(string.Empty);
}
}
else
{
writer.WriteString(GetTrimmedString(ds.GetValueOrDefault(element.Tag, index, string.Empty)));
}
writer.WriteEndElement( );
}
}
/// <summary>
/// Applies user DICOM tag replacement rules to a dataset
/// </summary>
/// <param name="dicomDataSet">The dicom dataset.</param>
/// <param name="replacement">The replacement.</param>
public static void ApplyUserReplacement(DicomDataset dicomDataSet, TagReplacement replacement)
{
dicomDataSet = dicomDataSet ?? throw new ArgumentNullException(nameof(dicomDataSet));
replacement = replacement ?? throw new ArgumentNullException(nameof(replacement));
// We must do contains otherwise if the tag is present but empty it will return null
var tag = replacement.DicomTagIndex.DicomTag;
if (dicomDataSet.Contains(tag))
{
var sourceTagValue = dicomDataSet.GetSingleValueOrDefault(tag, string.Empty);
if (replacement.Operation == TagReplacementOperation.UpdateIfExists)
{
dicomDataSet.AddOrUpdate(tag, replacement.Value);
}
else if (replacement.Operation == TagReplacementOperation.AppendIfExists)
{
dicomDataSet.AddOrUpdate(tag, $"{sourceTagValue}{replacement.Value}");
}
else
{
throw new InvalidOperationException(nameof(replacement));
}
}
}
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.GetSingleValueOrDefault(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 Get_NonGenericWithIntArgumentTagNonExisting_ShouldNotThrow()
{
var dataset = new DicomDataset();
var e = Record.Exception(() => Assert.Equal(20, dataset.GetSingleValueOrDefault(DicomTag.MetersetRate, 20)));
Assert.Null(e);
}
public DicomStudy(DicomDataset dataset)
{
PatientName = dataset.GetSingleValueOrDefault(DicomTag.PatientName, "");
PatientId = dataset.GetSingleValueOrDefault(DicomTag.PatientID, "");
AccessionNumber = dataset.GetSingleValueOrDefault(DicomTag.AccessionNumber, "");
Modality = dataset.GetString(DicomTag.ModalitiesInStudy);
if (dataset.TryGetSingleValue(DicomTag.StudyDate, out DateTime date))
{
Date = date;
}
Description = dataset.GetSingleValueOrDefault(DicomTag.StudyDescription, "");
Uid = dataset.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, "");
if (dataset.TryGetSingleValue(DicomTag.NumberOfStudyRelatedInstances, out int imageCount))
{
ImageCount = imageCount;
}
}
private static void AddLongRow(DicomDataset instance, List <InsertLongExtendedQueryTagTableTypeV1Row> longRows, QueryTag queryTag)
{
long?longVal = instance.GetSingleValueOrDefault <long>(queryTag.Tag, expectedVR: queryTag.VR);
if (longVal.HasValue)
{
longRows.Add(new InsertLongExtendedQueryTagTableTypeV1Row(queryTag.ExtendedQueryTagStoreEntry.Key, longVal.Value, (byte)queryTag.Level));
}
}
public void GivenDicomTagWithDifferentVR_WhenGetSingleOrDefaultIsCalled_ThenShouldReturnNull()
{
DicomTag tag = DicomTag.AbortReason;
DicomVR expectedVR = DicomVR.CS;
DicomElement element = new DicomLongString(tag, "Value");
_dicomDataset.Add(element);
Assert.Null(_dicomDataset.GetSingleValueOrDefault <string>(tag, expectedVR));
}
private static ImageRecord ToImage(DicomDataset record)
{
ImageRecord image = new ImageRecord();
image.SOPInstanceUID = record.GetSingleValue <string>(DicomTag.SOPInstanceUID);
image.ImageNumber = record.GetSingleValueOrDefault <string>(DicomTag.InstanceNumber, null);
return(image);
}
private static void AddDoubleRow(DicomDataset instance, List <InsertDoubleExtendedQueryTagTableTypeV1Row> doubleRows, QueryTag queryTag)
{
double?doubleVal = instance.GetSingleValueOrDefault <double>(queryTag.Tag, expectedVR: queryTag.VR);
if (doubleVal.HasValue)
{
doubleRows.Add(new InsertDoubleExtendedQueryTagTableTypeV1Row(queryTag.ExtendedQueryTagStoreEntry.Key, doubleVal.Value, (byte)queryTag.Level));
}
}
private static void AddStringRow(DicomDataset instance, List <InsertStringExtendedQueryTagTableTypeV1Row> stringRows, QueryTag queryTag)
{
string stringVal = instance.GetSingleValueOrDefault <string>(queryTag.Tag, expectedVR: queryTag.VR);
if (stringVal != null)
{
stringRows.Add(new InsertStringExtendedQueryTagTableTypeV1Row(queryTag.ExtendedQueryTagStoreEntry.Key, stringVal, (byte)queryTag.Level));
}
}
public static ImageRecord ToImage(DicomDataset record)
{
ImageRecord image = new ImageRecord();
image.SOPInstanceUID = record.GetSingleValue <string>(DicomTag.ReferencedSOPInstanceUIDInFile);
image.ImageNumber = record.GetSingleValueOrDefault <string>(DicomTag.InstanceNumber, null);
image.ReferencedFileID = record.GetValueOrDefault <string>(DicomTag.ReferencedFileID, 0, null);
return(image);
}
/// <summary>
/// Return true if and only if the DicomDataset has the RT Structure set SOPClassUID
/// </summary>
/// <param name="dicomDataSet">The DICOM data set.</param>
/// <returns>If the current dataset is an RT structure file.</returns>
public static bool IsRTStructure(this DicomDataset dicomDataSet)
{
if (dicomDataSet == null)
{
throw new ArgumentNullException(nameof(dicomDataSet), "The Dicom data set is null");
}
return(dicomDataSet.GetSingleValueOrDefault(
DicomTag.SOPClassUID,
new DicomUID(string.Empty, string.Empty, DicomUidType.Unknown)) == DicomUID.RTStructureSetStorage);
}
public override async Task <long> BeginCreateInstanceIndexAsync(int partitionKey, DicomDataset instance, IEnumerable <QueryTag> queryTags, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(instance, nameof(instance));
EnsureArg.IsNotNull(queryTags, nameof(queryTags));
using (SqlConnectionWrapper sqlConnectionWrapper = await SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(cancellationToken))
using (SqlCommandWrapper sqlCommandWrapper = sqlConnectionWrapper.CreateSqlCommand())
{
var rows = ExtendedQueryTagDataRowsBuilder.Build(instance, queryTags.Where(tag => tag.IsExtendedQueryTag), Version);
VLatest.AddInstanceV6TableValuedParameters parameters = new VLatest.AddInstanceV6TableValuedParameters(
rows.StringRows,
rows.LongRows,
rows.DoubleRows,
rows.DateTimeWithUtcRows,
rows.PersonNameRows
);
VLatest.AddInstanceV6.PopulateCommand(
sqlCommandWrapper,
partitionKey,
instance.GetString(DicomTag.StudyInstanceUID),
instance.GetString(DicomTag.SeriesInstanceUID),
instance.GetString(DicomTag.SOPInstanceUID),
instance.GetSingleValueOrDefault <string>(DicomTag.PatientID),
instance.GetSingleValueOrDefault <string>(DicomTag.PatientName),
instance.GetSingleValueOrDefault <string>(DicomTag.ReferringPhysicianName),
instance.GetStringDateAsDate(DicomTag.StudyDate),
instance.GetSingleValueOrDefault <string>(DicomTag.StudyDescription),
instance.GetSingleValueOrDefault <string>(DicomTag.AccessionNumber),
instance.GetSingleValueOrDefault <string>(DicomTag.Modality),
instance.GetStringDateAsDate(DicomTag.PerformedProcedureStepStartDate),
instance.GetStringDateAsDate(DicomTag.PatientBirthDate),
instance.GetSingleValueOrDefault <string>(DicomTag.ManufacturerModelName),
(byte)IndexStatus.Creating,
parameters);
try
{
return((long)(await sqlCommandWrapper.ExecuteScalarAsync(cancellationToken)));
}
catch (SqlException ex)
{
if (ex.Number == SqlErrorCodes.Conflict)
{
if (ex.State == (byte)IndexStatus.Creating)
{
throw new PendingInstanceException();
}
throw new InstanceAlreadyExistsException();
}
throw new DataStoreException(ex);
}
}
}
