public static DRR ParseDICOM(string dcmFile)
{
var drr = new DRR();
var dcm = DICOMObject.Read(dcmFile);
if (!dcm.IsDRR())
{
throw new Exception("DICOM object not DRR");
}
var sel = dcm.GetSelector();
//READ VOXELS TO MAT
var pixels = SliceReader.ReadVoxels(dcm);
var window = sel.WindowWidth.Data;
var level = sel.WindowCenter.Data;
using (var im = new Mat((int)sel.Rows.Data, (int)sel.Columns.Data, MatType.CV_32FC1, pixels.ToArray()))
{
drr.Image = im.WindowAndLevel(level, window).CvtColor(ColorConversionCodes.GRAY2BGR);
}
var orient = PatientPosition.FromAbbreviation(sel.PatientPosition.Data);
FieldRenderer.Render(sel, drr);
//DRAW ISO
var iso = sel.IsocenterPosition?.Data_;
if (iso != null)
{
var identity = MatMaker.Identity(4, 4);
var iso3d = iso.ToPoint3f();
var gantryAngle = sel.GantryAngle.Data;
var collAngle = sel.BeamLimitingDeviceAngle.Data;
var tableAngle = sel.PatientSupportAngle.Data;
var dcm2IEC = Transform.DICOM2IEC(orient.Orientation);
var tx = Transform.GantryTransform(gantryAngle);
// iso3d = Transform.IECToDICOM(orient.Orientation).TransformPoint3f(isoDICOM_BEVCoord);
var sid = sel.RTImageSID.Data;
var mag = 1.0f;// (float)(sid / (sid - isoDICOM_BEVCoord.Z));
var origin = new Point2f((float)sel.RTImagePosition.Data_[0], (float)sel.RTImagePosition.Data_[0]);
var spacing = sel.ImagePlanePixelSpacing.Data_;
// var isoDICOM_BEV = Transform.IECToDICOM(orient.Orientation).TransformPoint3f(isoIEC_BEV);
GraticuleRenderer.Render(drr.Image, collAngle, spacing[0]);
//drr.Image.Line(iso2D, pt2,
// new Scalar(255, 255, 0), 1, LineTypes.Link8);
drr.Label = sel.RTImageLabel?.Data;
}
return(drr);
}
public static T1 DecodeKey <T1>([NotNull] this IKeyEncoder <T1> decoder, Slice encoded)
{
var reader = new SliceReader(encoded);
decoder.ReadKeyFrom(ref reader, out T1 item);
//TODO: should we fail if extra bytes?
return(item);
}
public void ReadKeyFrom(ref SliceReader reader, out TKey value)
{
if (this.Unpack is Func <Slice, TKey> f)
{
value = f(reader.ReadToEnd());
return;
}
throw new InvalidOperationException();
}
public override T DecodeOrderedSelfTerm(ref SliceReader input)
{
//HACKHACK: we lose the current depth!
var reader = new TupleReader(input);
bool res = TuPack.DecodeNext <T>(ref reader, out T value);
input = reader.Input;
return(res ? value : m_missingValue);
}
public override T DecodeOrderedSelfTerm(ref SliceReader input)
{
T value;
if (!FdbTuple.UnpackNext <T>(ref input, out value))
{
return(m_missingValue);
}
return(value);
}
public override void ReadKeyPartsFrom(ref SliceReader reader, int count, out (T1, T2) items)
{
Contract.Requires(count > 0);
items.Item1 = count >= 1 ? m_codec1.DecodeOrderedSelfTerm(ref reader) : default;
items.Item2 = count >= 2 ? m_codec2.DecodeOrderedSelfTerm(ref reader) : default;
if (reader.HasMore)
{
throw new InvalidOperationException($"Unexpected data at the end of composite key after {count} items");
}
}
public bool TryReadKeyFrom(ref SliceReader reader, out TKey value)
{
if (this.Unpack is Func <Slice, TKey> f)
{
try
{
value = f(reader.ReadToEnd());
return(true);
}
catch (FormatException)
{
value = default !;
TDocument IUnorderedTypeCodec <TDocument> .DecodeUnorderedSelfTerm(ref SliceReader input)
{
uint size = input.ReadVarInt32();
if (size > int.MaxValue)
{
throw new FormatException("Malformed data size");
}
var packed = input.ReadBytes((int)size);
return(DecodeValue(packed));
}
internal CompressedBitmapWordIterator(Slice buffer)
{
Contract.Requires((buffer.Count & 3) == 0 && (buffer.Count == 0 || buffer.Count >= 8));
if (buffer.Count == 0)
{
m_reader = new SliceReader();
}
else
{ // skip the header
m_reader = new SliceReader(buffer.Substring(4));
}
m_current = 0;
}
/// <summary>Outputs a debug version of a compressed segment</summary>
public static StringBuilder DumpCompressed(Slice compressed, StringBuilder?output = null)
{
if (output == null)
{
output = new StringBuilder();
}
if (compressed.Count == 0)
{
output.Append("Empty bitmap [0 bytes]");
return(output);
}
var reader = new SliceReader(compressed);
output.Append($"Compressed [{compressed.Count} bytes]:");
uint header = reader.ReadFixed32();
int highestBit = (int)header;
output.Append($" {(compressed.Count >> 2) - 1} words");
uint p = 0;
int i = 0;
while (reader.Remaining >= 4)
{
uint word = reader.ReadFixed32();
if ((word & TYPE_MASK) == BIT_TYPE_LITERAL)
{
output.AppendFormat(", ({0}:{1}) 0x{2:X8}", i, p, word);
p += 31;
}
else
{
uint len = (word & LENGTH_MASK) + 1;
output.AppendFormat(", ({0}:{1}) {2} x {3}", i, p, ((word & FILL_MASK) >> FILL_SHIFT) == 0 ? "zero" : "one", len);
p += len * 31;
}
i++;
}
output.Append(", MSB ").Append(highestBit);
if (reader.Remaining > 0)
{
output.AppendLine($", ERROR: {reader.Remaining} trailing byte(s)");
}
return(output);
}
public static ImageMatrix ParseDICOM(IEnumerable <string> dcmFiles)
{
try
{
var matrix = new ImageMatrix();
var fileImageNumbers = new List <(string fileName, int imageSlice, double z)>();
foreach (var file in dcmFiles)
{
var dcm = DICOMObject.Read(file);
var sel = dcm.GetSelector();
var seriesUID = sel.SeriesInstanceUID.Data;
var num = sel.InstanceNumber.Data;
var z = dcm.GetSelector().ImagePositionPatient.Data_[2];
fileImageNumbers.Add((file, num, z));
}
var ordered = fileImageNumbers.OrderBy(f => f.z);
matrix.DimensionZ = ordered.Count();
var values = new List <float>();
//Load Values
foreach (var o in ordered)
{
var dcm = DICOMObject.Read(o.fileName);
var minSliceNum = ordered.Min(or => or.imageSlice);
if (o.imageSlice == minSliceNum)
{
FillMetadata(matrix, dcm);
matrix.ZRes = dcm.GetSelector().SliceThickness.Data;
}
var voxels = SliceReader.ReadVoxels(o.fileName);
values.AddRange(voxels);
}
//Set origin to minimum Z
matrix.Origin = new Vector3(matrix.Origin.X, matrix.Origin.Y, ordered.First().z);
matrix.CreateMatrix(values.ToArray());
return(matrix);
}
catch (Exception e)
{
return(null);
}
}
public TupleReader(Slice buffer)
{
this.Input = new SliceReader(buffer);
this.Depth = 0;
}
public void Dispose()
{
m_reader = default(SliceReader);
m_current = 0;
}
public void ReadKeyFrom(ref SliceReader reader, out T value)
{
value = m_decoder(reader.ReadToEnd());
}
public virtual T DecodeUnordered(Slice input)
{
var reader = new SliceReader(input);
return(DecodeUnorderedSelfTerm(ref reader));
}
public virtual T DecodeUnorderedSelfTerm(ref SliceReader input)
{
return(DecodeOrderedSelfTerm(ref input));
}
public virtual T DecodeOrdered(Slice input)
{
var slicer = new SliceReader(input);
return DecodeOrderedSelfTerm(ref slicer);
}
public void Test_Incomplete_VersionStamp()
{
{ // 80-bits (no user version)
var vs = VersionStamp.Incomplete();
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(ulong.MaxValue));
Assert.That(vs.TransactionOrder, Is.EqualTo(ushort.MaxValue));
Assert.That(vs.IsIncomplete, Is.True);
Assert.That(vs.HasUserVersion, Is.False, "80-bits VersionStamps don't have a user version");
Assert.That(vs.UserVersion, Is.Zero, "80-bits VersionStamps don't have a user version");
Assert.That(vs.GetLength(), Is.EqualTo(10));
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("FF FF FF FF FF FF FF FF FF FF"));
Assert.That(vs.ToString(), Is.EqualTo("@?"));
}
{ // 96-bits, default user version
var vs = VersionStamp.Incomplete(0);
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(ulong.MaxValue));
Assert.That(vs.TransactionOrder, Is.EqualTo(ushort.MaxValue));
Assert.That(vs.IsIncomplete, Is.True);
Assert.That(vs.HasUserVersion, Is.True, "96-bits VersionStamps have a user version");
Assert.That(vs.UserVersion, Is.EqualTo(0));
Assert.That(vs.GetLength(), Is.EqualTo(12));
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("FF FF FF FF FF FF FF FF FF FF 00 00"));
Assert.That(vs.ToString(), Is.EqualTo("@?#0"));
}
{ // 96 bits, custom user version
var vs = VersionStamp.Incomplete(123);
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(ulong.MaxValue));
Assert.That(vs.TransactionOrder, Is.EqualTo(ushort.MaxValue));
Assert.That(vs.HasUserVersion, Is.True);
Assert.That(vs.UserVersion, Is.EqualTo(123));
Assert.That(vs.IsIncomplete, Is.True);
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("FF FF FF FF FF FF FF FF FF FF 00 7B"));
Assert.That(vs.ToString(), Is.EqualTo("@?#123"));
}
{ // 96 bits, large user version
var vs = VersionStamp.Incomplete(12345);
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(ulong.MaxValue));
Assert.That(vs.TransactionOrder, Is.EqualTo(ushort.MaxValue));
Assert.That(vs.HasUserVersion, Is.True);
Assert.That(vs.UserVersion, Is.EqualTo(12345));
Assert.That(vs.IsIncomplete, Is.True);
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("FF FF FF FF FF FF FF FF FF FF 30 39"));
Assert.That(vs.ToString(), Is.EqualTo("@?#12345"));
}
Assert.That(() => VersionStamp.Incomplete(-1), Throws.ArgumentException, "User version cannot be negative");
Assert.That(() => VersionStamp.Incomplete(65536), Throws.ArgumentException, "User version cannot be larger than 0xFFFF");
{
var writer = default(SliceWriter);
writer.WriteFixed24BE(0xAAAAAA);
VersionStamp.Incomplete(123).WriteTo(ref writer);
writer.WriteFixed24BE(0xAAAAAA);
Assert.That(writer.ToSlice().ToHexaString(' '), Is.EqualTo("AA AA AA FF FF FF FF FF FF FF FF FF FF 00 7B AA AA AA"));
var reader = new SliceReader(writer.ToSlice());
reader.Skip(3);
var vs = VersionStamp.Parse(reader.ReadBytes(12));
Assert.That(reader.Remaining, Is.EqualTo(3));
Assert.That(vs.TransactionVersion, Is.EqualTo(ulong.MaxValue));
Assert.That(vs.TransactionOrder, Is.EqualTo(ushort.MaxValue));
Assert.That(vs.UserVersion, Is.EqualTo(123));
Assert.That(vs.IsIncomplete, Is.True);
}
{
var buf = MutableSlice.Repeat(0xAA, 18);
VersionStamp.Incomplete(123).WriteTo(buf.Substring(3, 12));
Assert.That(buf.ToHexaString(' '), Is.EqualTo("AA AA AA FF FF FF FF FF FF FF FF FF FF 00 7B AA AA AA"));
}
}
public void Test_Complete_VersionStamp()
{
{ // 80-bits, no user version
var vs = VersionStamp.Complete(0x0123456789ABCDEFUL, 123);
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(0x0123456789ABCDEFUL));
Assert.That(vs.TransactionOrder, Is.EqualTo(123));
Assert.That(vs.HasUserVersion, Is.False);
Assert.That(vs.UserVersion, Is.Zero);
Assert.That(vs.IsIncomplete, Is.False);
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("01 23 45 67 89 AB CD EF 00 7B"));
Assert.That(vs.ToString(), Is.EqualTo("@81985529216486895-123"));
}
{ // 96 bits, default user version
var vs = VersionStamp.Complete(0x0123456789ABCDEFUL, 123, 0);
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(0x0123456789ABCDEFUL));
Assert.That(vs.TransactionOrder, Is.EqualTo(123));
Assert.That(vs.HasUserVersion, Is.True);
Assert.That(vs.UserVersion, Is.Zero);
Assert.That(vs.IsIncomplete, Is.False);
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("01 23 45 67 89 AB CD EF 00 7B 00 00"));
Assert.That(vs.ToString(), Is.EqualTo("@81985529216486895-123#0"));
}
{ // custom user version
var vs = VersionStamp.Complete(0x0123456789ABCDEFUL, 123, 456);
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(0x0123456789ABCDEFUL));
Assert.That(vs.TransactionOrder, Is.EqualTo(123));
Assert.That(vs.HasUserVersion, Is.True);
Assert.That(vs.UserVersion, Is.EqualTo(456));
Assert.That(vs.IsIncomplete, Is.False);
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("01 23 45 67 89 AB CD EF 00 7B 01 C8"));
Assert.That(vs.ToString(), Is.EqualTo("@81985529216486895-123#456"));
}
{ // two bytes user version
var vs = VersionStamp.Complete(0x0123456789ABCDEFUL, 12345, 6789);
Dump(vs);
Assert.That(vs.TransactionVersion, Is.EqualTo(0x0123456789ABCDEFUL));
Assert.That(vs.TransactionOrder, Is.EqualTo(12345));
Assert.That(vs.UserVersion, Is.EqualTo(6789));
Assert.That(vs.IsIncomplete, Is.False);
Assert.That(vs.ToSlice().ToHexaString(' '), Is.EqualTo("01 23 45 67 89 AB CD EF 30 39 1A 85"));
Assert.That(vs.ToString(), Is.EqualTo("@81985529216486895-12345#6789"));
}
Assert.That(() => VersionStamp.Complete(0x0123456789ABCDEFUL, 0, -1), Throws.ArgumentException, "User version cannot be negative");
Assert.That(() => VersionStamp.Complete(0x0123456789ABCDEFUL, 0, 65536), Throws.ArgumentException, "User version cannot be larger than 0xFFFF");
{
var writer = default(SliceWriter);
writer.WriteFixed24BE(0xAAAAAA);
VersionStamp.Complete(0x0123456789ABCDEFUL, 123, 456).WriteTo(ref writer);
writer.WriteFixed24BE(0xAAAAAA);
Assert.That(writer.ToSlice().ToHexaString(' '), Is.EqualTo("AA AA AA 01 23 45 67 89 AB CD EF 00 7B 01 C8 AA AA AA"));
var reader = new SliceReader(writer.ToSlice());
reader.Skip(3);
var vs = VersionStamp.Parse(reader.ReadBytes(12));
Assert.That(reader.Remaining, Is.EqualTo(3));
Assert.That(vs.TransactionVersion, Is.EqualTo(0x0123456789ABCDEFUL));
Assert.That(vs.TransactionOrder, Is.EqualTo(123));
Assert.That(vs.UserVersion, Is.EqualTo(456));
Assert.That(vs.IsIncomplete, Is.False);
}
{
var buf = MutableSlice.Repeat(0xAA, 18);
VersionStamp.Complete(0x0123456789ABCDEFUL, 123, 456).WriteTo(buf.Substring(3, 12));
Assert.That(buf.ToHexaString(' '), Is.EqualTo("AA AA AA 01 23 45 67 89 AB CD EF 00 7B 01 C8 AA AA AA"));
}
}
public void ReadKeyFrom(ref SliceReader reader, out Slice value)
{
value = reader.ReadToEnd();
}
/// <summary>Decode the next token from a packed tuple</summary>
/// <param name="reader">Parser from wich to read the next token</param>
/// <returns>Token decoded, or Slice.Nil if there was no more data in the buffer</returns>
public static Slice ParseNext(ref SliceReader reader)
{
int type = reader.PeekByte();
switch (type)
{
case -1:
{ // End of Stream
return(Slice.Nil);
}
case FdbTupleTypes.Nil:
{ // <00> => null
reader.Skip(1);
return(Slice.Empty);
}
case FdbTupleTypes.Bytes:
{ // <01>(bytes)<00>
return(reader.ReadByteString());
}
case FdbTupleTypes.Utf8:
{ // <02>(utf8 bytes)<00>
return(reader.ReadByteString());
}
case FdbTupleTypes.Single:
{ // <20>(4 bytes)
return(reader.ReadBytes(5));
}
case FdbTupleTypes.Double:
{ // <21>(8 bytes)
return(reader.ReadBytes(9));
}
case FdbTupleTypes.Uuid128:
{ // <30>(16 bytes)
return(reader.ReadBytes(17));
}
case FdbTupleTypes.Uuid64:
{ // <31>(8 bytes)
return(reader.ReadBytes(9));
}
case FdbTupleTypes.AliasDirectory:
case FdbTupleTypes.AliasSystem:
{ // <FE> or <FF>
return(reader.ReadBytes(1));
}
}
if (type <= FdbTupleTypes.IntPos8 && type >= FdbTupleTypes.IntNeg8)
{
int bytes = type - FdbTupleTypes.IntZero;
if (bytes < 0)
{
bytes = -bytes;
}
return(reader.ReadBytes(1 + bytes));
}
throw new FormatException(String.Format("Invalid tuple type byte {0} at index {1}/{2}", type, reader.Position, reader.Buffer.Count));
}
public void ReadKeyFrom(ref SliceReader reader, out T key)
{
key = m_codec.DecodeOrdered(reader.ReadToEnd());
}
public TupleReader(SliceReader input)
{
this.Input = input;
this.Depth = 0;
}
public TupleReader(Slice buffer, int depth)
{
this.Input = new SliceReader(buffer);
this.Depth = depth;
}
public abstract T DecodeOrderedSelfTerm(ref SliceReader input);