public static ModalityDataLut Create(IDicomElementProvider dicomElementProvider)
{
DicomElementSq modalityLutSequence = (DicomElementSq)dicomElementProvider[DicomTags.ModalityLutSequence];
int pixelRepresentation = GetPixelRepresentation(dicomElementProvider);
return(Create(modalityLutSequence, pixelRepresentation));
}
public static List <VoiDataLut> Create(IDicomElementProvider elementProvider)
{
if (elementProvider == null)
{
throw new ArgumentNullException("elementProvider");
}
DicomElementSq voiLutSequence = elementProvider[DicomTags.VoiLutSequence] as DicomElementSq;
if (voiLutSequence == null)
{
return(new List <VoiDataLut>());
}
DicomElementSq modalityLutSequence = elementProvider[DicomTags.ModalityLutSequence] as DicomElementSq;
int pixelRepresentation = GetPixelRepresentation(elementProvider);
if (IsValidAttribute(modalityLutSequence))
{
return(Create(voiLutSequence, modalityLutSequence, pixelRepresentation));
}
DicomElement rescaleInterceptElement = elementProvider[DicomTags.RescaleIntercept];
if (IsValidAttribute(rescaleInterceptElement))
{
double rescaleSlope = GetRescaleSlope(elementProvider);
double rescaleIntercept = rescaleInterceptElement.GetFloat64(0, 0);
int bitsStored = GetBitsStored(elementProvider);
return(Create(voiLutSequence, bitsStored, pixelRepresentation, rescaleSlope, rescaleIntercept));
}
return(Create(voiLutSequence, pixelRepresentation));
}
private static List <VoiDataLut> Create(DicomElementSq voiLutSequence, int pixelRepresentation)
{
bool isFirstMappedPixelSigned = pixelRepresentation != 0;
List <DataLut> dataLuts = DataLut.Create(voiLutSequence, isFirstMappedPixelSigned, false);
return(Convert(dataLuts));
}
/// <summary>
/// Initializes a new instance of the SequenceIodList class.
/// </summary>
public SequenceIodList(DicomElementSq dicomElementSq)
{
if (dicomElementSq == null)
{
throw new ArgumentNullException("dicomElementSq");
}
_dicomElementSq = dicomElementSq;
}
internal static ModalityDataLut Create(DicomElementSq modalityLutSequence, int pixelRepresentation)
{
List <DataLut> data = DataLut.Create(modalityLutSequence, pixelRepresentation != 0, false);
if (data.Count == 0)
{
return(null);
}
string modalityLutType = ((DicomSequenceItem[])modalityLutSequence.Values)[0][DicomTags.ModalityLutType].ToString();
return(new ModalityDataLut(data[0], modalityLutType));
}
public static List<DataLut> Create(DicomElementSq sequence, bool isFirstMappedPixelSigned, bool isLutDataSigned)
{
if (sequence == null)
throw new ArgumentNullException("sequence");
if (sequence.IsEmpty || sequence.IsNull)
return new List<DataLut>();
DicomSequenceItem[] sequenceItems = sequence.Values as DicomSequenceItem[];
if (sequenceItems == null || sequenceItems.Length == 0)
return new List<DataLut>();
return Create(sequenceItems, isFirstMappedPixelSigned, isLutDataSigned);
}
private static List <VoiDataLut> Create(DicomElementSq voiLutSequence, DicomElementSq modalityLutSequence, int pixelRepresentation)
{
ModalityDataLut modalityLut = ModalityDataLut.Create(modalityLutSequence, pixelRepresentation);
if (modalityLut == null)
{
throw new DicomDataException("Input Modality Lut Sequence is not valid.");
}
//Hounsfield units are always signed.
bool isFirstMappedPixelValueSigned = pixelRepresentation != 0 || modalityLut.ModalityLutType == "HU";
List <DataLut> dataLuts = Create(voiLutSequence, isFirstMappedPixelValueSigned, false);
return(Convert(dataLuts));
}
private static List <VoiDataLut> Create(DicomElementSq voiLutSequence, int bitsStored, int pixelRepresentation, double rescaleSlope, double rescaleIntercept)
{
int minPixelValue;
int maxPixelValue;
bool isSigned = pixelRepresentation != 0;
GetMinMaxPixelValue(bitsStored, isSigned, out minPixelValue, out maxPixelValue);
double minModalityLutValue = minPixelValue * rescaleSlope + rescaleIntercept;
double maxModalityLutValue = maxPixelValue * rescaleSlope + rescaleIntercept;
bool isFirstMappedPixelValueSigned = minModalityLutValue < 0 || maxModalityLutValue < 0;
List <DataLut> dataLuts = DataLut.Create(voiLutSequence, isFirstMappedPixelValueSigned, false);
return(Convert(dataLuts));
}
/// <summary>
/// Initializes a new instance of the <see cref="SequenceIodList<T>"/> class.
/// </summary>
/// <param name="tag">The tag.</param>
public SequenceIodList(uint tag)
{
_dicomElementSq = new DicomElementSq(tag);
}
/// <summary>
/// Initializes a new instance of the <see cref="SequenceIodList<T>"/> class.
/// </summary>
/// <param name="dicomTag">The dicom tag.</param>
public SequenceIodList(DicomTag dicomTag)
{
_dicomElementSq = new DicomElementSq(dicomTag);
}
public DicomWriteStatus Write(TransferSyntax syntax, DicomDataset dataset, DicomWriteOptions options)
{
TransferSyntax = syntax;
foreach (DicomElement item in dataset)
{
if (item.Tag.Element == 0x0000)
{
continue;
}
if (item.IsEmpty)
{
continue;
}
if (Flags.IsSet(options, DicomWriteOptions.CalculateGroupLengths) &&
item.Tag.Group != _group && item.Tag.Group <= 0x7fe0)
{
_group = item.Tag.Group;
_writer.Write((ushort)_group);
_writer.Write((ushort)0x0000);
if (_syntax.ExplicitVr)
{
_writer.Write((byte)'U');
_writer.Write((byte)'L');
_writer.Write((ushort)4);
}
else
{
_writer.Write((uint)4);
}
_writer.Write((uint)dataset.CalculateGroupWriteLength(_group, _syntax, options));
}
_writer.Write((ushort)item.Tag.Group);
_writer.Write((ushort)item.Tag.Element);
if (_syntax.ExplicitVr)
{
_writer.Write((byte)item.Tag.VR.Name[0]);
_writer.Write((byte)item.Tag.VR.Name[1]);
}
if (item is DicomElementSq)
{
DicomElementSq sq = item as DicomElementSq;
if (_syntax.ExplicitVr)
{
_writer.Write((ushort)0x0000);
}
if (Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequence))
{
int hl = _syntax.ExplicitVr ? 12 : 8;
_writer.Write((uint)sq.CalculateWriteLength(_syntax, options & ~DicomWriteOptions.CalculateGroupLengths) - (uint)hl);
}
else
{
_writer.Write((uint)UndefinedLength);
}
foreach (DicomSequenceItem ids in item.Values as DicomSequenceItem[])
{
_writer.Write((ushort)DicomTag.Item.Group);
_writer.Write((ushort)DicomTag.Item.Element);
if (Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequenceItem))
{
_writer.Write((uint)ids.CalculateWriteLength(_syntax, options & ~DicomWriteOptions.CalculateGroupLengths));
}
else
{
_writer.Write((uint)UndefinedLength);
}
Write(this.TransferSyntax, ids, options & ~DicomWriteOptions.CalculateGroupLengths);
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequenceItem))
{
_writer.Write((ushort)DicomTag.ItemDelimitationItem.Group);
_writer.Write((ushort)DicomTag.ItemDelimitationItem.Element);
_writer.Write((uint)0x00000000);
}
}
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequence))
{
_writer.Write((ushort)DicomTag.SequenceDelimitationItem.Group);
_writer.Write((ushort)DicomTag.SequenceDelimitationItem.Element);
_writer.Write((uint)0x00000000);
}
}
else if (item is DicomFragmentSequence)
{
DicomFragmentSequence fs = item as DicomFragmentSequence;
if (_syntax.ExplicitVr)
{
_writer.Write((ushort)0x0000);
}
_writer.Write((uint)UndefinedLength);
_writer.Write((ushort)DicomTag.Item.Group);
_writer.Write((ushort)DicomTag.Item.Element);
if (Flags.IsSet(options, DicomWriteOptions.WriteFragmentOffsetTable) && fs.HasOffsetTable)
{
_writer.Write((uint)fs.OffsetTableBuffer.Length);
fs.OffsetTableBuffer.CopyTo(_writer);
}
else
{
_writer.Write((uint)0x00000000);
}
foreach (DicomFragment bb in fs.Fragments)
{
_writer.Write((ushort)DicomTag.Item.Group);
_writer.Write((ushort)DicomTag.Item.Element);
_writer.Write((uint)bb.Length);
bb.GetByteBuffer(_syntax).CopyTo(_writer);
}
_writer.Write((ushort)DicomTag.SequenceDelimitationItem.Group);
_writer.Write((ushort)DicomTag.SequenceDelimitationItem.Element);
_writer.Write((uint)0x00000000);
}
else
{
DicomElement de = item;
ByteBuffer theData = de.GetByteBuffer(_syntax, dataset.SpecificCharacterSet);
if (_syntax.ExplicitVr)
{
if (de.Tag.VR.Is16BitLengthField)
{
_writer.Write((ushort)theData.Length);
}
else
{
_writer.Write((ushort)0x0000);
_writer.Write((uint)theData.Length);
}
}
else
{
_writer.Write((uint)theData.Length);
}
if (theData.Length > 0)
{
theData.CopyTo(_writer);
}
}
}
return(DicomWriteStatus.Success);
}
private void OnReceiveMWLQuery(DicomServer server, byte presentationId, DicomMessage message)
{
var tagList = new List <DicomTag>();
string specificCharacterSet = string.Empty;
foreach (var attrib in message.DataSet)
{
tagList.Add(attrib.Tag);
if (!attrib.IsNull)
{
switch (attrib.Tag.TagValue)
{
case DicomTags.SpecificCharacterSet:
specificCharacterSet = message.DataSet[DicomTags.SpecificCharacterSet];
break;
#region Case Scheduled Procedure Step Seq
case DicomTags.ScheduledProcedureStepSequence:
DicomElementSq sequence = attrib as DicomElementSq;
DicomSequenceItem sqSubItems = sequence[0];
foreach (var sqSubItem in sqSubItems)
{
if (sqSubItem.IsNull)
{
continue;
}
tagList.Add(sqSubItem.Tag);
switch (sqSubItem.Tag.TagValue)
{
case DicomTags.ScheduledStationName:
break;
case DicomTags.Modality:
break;
case DicomTags.ScheduledPerformingPhysiciansName:
break;
case DicomTags.ScheduledProcedureStepStartDate:
break;
case DicomTags.ScheduledProcedureStepStartTime:
break;
// Optional Matching keys
case DicomTags.ScheduledProcedureStepLocation:
break;
case DicomTags.ScheduledProcedureStepDescription:
break;
case DicomTags.RequestedProcedureId:
break;
case DicomTags.ScheduledProcedureStepId:
break;
default:
break;
}
}
break;
#endregion
case DicomTags.PatientId:
break;
case DicomTags.PatientsName:
break;
//Optional Matching Keys
case DicomTags.AccessionNumber:
break;
case DicomTags.ReferringPhysiciansName:
break;
default:
break;
}
}
}
// Populate result Information from Db
List <DicomMessage> results = new List <DicomMessage>();
try
{
foreach (var dicomMessage in results)
{
if (_cancelReceived)
{
throw new DicomException("DICOM C-Cancel Received");
}
server.SendCFindResponse(presentationId, message.MessageId, dicomMessage,
DicomStatuses.Pending);
}
}
catch (Exception)
{
if (_cancelReceived)
{
var errorResponse = new DicomMessage();
server.SendCFindResponse(presentationId, message.MessageId, errorResponse,
DicomStatuses.Cancel);
}
return;
}
var finalResponse = new DicomMessage();
server.SendCFindResponse(presentationId, message.MessageId, finalResponse, DicomStatuses.Success);
}
