public DoseMatrix(DICOMObject dcm)
{
_doseObject = new DICOMSelector(dcm);
ValueSizeInBytes = _doseObject.BitsStored.Data / 8;
DoseValues = new List<double>();
this.Scaling= _doseObject.DoseGridScaling.Data;
using (var stream = _doseObject.ToDICOMObject().PixelStream)
{
var binReader = new BinaryReader(stream);
if (ValueSizeInBytes == 4)
{
while (binReader.BaseStream.Position < binReader.BaseStream.Length)
{
DoseValues.Add(Scaling * binReader.ReadInt32());
}
}
else
{
while (binReader.BaseStream.Position < binReader.BaseStream.Length)
{
DoseValues.Add(Scaling * binReader.ReadUInt16());
}
}
}
}
/// <summary>
/// Writes DICOM file out as a file of a specified path
/// </summary>
/// <param name="filePath">the path to which to write the file</param>
/// <param name="settings">the write settings</param>
/// <param name="toWrite">the object to write</param>
public static void Write(string filePath, DICOMWriteSettings settings, DICOMObject toWrite)
{
using (var fs = new FileStream(filePath, FileMode.Create))
{
Write(fs, settings, toWrite);
}
}
/// <summary>
/// Splits the DICOM object into chunks that are within the max PDU size
/// </summary>
/// <param name="dicomObject"> the DICOM objec to be split</param>
/// <param name="maxPduSize">the max length (in bytes) for a PDU</param>
/// <param name="asc">the association that the file will be sent</param>
/// <returns></returns>
public static List<byte[]> GetChunks(DICOMObject dicomObject, int maxPduSize, PresentationContext pc)
{
byte[] dicomBytes;
using (var stream = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(stream))
{
var tx = TransferSyntaxHelper.GetSyntax(pc.TransferSyntaxes.First());
DICOMObjectWriter.WriteSameSyntax(dw,
new DICOMWriteSettings
{
TransferSyntax = tx,
DoWriteIndefiniteSequences = false
}, dicomObject);
dicomBytes = stream.ToArray();
}
}
var split = new List<byte[]>();
int i = 0;
while (i < dicomBytes.Length)
{
int toTake = dicomBytes.Length >= (maxPduSize - 6) ? maxPduSize - 6 : dicomBytes.Length;
byte[] fragment = dicomBytes.Skip(i).Take(toTake).ToArray();
i += fragment.Length;
split.Add(fragment);
}
return split;
}
public PDataTF(DICOMObject dicom, bool isLastItem, bool isCommandObject, PresentationContext context)
: this()
{
byte[] data;
using (var stream = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(stream))
{
var settings = new DICOMWriteSettings();
settings.TransferSyntax = isCommandObject
? TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN
: TransferSyntaxHelper.GetSyntax(context.TransferSyntaxes[0]);
DICOMObjectWriter.Write(dw, settings, dicom);
data = stream.ToArray();
}
}
var frag = new PDVItemFragment();
frag.Data = data;
frag.IsLastItem = isLastItem;
frag.IsCommandObject = isCommandObject;
var item = new PDVItem();
item.Fragment = frag;
item.PresentationContextID = context.Id;
Items.Add(item);
}
public void Anonymize(DICOMObject d)
{
EvilLogger.Instance.Log("Anonymizing dates...");
if (dateSettings == DateSettings.KEEP_ALL_DATES)
{
return;
}
else
{
if (dateSettings == DateSettings.PRESERVE_AGE)
{
PreserveAndAnonymize(d);
}
else if (dateSettings == DateSettings.NULL_AGE)
{
NullAndAnonymize(d);
}
else if (dateSettings == DateSettings.MAKE_89)
{
Make89AndAnonymize(d);
}
else
{
Randomize(d);
}
}
}
public void Anonymize(DICOMObject d)
{
EvilLogger.Instance.Log("Clearing DICOM profile...");
foreach (var el in GenerateProfile())
{
d.Replace(el);
}
}
public AbstractDIMSERequest(DICOMObject d)
{
var sel = new DICOMSelector(d);
GroupLength = sel.CommandGroupLength.Data;
AffectedSOPClassUID = sel.AffectedSOPClassUID.Data;
MessageID = sel.MessageID.Data;
DataSetType = sel.CommandDataSetType.Data;
}
public void Anonymize(DICOMObject d)
{
EvilLogger.Instance.Log("Removing private tags...", 0);
foreach (var priv in d.AllElements.Where(e => e.Tag.IsPrivate()))
{
d.Remove(priv.Tag);
}
}
public void Anonymize(DICOMObject d)
{
EvilLogger.Instance.Log("Anonymizing names...", 0);
foreach (var name in d.FindAll(VR.PersonName))
{
name.DData = "Anonymized";
}
}
public static void WriteLittleEndian(string filePath, DICOMWriteSettings settings, DICOMObject toWrite)
{
using (DICOMBinaryWriter dw = new DICOMBinaryWriter(filePath))
{
DICOMPreambleWriter.Write(dw);
TransferSyntaxHelper.SetSyntax(toWrite, settings.TransferSyntax);
DICOMObjectWriter.WriteObjectLittleEndian(dw, settings, toWrite);
}
}
/// <summary>
/// Constructor por defecto
/// </summary>
public MyDicom()
{
minPixVal = 0;
signedImage = false;
bmp = null;
pixelData = new List<ushort>();
dcm = null;
selector = null;
}
public static int WriteGroup(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d, IDICOMElement el)
{
byte[] groupBytes = WriteGroupBytes(d, settings, el.Tag.Group);
int length = groupBytes.Length;
var ul = el as UnsignedLong;
ul.SetData((uint) length);
DICOMElementWriter.Write(dw, settings, ul);
dw.Write(groupBytes);
return d.Elements.Where(elm => elm.Tag.Group == ul.Tag.Group).ToList().Count - 1;
}
/// <summary>
/// Write DICOM file out (bytes) to a specified stream
/// </summary>
/// <param name="stream">the stream to which to write the file</param>
/// <param name="settings">the write settings</param>
/// <param name="toWrite">the object to write</param>
public static void Write(Stream stream, DICOMWriteSettings settings, DICOMObject toWrite)
{
settings = settings ?? DICOMWriteSettings.Default();
using (var dw = new DICOMBinaryWriter(stream))
{
DICOMPreambleWriter.Write(dw);
TransferSyntaxHelper.SetSyntax(toWrite, settings.TransferSyntax);
DICOMObjectWriter.Write(dw, settings, toWrite);
}
}
public CFindRequest(DICOMObject d)
{
var sel = new DICOMSelector(d);
GroupLength = sel.CommandGroupLength.Data;
AffectedSOPClassUID = sel.AffectedSOPClassUID.Data;
CommandField = (ushort)C.C_FIND_RQ;
MessageID = sel.MessageID.Data;
Priority = sel.Priority.Data;
DataSetType = sel.CommandDataSetType.Data;
}
/// <summary>
/// This method needs to be called on each DICOM object (file) to be anonymized with the set options
/// </summary>
/// <param name="dcm">the DICOM object (file) to be anonymized</param>
public void Anonymize(DICOMObject dcm)
{
int i = 1;
foreach (var anony in Queue)
{
anony.Anonymize(dcm);
RaiseProgressUpdated(CalculateProgress(i, Queue.Count + 1) / 100);
i++;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public Study(DICOMObject dicomObject)
: this()
{
_dicomObject = dicomObject;
Date = this.GetDate();
Time = this.GetTime();
Description = this.GetDescription();
InstanceUID = this.GetInstanceUID();
ID = this.GetID();
AccessionNumber = this.GetAccessionNumber();
}
public DOSELoad(string _filePath)
{
if (_filePath != "")
{
this.dcm = DICOMFileReader.Read(_filePath);
this.success = true;
}
else
{
this.success = false;
}
}
public AbstractDIMSEResponse(DICOMObject d)
{
var sel = new DICOMSelector(d);
GroupLength = sel.CommandGroupLength.Data;
if (sel.AffectedSOPClassUID != null)
{
AffectedSOPClassUID = sel.AffectedSOPClassUID.Data;
};
MessageIDBeingResponsedTo = sel.MessageIDBeingRespondedTo.Data;
DataSetType = sel.CommandDataSetType.Data;
Status = sel.Status.Data;
}
public CEchoResponse(DICOMObject d)
{
var sel = new DICOMSelector(d);
GroupLength = sel.CommandGroupLength.Data;
if (sel.AffectedSOPClassUID != null)
{
AffectedSOPClassUID = sel.AffectedSOPClassUID.Data;
};
CommandField = (ushort)C.C_ECHO_RP;
MessageIDBeingResponsedTo = sel.MessageIDBeingRespondedTo.Data;
DataSetType = sel.CommandDataSetType.Data;
Status = sel.Status.Data;
}
public void ReadUnknownFP2()
{
var dcm = new DICOMObject();
var fs = new FloatingPointSingle(new Tag("30091047"), 25.0f);
dcm.Add(fs);
dcm.Write("test.dcm", new EvilDICOM.Core.IO.Writing.DICOMWriteSettings() { TransferSyntax = EvilDICOM.Core.Enums.TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN });
TagDictionary.AddEntry<FloatingPointSingle>("30091047", "MyCustomType");
dcm = DICOMObject.Read("test.dcm");
var found = dcm.FindAll("30091047");
Assert.IsTrue(found.First() is FloatingPointSingle);
}
public void ReadUnknownFP()
{
var dcm = new DICOMObject();
var fs = new FloatingPointSingle(new Tag("30091047"), 25.0f);
dcm.Add(fs);
dcm.Write(System.IO.File.OpenWrite("test.dcm"), new EvilDICOM.Core.IO.Writing.DICOMWriteSettings() { TransferSyntax = EvilDICOM.Core.Enums.TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN });
dcm = DICOMObject.Read(System.IO.File.OpenRead("test.dcm"));
var found = dcm.GetUnknownTagAs<FloatingPointSingle>("30091047");
Assert.IsTrue(found.First() is FloatingPointSingle);
}
public void PreserveAndAnonymize(DICOMObject d)
{
List<IDICOMElement> dates = d.FindAll(VR.Date);
if (dates.Count > 0)
{
Date oldest = (Date)dates.OrderBy(da => (da as Date).Data).ToList()[0];
foreach (IDICOMElement el in dates)
{
Date da = el as Date;
System.DateTime? date = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
da.Data = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
}
}
}
public void Anonymize(DICOMObject d)
{
EvilLogger.Instance.Log("Anonymizing patient identity...", 0);
//PATIENTS NAME
var name = DICOMForge.PatientName;
name.FirstName = FirstName;
name.LastName = LastName;
d.ReplaceOrAdd(name);
//PATIENT ID
var id = DICOMForge.PatientID;
id.Data = Id;
d.ReplaceOrAdd(id);
}
public CStoreRequest(DICOMObject d)
{
var sel = new DICOMSelector(d);
GroupLength = sel.CommandGroupLength.Data;
AffectedSOPClassUID = sel.AffectedSOPClassUID.Data;
CommandField = sel.CommandField.Data;
MessageID = sel.MessageID.Data;
Priority = sel.Priority.Data;
DataSetType = sel.CommandDataSetType.Data;
AffectedSOPInstanceUID = sel.AffectedSOPInstanceUID.Data;
MoveOrigAETitle = sel.MoveOriginatorApplicationEntityTitle != null
? sel.MoveOriginatorApplicationEntityTitle.Data
: "";
MoveOrigMessageID = sel.MoveOriginatorMessageID != null ? sel.MoveOriginatorMessageID.Data : default(ushort);
}
public void AddDICOMObject(DICOMObject d)
{
List<IDICOMElement> uids = d.FindAll(VR.UniqueIdentifier).ToList();
foreach (IDICOMElement el in uids)
{
UniqueIdentifier u = el as UniqueIdentifier;
if (!IsProtectedUID(u.Tag) && u.Data != null)
{
//Add only unique ids
if (!_uidMap.ContainsKey(u.Data))
{
AddToUIDDictionary(u.Data);
}
}
}
}
public static void WriteLittleEndian(string filePath, DICOMObject toWrite)
{
DICOMWriteSettings settings = DICOMWriteSettings.Default();
IDICOMElement currentUID = toWrite.FindFirst(TagHelper.TRANSFER_SYNTAX_UID);
if (currentUID != null)
{
settings.TransferSyntax = TransferSyntaxHelper.GetSyntax(currentUID);
}
//TODO Currently don't support BigEndian writing : switch syntax to supported
if (settings.TransferSyntax == TransferSyntax.EXPLICIT_VR_BIG_ENDIAN)
{
settings.TransferSyntax = TransferSyntax.EXPLICIT_VR_LITTLE_ENDIAN;
}
Write(filePath, settings, toWrite);
}
internal CFindRequest(AbstractDIMSEIOD query, Root root, ushort priority = (ushort) Core.Enums.Priority.MEDIUM, ushort messageId = 1)
{
Query = query;
MessageID = messageId;
switch (root)
{
case Root.PATIENT:
AffectedSOPClassUID = AbstractSyntax.PATIENT_FIND;
break;
case Root.STUDY:
AffectedSOPClassUID = AbstractSyntax.STUDY_FIND;
break;
}
Priority = priority;
CommandField = (ushort)C.C_FIND_RQ;
Data = new DICOMObject(query.Elements);
}
public static void WriteObjectLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d)
{
for (int i = 0; i < d.Elements.Count; i++)
{
IDICOMElement el = d.Elements[i];
DICOMWriteSettings currentSettings = IsFileMetaGroup(el) ? settings.GetFileMetaSettings() : settings;
if (GroupWriter.IsGroupHeader(el))
{
int skip = GroupWriter.WriteGroupLittleEndian(dw, currentSettings, d, el);
i += skip;
}
else
{
DICOMElementWriter.WriteLittleEndian(dw, currentSettings, el);
}
}
}
public void AddDICOMObject(DICOMObject d)
{
IDICOMElement id = d.FindFirst(TagHelper.STUDY_ID.CompleteID);
if (id != null)
{
string studyID = (id as ShortString).Data;
DICOMFileType type = GetFileType(d);
if (!Studies.Exists(s => s.ID == studyID))
{
DICOMStudy study = new DICOMStudy();
study.ID = studyID;
study.Type = type;
Date dt = d.FindFirst(TagHelper.STUDY_DATE.CompleteID) as Date;
study.Date = dt.Data;
Studies.Add(study);
}
}
}
public CMoveRequest(CMoveIOD iod, string moveToAeTitle, Root root = Root.STUDY, Priority priority = Core.Enums.Priority.MEDIUM,
ushort messageId = 1)
{
switch (root)
{
case Root.PATIENT:
AffectedSOPClassUID = AbstractSyntax.PATIENT_MOVE;
break;
case Root.STUDY:
AffectedSOPClassUID = AbstractSyntax.STUDY_MOVE;
break;
}
CommandField = (ushort)C.C_MOVE_RQ;
Data = new DICOMObject(iod.Elements);
MoveDestination = moveToAeTitle;
Priority = (ushort)priority;
MessageID = messageId;
}
private Image <Gray, double> GrayscaleImageFromDicomObject(DICOMObject obj, double minValueIntensity, double maxValueIntensity)
{
var str = obj.PixelStream;
var height = ((UnsignedShort)obj.FindFirst(TagHelper.ROWS)).Data;
var width = ((UnsignedShort)obj.FindFirst(TagHelper.COLUMNS)).Data;
var image = new Image <Gray, double>(width, height);
var bytesPerPixel = ((UnsignedShort)obj.FindFirst(TagHelper.BITS_ALLOCATED)).Data / 8;
str.Position = 0;
var buffer = new byte[width * bytesPerPixel];
for (int y = 0; y < height; y++)
{
str.Read(buffer, 0, width * bytesPerPixel);
for (int x = 0; x < width; x++)
{
var pixel = image[x, y];
double intensity = 0;
for (int i = 1; i <= bytesPerPixel; i++)
{
intensity += buffer[x * bytesPerPixel + bytesPerPixel - i];
}
if (intensity < maxValueIntensity && intensity > minValueIntensity)
{
pixel.Intensity = intensity;
image[y, x] = pixel;
}
else
{
pixel.Intensity = 0;
image[y, x] = pixel;
}
}
}
return(image);
}
public CMoveRequest(CMoveIOD iod, string moveToAeTitle, Root root = Root.STUDY, Priority priority = Core.Enums.Priority.MEDIUM,
ushort messageId = 1)
{
switch (root)
{
case Root.PATIENT:
AffectedSOPClassUID = AbstractSyntax.PATIENT_MOVE;
break;
case Root.STUDY:
AffectedSOPClassUID = AbstractSyntax.STUDY_MOVE;
break;
}
CommandField = (ushort)C.C_MOVE_RQ;
Data = new DICOMObject(iod.Elements);
MoveDestination = moveToAeTitle;
Priority = (ushort)priority;
MessageID = messageId;
}
public void GetChunksTest()
{
//Generate a DIMSE
var dimse = CFind.CreateStudyQuery("123456");
var pContext = new PresentationContext()
{
AbstractSyntax = AbstractSyntax.STUDY_FIND,
TransferSyntaxes = new List <string>()
{
TransferSyntaxHelper.IMPLICIT_VR_LITTLE_ENDIAN
}
};
var bytes = PDataMessenger.GetChunks(dimse.Data, 16534, pContext);
var bytes1 = bytes[0];
var dcm = DICOMObject.Read(bytes1);
DICOMAssert.AreEqual(dcm, dimse.Data);
}
public void AddDICOMObject(DICOMObject d)
{
var id = d.FindFirst(TagHelper.StudyID.CompleteID);
if (id != null)
{
var studyID = (id as ShortString).Data;
var type = GetFileType(d);
if (!Studies.Exists(s => s.ID == studyID))
{
var study = new DICOMStudy();
study.ID = studyID;
study.Type = type;
var dt = d.FindFirst(TagHelper.StudyDate.CompleteID) as Date;
study.Date = dt.Data;
Studies.Add(study);
}
}
}
public void AddDICOMObject(DICOMObject d)
{
IDICOMElement id = d.FindFirst(TagHelper.STUDY_ID.CompleteID);
if (id != null)
{
string studyID = (id as ShortString).Data;
DICOMFileType type = GetFileType(d);
if (!Studies.Exists(s => s.ID == studyID))
{
DICOMStudy study = new DICOMStudy();
study.ID = studyID;
study.Type = type;
Date dt = d.FindFirst(TagHelper.STUDY_DATE.CompleteID) as Date;
study.Date = dt.Data;
Studies.Add(study);
}
}
}
public CGetRequest(CFindImageIOD iod, Root root = Root.STUDY,
Priority priority = Core.Enums.Priority.MEDIUM,
ushort messageId = 1)
{
switch (root)
{
case Root.PATIENT:
AffectedSOPClassUID = AbstractSyntax.PATIENT_GET;
break;
case Root.STUDY:
AffectedSOPClassUID = AbstractSyntax.STUDY_GET;
break;
}
CommandField = (ushort)C.C_GET_RQ;
Data = new DICOMObject(iod.Elements);
Priority = (ushort)priority;
MessageID = messageId;
}
public void Anonymize(DICOMObject d)
{
EvilLogger.Instance.Log("Remapping UIDs...");
var uids = d.FindAll(VR.UniqueIdentifier).ToList();
foreach (var el in uids)
{
var u = el as UniqueIdentifier;
string newUID;
if (u.Data != null)
{
_uidMap.TryGetValue(u.Data, out newUID);
if (newUID != null)
{
u.Data = newUID;
}
}
}
}
private void ajouttag(String nom)
{
var dcm = DICOMObject.Read(nom);
var sel = new DICOMSelector(dcm);
var refDoseRate = new DecimalString
{
Tag = TagHelper.DoseRateSet,
Data = 400
};
var nbBeams = sel.NumberOfBeams.Data;
for (int i = 0; i < nbBeams; i++)
{
sel.ControlPointSequence_[i].Items[0].Add(refDoseRate);
}
Console.WriteLine("- Ajout du tag pour l'AutoBreast");
dcm.Write(nom);
}
private void openButton_Click(object sender, EventArgs e)
{
// Show the Open File dialog. If the user clicks OK, load the
// picture that the user chose.
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
var dcm = DICOMObject.Read(openFileDialog1.FileNames[0]);
trackBar1.Enabled = true;
trackBar1.Maximum = openFileDialog1.FileNames.Length;
trackBar1.Minimum = 1;
MinSliceLabel.Text = Convert.ToString(1);
MinSliceLabel.Visible = true;
MaxSliceLabel.Text = Convert.ToString(openFileDialog1.FileNames.Length);
MaxSliceLabel.Visible = true;
double window = (double)dcm.FindFirst(TagHelper.WindowWidth).DData;
double level = (double)dcm.FindFirst(TagHelper.WindowCenter).DData;
trackBar2.Minimum = Convert.ToInt32(level - window / 2);
trackBar2.Maximum = Convert.ToInt32(level + window / 2);
trackBar2.Enabled = true;
trackBar2.Value = trackBar2.Minimum;
MinDensityLabel.Text = Convert.ToString(trackBar2.Minimum);
MinDensityLabel.Visible = true;
MaxDensityLabel.Text = Convert.ToString(trackBar2.Maximum);
MaxDensityLabel.Visible = true;
SegmentateCheckBox.Enabled = true;
ClearButton.Enabled = true;
//SaveButton.Enabled = true;
pictureBox1.Image = LoadImage(openFileDialog1.FileNames[trackBar1.Value - 1]);
}
}
public static void Write(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d, bool isSequenceItem = false)
{
for (int i = 0; i < d.Elements.Count; i++)
{
IDICOMElement el = d.Elements[i];
if (!isSequenceItem)
{
TransferSyntaxHelper.SetSyntax(d, settings.TransferSyntax);
}
DICOMWriteSettings currentSettings = IsFileMetaGroup(el) ? settings.GetFileMetaSettings() : settings;
if (GroupWriter.IsGroupHeader(el))
{
int skip = GroupWriter.WriteGroup(dw, currentSettings, d, el);
i += skip;
}
else
{
DICOMElementWriter.Write(dw, currentSettings, el);
}
}
}
public static (string Value, PreambleStatus Status) Read(string filePath, string group, string element)
{
TransferSyntax syntax = TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN;
PreambleStatus preambleStatus;
DICOMObject dicomObject = null;
using (var dicomBinaryReader = new DICOMBinaryReader(filePath))
{
preambleStatus = Read(dicomBinaryReader);
if (preambleStatus == PreambleStatus.Ok || preambleStatus == PreambleStatus.MismatchPreamble128)
{
List <IDICOMElement> metaElements = DICOMFileReader.ReadFileMetadata(dicomBinaryReader, ref syntax);
List <IDICOMElement> elements = metaElements.Concat(DICOMElementReader.ReadAllElements(dicomBinaryReader, syntax)).ToList();
dicomObject = new DICOMObject(elements);
}
}
IDICOMElement value = dicomObject?.Elements.FirstOrDefault(d => d.Tag.Group == group && d.Tag.Element == element);
return(value?.DData.ToString(), preambleStatus);
}
private DICOMObject AddMetaData(DICOMObject dcm)
{
var metadata = new FileMetadata();
byte[] b = new byte[2] {
0, 1
};
metadata.GroupLength = 166;
metadata.InfoVersion = b;
metadata.ImplementationClassUID = "1.2.246.352.70.2.1.7";
metadata.MediaStorageSOPClassUID = dcm.FindFirst(TagHelper.SOPCLASS_UID).DData.ToString();
metadata.MediaStorageSOPInstanceUID = dcm.FindFirst(TagHelper.SOPINSTANCE_UID).DData.ToString();
foreach (IDICOMElement el in metadata.Elements)
{
if (el.DData_.Count > 0)
{
dcm.Add(el);
}
}
return(dcm);
}
public static byte[] WriteGroupBytes(DICOMObject d, DICOMIOSettings settings, string groupId)
{
var groupElements = d.Elements.Where(el => el.Tag.Group == groupId).ToList();
byte[] groupBytes;
using (var stream = new MemoryStream())
{
using (var groupDW = new DICOMBinaryWriter(stream))
{
foreach (var el in groupElements)
{
if (!IsGroupHeader(el))
{
DICOMElementWriter.Write(groupDW, settings, el);
}
}
}
groupBytes = stream.ToArray();
}
return(groupBytes);
}
private static byte[] WriteGroupBytesLittleEndian(DICOMObject d, DICOMWriteSettings settings, string groupID)
{
List <IDICOMElement> groupElements = d.Elements.Where(el => el.Tag.Group == groupID).ToList();
byte[] groupBytes;
using (MemoryStream stream = new MemoryStream())
{
using (DICOMBinaryWriter groupDW = new DICOMBinaryWriter(stream))
{
foreach (IDICOMElement el in groupElements)
{
if (!IsGroupHeader(el))
{
DICOMElementWriter.WriteLittleEndian(groupDW, settings, el);
}
}
}
groupBytes = stream.ToArray();
}
return(groupBytes);
}
public DICOMObject Clone(DICOMObject dcm) //copy and alter from EvilDICOM original code, clone a DICOMObject
{
List <IDICOMElement> copy = new List <IDICOMElement>();
foreach (var el in dcm.Elements)
{
using (var ms = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(ms))
{
DICOMElementWriter.Write(dw, DICOMIOSettings.Default(), el);
}
using (var dr = new DICOMBinaryReader(ms.ToArray()))
{
copy.Add(DICOMElementReader.ReadElementImplicitLittleEndian(dr));
}
}
}
return(new DICOMObject(copy));
}
public static List <float> ReadVoxels(DICOMObject dcm)
{
var sel = dcm.GetSelector();
var rows = sel.Rows.Data;
var cols = sel.Columns.Data;
var bitsAllocated = sel.BitsAllocated.Data;
var bitsStored = sel.BitsStored.Data;
var bytesAllocated = bitsAllocated / 8;
var voxels = new List <float>();
Func <byte[], float> valueConverter = null;
switch (bytesAllocated)
{
case 1: valueConverter = (bytes) => (int)bytes[0]; break;
case 2: valueConverter = (bytes) => BitConverter.ToInt16(bytes, 0); break;
case 4: valueConverter = (bytes) => BitConverter.ToInt32(bytes, 0); break;
case 8: valueConverter = (bytes) => BitConverter.ToInt64(bytes, 0); break;
}
var m = (float)sel.RescaleSlope.Data; //Slope
var b = (float)sel.RescaleIntercept.Data; //Intercept
using (BinaryReader br = new BinaryReader(dcm.GetPixelStream()))
{
var bytes = new byte[bytesAllocated];
while (br.Read(bytes, 0, bytesAllocated) != 0)
{
var val = m * valueConverter(bytes) + b;
voxels.Add(val);
}
}
return(voxels);
}
public void CanAddMultipleStringsTest()
{
var dcm = new DICOMObject();
dcm.ReplaceOrAdd(DICOMForge.ImageType("Type1", "Type2", "Type3"));
//Memory test
var expected = 3;
var data = dcm.GetSelector().ImageType.Data_;
var actual = data.Count;
Assert.AreEqual(expected, actual);
Assert.AreEqual("Type1", data[0]);
Assert.AreEqual("Type2", data[1]);
Assert.AreEqual("Type3", data[2]);
var bytes = new byte[0];
//Test IO
using (var ms = new MemoryStream())
{
//WRITE
using (var bw = new DICOMBinaryWriter(ms))
{
DICOMObjectWriter.Write(bw, DICOMIOSettings.Default(), dcm);
}
bytes = ms.ToArray();
}
//READ
var dcmRead = DICOMObject.Read(bytes);
expected = 3;
data = dcmRead.GetSelector().ImageType.Data_;
actual = data.Count;
Assert.AreEqual(expected, actual);
Assert.AreEqual("Type1", data[0]);
Assert.AreEqual("Type2", data[1]);
Assert.AreEqual("Type3", data[2]);
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
using (OpenFileDialog dialog = new OpenFileDialog())
{
if (dialog.ShowDialog() == DialogResult.OK)
{
try
{
this.filePlan = dialog.FileName;
this.plan = DICOMObject.Read(this.filePlan);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString() + "\nOpen DICOM file error.");
}
this.Text = "Repainting Utility - " + Path.GetFileName(this.filePlan);
toolStripStatusLabel1.Text = Path.GetFileName(this.filePlan) + " is Loaded.";
loadRTplan(plan);
planOpened = true;
}
}
}
protected static void FillMetadata(Matrix mat, DICOMObject dcm)
{
var sel = dcm.GetSelector();
mat.XRes = sel.PixelSpacing.Data_[0];
mat.YRes = sel.PixelSpacing.Data_[1];
var _origin = sel.ImagePositionPatient.Data_;
mat.Origin = new Vector3(_origin[0], _origin[1], _origin[2]);
mat.DimensionX = sel.Columns.Data;
mat.DimensionY = sel.Rows.Data;
var bitsAllocated = sel.BitsAllocated.Data;
var bitsStored = sel.BitsStored.Data;
mat.BytesAllocated = bitsAllocated / 8;
var orient = sel.ImageOrientationPatient.Data_;
var xDir = new Vector3(orient[0], orient[1], orient[2]);
var yDir = new Vector3(orient[3], orient[4], orient[5]);
var zDir = xDir.CrossMultiply(yDir);
mat.ImageOrientation = (xDir, yDir, zDir);
}
public void NullAndAnonymize(DICOMObject d)
{
var dob = d.FindFirst(TagHelper.PatientBirthDate) as Date;
dob.Data = null;
var dates = d.FindAll(VR.Date);
if (dates.Count > 0)
{
var oldest = (Date)dates
.Where(da => (da as Date).Data != null)
.OrderBy(da => (da as Date).Data)
.ToList()[0];
foreach (var el in dates)
{
var da = el as Date;
var date = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
da.Data = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
}
}
}
public void NullAndAnonymize(DICOMObject d)
{
Date dob = d.FindFirst(TagHelper.PATIENT_BIRTH_DATE) as Date;
dob.Data = null;
List <IDICOMElement> dates = d.FindAll(VR.Date);
if (dates.Count > 0)
{
Date oldest = (Date)dates
.Where(da => (da as Date).Data != null)
.OrderBy(da => (da as Date).Data)
.ToList()[0];
foreach (IDICOMElement el in dates)
{
Date da = el as Date;
System.DateTime?date = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
da.Data = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
}
}
}
public int GetTotalNumberOfChannelsInPlan(DICOMObject plan)
{
try
{
var patientSelector = new DICOMSelector(plan);
var channelSeq = patientSelector.ChannelSequence;
if (channelSeq != null)
{
var numberOfChannels = channelSeq.Items.Count;
return(numberOfChannels);
}
else
{
return(0);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private static AbstractDIMSE ProcessCommand(List <PDataTF> pDatas, Association asc)
{
DICOMObject dcm = GetCommandObject(pDatas);
AbstractDIMSE dimse;
bool success = DIMSEReader.TryReadDIMSE(dcm, out dimse);
if (!success)
{
asc.Logger.Log("DIMSE could not be read!");
}
if (dimse.HasData)
{
NetworkBinaryReader dr = asc.Reader;
List <PDataTF> dataPds = ReadPDataTFs(dr);
int id;
var txSyntax = GetTransferSyntax(asc, dataPds, out id);
dimse.DataPresentationContextId = id;
dimse.Data = GetDataObject(dataPds, txSyntax);
}
DIMSEProcessor.Process(dimse, asc);
return(dimse);
}
public void Make89AndAnonymize(DICOMObject d)
{
Date dob = d.FindFirst(TagHelper.PATIENT_BIRTH_DATE) as Date;
List <IDICOMElement> dates = d.FindAll(VR.Date);
if (dates.Count > 0)
{
Date oldest = (Date)dates
.Where(da => (da as Date).Data != null && da.Tag.CompleteID != TagHelper.PATIENT_BIRTH_DATE.CompleteID)
.OrderBy(da => (da as Date).Data)
.ToList()[0];
System.DateTime oldestDate = (System.DateTime)oldest.Data;
dob.Data = new System.DateTime(oldestDate.Year - 89, oldestDate.Month, oldestDate.Day);
oldest = dob;
foreach (IDICOMElement el in dates)
{
Date da = el as Date;
System.DateTime?date = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
da.Data = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
}
}
}
public static List <CompilationUnitSyntax> BuildFromFile(string filePath, string className)
{
//This object plus all descendant sequence objects
List <CompilationUnitSyntax> allNodes = new List <CompilationUnitSyntax>();
var dcm = DICOMObject.Read(filePath);
var(props, descNodes) = GetProperties(dcm);
allNodes.AddRange(descNodes);
var syntaxFactory = SyntaxFactory.CompilationUnit();
syntaxFactory = syntaxFactory.AddUsings(
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System")),
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("EvilDICOM.Core.Wrapping")),
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("EvilDICOM.Core")),
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Collections.Generic")),
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Linq")));
var @namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName("EvilDICOM.IOD")).NormalizeWhitespace();
var node = SyntaxFactory.ClassDeclaration(className);
node = node.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
node = node.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("DICOMObjectWrapper")));
var constructor = SyntaxFactory.ConstructorDeclaration(className).WithBody(
SyntaxFactory.Block(
SyntaxFactory.ParseStatement("DCM = new DICOMObject();")));
constructor = constructor.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
props.Insert(0, constructor);
node = node.AddMembers(props.ToArray());
@namespace = @namespace.AddMembers(node);
syntaxFactory = syntaxFactory.AddMembers(@namespace);
allNodes.Add(syntaxFactory);
return(allNodes);
}
public PlanFile(string fileName)
{
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
FieldNumberToNameList = new List <Tuple <string, string, string> >();
FileName = fileName;
ShortFileName = FileName.Substring(FileName.LastIndexOf(@"\"));
DICOMObject dcm1 = DICOMObject.Read(fileName);
SopInstanceId = dcm1.FindFirst(TagHelper.SOPInstanceUID).DData.ToString();
PatientID = dcm1.FindFirst(TagHelper.PatientID).DData.ToString();
if ((dcm1.FindFirst(TagHelper.Modality).ToString() ?? "").Contains("RTPLAN"))
{
IsPlanFile = true;
PlanID = dcm1.FindFirst(TagHelper.RTPlanLabel).DData.ToString();
List <EvilDICOM.Core.Interfaces.IDICOMElement> beamNumbers = dcm1.FindAll(TagHelper.BeamNumber);
List <EvilDICOM.Core.Interfaces.IDICOMElement> beamNames = dcm1.FindAll(TagHelper.BeamName);
List <EvilDICOM.Core.Interfaces.IDICOMElement> beamMUs = dcm1.FindAll(TagHelper.BeamMeterset);
if (beamNames.Count == beamNumbers.Count && beamNames.Count == beamMUs.Count)
{
for (int i = 0; i < beamNames.Count; i++)
{
try
{
var temp = new Tuple <string, string, string>(beamNumbers[i].DData.ToString(), beamNames[i].DData.ToString(), beamMUs[i].DData.ToString());
FieldNumberToNameList.Add(temp);
}
catch (ArgumentOutOfRangeException)
{
break;
}
}
}
}
}
public void WriteUnknownTest()
{
var dcm = new DICOMObject();
dcm.Add(new LongString(new Tag("32751000"), "Online3D"));
var dcmBytes = new byte[0]; //Start empty
using (var ms = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(ms))
{
//Explicity
DICOMObjectWriter.Write(dw, DICOMIOSettings.DefaultExplicit(), dcm);
}
dcmBytes = ms.ToArray(); //Store to read back
}
var dcmBack = DICOMObject.Read(dcmBytes);
//This passes
Assert.IsTrue(dcmBack.FindFirst("32751000").VR == EvilDICOM.Core.Enums.VR.LongString);
using (var ms = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(ms))
{
//Implicit
DICOMObjectWriter.Write(dw, DICOMIOSettings.Default(), dcm);
}
dcmBytes = ms.ToArray(); //Store to read back
}
dcmBack = DICOMObject.Read(dcmBytes);
//This fails
Assert.IsFalse(dcmBack.FindFirst("32751000").VR == EvilDICOM.Core.Enums.VR.LongString);
}
public CMoveResponse(DICOMObject d)
: base(d)
{
var sel = new DICOMSelector(d);
GroupLength = sel.CommandGroupLength.Data;
AffectedSOPClassUID = sel.AffectedSOPClassUID.Data;
CommandField = (ushort)C.C_MOVE_RP;
MessageIDBeingRespondedTo = sel.MessageIDBeingRespondedTo.Data;
DataSetType = sel.CommandDataSetType.Data;
NumberOfFailedOps = sel.NumberOfFailedSuboperations != null
? sel.NumberOfFailedSuboperations.Data
: (ushort)0;
NumberOfRemainingOps = sel.NumberOfRemainingSuboperations != null
? sel.NumberOfRemainingSuboperations.Data
: (ushort)0;
NumberOfCompletedOps = sel.NumberOfCompletedSuboperations != null
? sel.NumberOfCompletedSuboperations.Data
: (ushort)0;
NumberOfWarningOps = sel.NumberOfWarningSuboperations != null
? sel.NumberOfWarningSuboperations.Data
: (ushort)0;
Status = sel.Status.Data;
}
private void vidangeligne(String nom)
{
var dcm = DICOMObject.Read(nom);
var sel = new DICOMSelector(dcm);
try
{
var Vertical = sel.TableTopVerticalPosition_;
var Longitudinal = sel.TableTopLongitudinalPosition_;
var Lateral = sel.TableTopLateralPosition_;
for (int i = 0; i < Vertical.Count; i++)
{
sel.TableTopVerticalPosition_[i].Data_.Clear();
}
for (int j = 0; j < Longitudinal.Count; j++)
{
sel.TableTopLongitudinalPosition_[j].Data_.Clear();
}
for (int k = 0; k < Lateral.Count; k++)
{
sel.TableTopLateralPosition_[k].Data_.Clear();
}
Console.WriteLine("- Les lignes 'Table TopVertical Position', 'Table Top Longitudinal Position' et 'TableTopLateralPosition' sont vide.");
}
catch (NullReferenceException)
{
MessageBox.Show("Impossible de vider les lignes pour le fichier " + nom, "Erreur", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
status.ForeColor = System.Drawing.Color.Red;
status.Text = "Modification interrompu ";
test = false;
}
dcm.Write(nom);
}
public void Make89AndAnonymize(DICOMObject d)
{
var dob = d.FindFirst(TagHelper.PatientBirthDate) as Date;
var dates = d.FindAll(VR.Date);
if (dates.Count > 0)
{
var oldest = (Date)dates
.Where(da => (da as Date).Data != null &&
da.Tag.CompleteID != TagHelper.PatientBirthDate.CompleteID)
.OrderBy(da => (da as Date).Data)
.ToList()[0];
var oldestDate = (System.DateTime)oldest.Data;
dob.Data = new System.DateTime(oldestDate.Year - 89, oldestDate.Month, oldestDate.Day);
oldest = dob;
foreach (var el in dates)
{
var da = el as Date;
var date = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
da.Data = DateHelper.DateRelativeBaseDate(da.Data, oldest.Data);
}
}
}
