public void Transform(DcmDataset dataset)
{
if (dataset.Contains(_src))
{
dataset.AddElementWithValueString(_dst, dataset.GetValueString(_src));
}
}
public void Transform(DcmDataset dataset)
{
if (dataset.Contains(_tag) && dataset.GetValueString(_tag) == _match)
{
dataset.AddElementWithValueString(_tag, _value);
}
}
public void AddSequenceItem(DcmDataset itemDataset)
{
DcmItemSequenceItem item = new DcmItemSequenceItem();
item.Dataset = itemDataset;
AddSequenceItem(item);
}
public void Transform(DcmDataset dataset)
{
IDbConnection connection = null;
try {
if (_dbType == DatabaseType.Odbc)
{
connection = new OdbcConnection(_connectionString);
}
else if (_dbType == DatabaseType.MsSql)
{
connection = new SqlConnection(_connectionString);
}
using (IDbCommand command = connection.CreateCommand()) {
command.Connection = connection;
command.CommandText = _query;
for (int i = 0; i < _params.Count; i++)
{
string str = dataset.GetValueString(_params[i]);
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++)
{
string str = reader.GetString(i);
dataset.AddElementWithValueString(_output[i], str);
}
}
}
}
connection.Close();
connection = null;
}
} finally {
if (connection != null)
{
if (connection.State == ConnectionState.Closed || connection.State == ConnectionState.Broken)
{
connection.Close();
}
connection.Dispose();
}
}
}
public static void DumpFrameToDisk(DcmDataset data, int frame, string file)
{
DcmPixelData pixelData = new DcmPixelData(data);
byte[] pixels = pixelData.GetFrameDataU8(frame);
File.WriteAllBytes(file, pixels);
}
private void InsertDatasetItem(DcmItem item, DicomReadOptions options)
{
if (_sds.Count > 0 && _sds.Count == _sqs.Count)
{
DcmDataset ds = _sds.Peek();
if (_tag.Element == 0x0000)
{
if (Flags.IsSet(options, DicomReadOptions.KeepGroupLengths))
{
ds.AddItem(item);
}
}
else
{
ds.AddItem(item);
}
if (ds.StreamLength != UndefinedLength)
{
long end = ds.StreamPosition + ds.StreamLength;
if ((_stream.Position - _offset) >= end)
{
_sds.Pop();
}
}
}
else
{
if (_tag.Element == 0x0000)
{
if (Flags.IsSet(options, DicomReadOptions.KeepGroupLengths))
{
_dataset.AddItem(item);
}
}
else
{
_dataset.AddItem(item);
}
}
if (_tag == DicomTags.SpecificCharacterSet && item is DcmCodeString)
{
DcmCodeString cs = (DcmCodeString)item;
if (cs.Length > 0)
{
string[] values = cs.GetValues();
for (int i = 0; i < values.Length; i++)
{
if (String.IsNullOrEmpty(values[i]))
{
continue;
}
_encoding = DcmEncoding.GetEncodingForSpecificCharacterSet(values[i]);
break;
}
}
}
}
public bool Match(DcmDataset dataset)
{
if (_operator == DicomMatchOperator.Or)
{
foreach (IDicomMatchRule rule in _rules)
{
if (rule.Match(dataset))
{
return(true);
}
}
return(false);
}
else
{
foreach (IDicomMatchRule rule in _rules)
{
if (!rule.Match(dataset))
{
return(false);
}
}
return(true);
}
}
public static IPipeline Create(DcmDataset dataset, DcmPixelData pixelData)
{
PhotometricInterpretation pi = PhotometricInterpretation.Lookup(pixelData.PhotometricInterpretation);
if (pi == PhotometricInterpretation.Monochrome1 || pi == PhotometricInterpretation.Monochrome2)
{
GenericGrayscalePipeline pipeline = new GenericGrayscalePipeline(pixelData.RescaleSlope, pixelData.RescaleIntercept, pixelData.BitsStored, pixelData.IsSigned);
if (pi == PhotometricInterpretation.Monochrome1)
{
pipeline.ColorMap = ColorTable.Monochrome1;
}
else
{
pipeline.ColorMap = ColorTable.Monochrome2;
}
WindowLevel[] wl = WindowLevel.FromDataset(dataset);
if (wl.Length > 0)
{
pipeline.WindowLevel = wl[0];
}
return(pipeline);
}
else if (pi == PhotometricInterpretation.Rgb)
{
return(new RgbColorPipeline());
}
else
{
throw new DicomImagingException("Unsupported pipeline photometric interpretation: {0}", pi.Value);
}
}
public static DcmDataset ToDICOM(XDocument document)
{
DcmDataset dataset = new DcmDataset(DicomTransferSyntax.ExplicitVRLittleEndian);
Save(document.Root, dataset);
return(dataset);
}
protected override void OnReceiveNSetResponse(byte presentationID, ushort messageIdRespondedTo, DicomUID affectedClass, DicomUID affectedInstance,
DcmDataset dataset, DcmStatus status)
{
if (_filmSession != null)
{
// ReSharper disable PossibleUnintendedReferenceComparison
if (affectedClass == DicomUID.BasicColorImageBoxSOPClass ||
affectedClass == DicomUID.BasicGrayscaleImageBoxSOPClass)
// ReSharper restore PossibleUnintendedReferenceComparison
{
if (status == DcmStatus.Success)
{
DcmImageBox imageBox = _filmSession.FindImageBox(affectedInstance);
if (imageBox != null)
{
_pendingImageBoxResponses.Remove(imageBox);
if (_pendingImageBoxResponses.Count == 0)
{
byte pcid = Associate.FindAbstractSyntax(DicomUID.PrinterSOPClass);
SendNActionRequest(pcid, NextMessageID(), DicomUID.BasicFilmSessionSOPClass, _filmSession.SOPInstanceUID, 0x0001, null);
}
return;
}
}
}
}
SendAbort(DcmAbortSource.ServiceUser, DcmAbortReason.NotSpecified);
}
protected override void OnReceiveNActionResponse(byte presentationID, ushort messageIdRespondedTo, DicomUID affectedClass, DicomUID affectedInstance,
ushort actionTypeID, DcmDataset dataset, DcmStatus status)
{
if (_filmSession != null)
{
// ReSharper disable PossibleUnintendedReferenceComparison
if (affectedClass == DicomUID.BasicFilmSessionSOPClass)
// ReSharper restore PossibleUnintendedReferenceComparison
{
if (status == DcmStatus.Success)
{
_pendingFilmBoxResponses.Clear();
byte pcid = Associate.FindAbstractSyntax(DicomUID.PrinterSOPClass);
foreach (DcmFilmBox filmBox in _filmSession.BasicFilmBoxes)
{
_pendingFilmBoxResponses.Add(filmBox);
SendNDeleteRequest(pcid, NextMessageID(), DicomUID.BasicFilmBoxSOPClass, filmBox.SOPInstanceUID);
}
return;
}
}
}
SendAbort(DcmAbortSource.ServiceUser, DcmAbortReason.NotSpecified);
}
private TreeModel LoadDataset(DcmDataset ds)
{
TreeModel model = new TreeModel();
LoadDataset(ds, model.Nodes);
return(model);
}
protected override void OnReceiveDimseBegin(byte pcid, DcmCommand command, DcmDataset dataset, DcmDimseProgress progress)
{
if (command.CommandField == DcmCommandField.CStoreRequest && OnCStoreRequestBegin != null)
{
OnCStoreRequestBegin(this, pcid, command, dataset, progress);
}
}
/// <summary>
/// Loads a dicom file, stopping at a certain tag
/// </summary>
/// <param name="file">Filename</param>
/// <param name="stopTag">Tag to stop parsing at</param>
/// <param name="options">DICOM read options</param>
public DicomReadStatus Load(String file, DicomTag stopTag, DicomReadOptions options)
{
using (FileStream fs = File.OpenRead(file)) {
fs.Seek(128, SeekOrigin.Begin);
CheckFileHeader(fs);
DicomStreamReader dsr = new DicomStreamReader(fs);
_metainfo = new DcmFileMetaInfo();
dsr.Dataset = _metainfo;
dsr.Read(DcmFileMetaInfo.StopTag, options | DicomReadOptions.FileMetaInfoOnly);
if (_metainfo.TransferSyntax.IsDeflate)
{
MemoryStream ms = StreamUtility.Deflate(fs, false);
dsr = new DicomStreamReader(ms);
}
_dataset = new DcmDataset(_metainfo.TransferSyntax);
dsr.Dataset = _dataset;
DicomReadStatus status = dsr.Read(stopTag, options);
fs.Close();
return(status);
}
}
/// <summary>
/// Initializes new Basic Image Box
/// </summary>
/// <param name="filmBox">Basic Film Box</param>
/// <param name="sopClass">SOP Class UID</param>
/// <param name="sopInstance">SOP Instance UID</param>
public DcmImageBox(DcmFilmBox filmBox, DicomUID sopClass, DicomUID sopInstance)
{
_filmBox = filmBox;
_sopClass = sopClass;
_sopInstance = sopInstance;
_dataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
}
/// <summary>
/// Initializes new Basic Image Box
/// </summary>
/// <param name="filmBox">Basic Film Box</param>
/// <param name="sopClass">SOP Class UID</param>
/// <param name="sopInstance">SOP Instance UID</param>
/// <param name="dataset">Dataset</param>
public DcmImageBox(DcmFilmBox filmBox, DicomUID sopClass, DicomUID sopInstance, DcmDataset dataset)
{
_filmBox = filmBox;
_sopClass = sopClass;
_sopInstance = sopInstance;
_dataset = dataset;
}
/// <summary>
/// Initializes new Basic Film Box
/// </summary>
/// <param name="session">Basic Film Session</param>
/// <param name="sopInstance">SOP Instance UID</param>
/// <param name="dataset">Dataset</param>
public DcmFilmBox(DcmFilmSession session, DicomUID sopInstance, DcmDataset dataset)
{
_session = session;
_sopInstance = sopInstance;
_dataset = dataset;
_boxes = new List <DcmImageBox>();
}
/// <summary>
/// Initializes new Basic Film Box
/// </summary>
/// <param name="session">Basic Film Session</param>
/// <param name="sopInstance">SOP Instance UID</param>
public DcmFilmBox(DcmFilmSession session, DicomUID sopInstance)
{
_session = session;
_sopInstance = sopInstance;
_dataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
_boxes = new List <DcmImageBox>();
}
public void Transform(DcmDataset dataset)
{
if (dataset.Contains(_tag))
{
string value = dataset.GetValueString(_tag);
dataset.AddElementWithValueString(_tag, _prefix + value);
}
}
public void Transform(DcmDataset dataset)
{
if (dataset.Contains(_tag))
{
string value = dataset.GetValueString(_tag);
dataset.AddElementWithValueString(_tag, value.ToLower());
}
}
public void Decode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
DcmRleCodecParameters rleParams = parameters as DcmRleCodecParameters;
if (rleParams == null)
{
rleParams = GetDefaultParameters() as DcmRleCodecParameters;
}
int pixelCount = oldPixelData.ImageWidth * oldPixelData.ImageHeight;
int numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel;
byte[] frameData = new byte[newPixelData.UncompressedFrameSize];
for (int i = 0; i < oldPixelData.NumberOfFrames; i++)
{
IList <ByteBuffer> rleData = oldPixelData.GetFrameFragments(i);
RLEDecoder decoder = new RLEDecoder(rleData);
if (decoder.NumberOfSegments != numberOfSegments)
{
throw new DicomCodecException("Unexpected number of RLE segments!");
}
for (int s = 0; s < numberOfSegments; s++)
{
int sample = s / newPixelData.BytesAllocated;
int sabyte = s % newPixelData.BytesAllocated;
int pos, offset;
if (newPixelData.PlanarConfiguration == 0)
{
pos = sample * newPixelData.BytesAllocated;
offset = newPixelData.SamplesPerPixel * newPixelData.BytesAllocated;
}
else
{
pos = sample * newPixelData.BytesAllocated * pixelCount;
offset = newPixelData.BytesAllocated;
}
if (rleParams.ReverseByteOrder)
{
pos += sabyte;
}
else
{
pos += newPixelData.BytesAllocated - sabyte - 1;
}
decoder.DecodeSegment(s, frameData, pos, offset);
}
newPixelData.AddFrame(frameData);
}
}
public bool Match(DcmDataset dataset)
{
if (dataset.Contains(_tag))
{
string value = dataset.GetValueString(_tag);
return(value.EndsWith(_value));
}
return(false);
}
public bool Match(DcmDataset dataset)
{
if (dataset.Contains(_tag))
{
string value = dataset.GetValueString(_tag).Trim();
return(String.IsNullOrEmpty(value));
}
return(true);
}
public bool Match(DcmDataset dataset)
{
if (dataset.Contains(_tag))
{
string value = dataset.GetValueString(_tag);
return(Wildcard.Match(_pattern, value));
}
return(false);
}
public bool Match(DcmDataset dataset)
{
if (dataset.Contains(_tag))
{
string value = dataset.GetValueString(_tag);
return(_regex.IsMatch(value));
}
return(false);
}
protected override void AdditionalMembers(DcmDataset dataset)
{
dataset.AddElement(DicomTags.Modality, DicomVR.CS);
dataset.AddElement(DicomTags.PatientsBirthDate, DicomVR.DA);
dataset.AddElement(DicomTags.PatientsSex, DicomVR.CS);
//dataset.AddElement(DicomTags.SpecificCharacterSet, DicomVR.CS);
dataset.AddElement(DicomTags.NumberOfStudyRelatedSeries, DicomVR.IS);
dataset.AddElement(DicomTags.NumberOfStudyRelatedInstances, DicomVR.IS);
}
public void Transform(DcmDataset dataset)
{
List <DicomTag> remove = new List <DicomTag>(dataset.GetMaskedTags(_mask));
foreach (DicomTag tag in remove)
{
dataset.Remove(tag);
}
}
public DcmPrintJob(DicomUID sopInst)
{
_sopInst = sopInst;
if (_sopInst == null || _sopInst.UID == String.Empty)
{
_sopInst = DicomUID.Generate();
}
_dataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
}
public static XDocument ToXML(DcmDataset dataset, XDicomOptions options)
{
XDocument document = new XDocument(new XDeclaration("1.0", "utf-8", "yes"));
XElement root = new XElement("dicom");
LoadSequence(root, dataset.Elements, options);
document.Add(root);
return(document);
}
public void Transform(DcmDataset dataset)
{
if (dataset.Contains(_tag))
{
string value = dataset.GetValueString(_tag);
value = Regex.Replace(value, _pattern, _replacement);
dataset.AddElementWithValueString(_tag, value);
}
}
