public DICOMWriteSettings ToDICOMWriteSettings()
{
var settings = DICOMWriteSettings.Default();
settings.TransferSyntax = TransferSyntaxHelper.GetSyntax(TransferSyntaxes.FirstOrDefault());
return(settings);
}
public void WriteMultipleFl()
{
var vssd = DICOMForge.VirtualSourceAxisDistances();
vssd.Data_ = new System.Collections.Generic.List <float>()
{
2538.4199f, 2541.00f
};
byte[] elBytes = null;
using (var stream = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(stream))
{
DICOMElementWriter.Write(dw, DICOMWriteSettings.DefaultExplicit(), vssd);
elBytes = stream.ToArray();
}
}
AbstractElement <float> readVssd = null;
using (var dr = new DICOMBinaryReader(elBytes))
{
readVssd = DICOMElementReader.ReadElementExplicitLittleEndian(dr) as AbstractElement <float>;
}
Assert.AreEqual(readVssd.Data_.Count, 2);
Assert.AreEqual(readVssd.Data_[0], 2538.4199f);
Assert.AreEqual(readVssd.Data_[1], 2541.00f);
}
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 WriteBigEndianLength3()
{
var len = 10;
byte[] bytes;
using (var ms = new MemoryStream())
{
var dw = new DICOMBinaryWriter(ms);
VR vr = VR.CodeString;
DICOMWriteSettings settings = new DICOMWriteSettings()
{
TransferSyntax = TransferSyntax.EXPLICIT_VR_BIG_ENDIAN, DoWriteIndefiniteSequences = false
};
var data = new byte[10];
LengthWriter.Write(dw, vr, settings, data != null ? data.Length : 0);
bytes = ms.ToArray();
}
var read = LengthReader.ReadLittleEndian(bytes);
Assert.AreNotEqual(len, read);
read = LengthReader.ReadBigEndian(bytes);
Assert.AreEqual(len, read);
}
public byte[] GetBytes(DICOMWriteSettings settings = null)
{
settings = settings ?? DICOMWriteSettings.Default();
using (var stream = new MemoryStream())
{
DICOMFileWriter.Write(stream, settings, this);
return(stream.ToArray());
}
}
/// <summary>
/// Writes DICOM object to a file
/// </summary>
/// <param name="file">the path to write</param>
/// <param name="settings">the DICOM settings to write (endianness, and indefinite sequences)</param>
public void Write(string file, DICOMWriteSettings settings = null)
{
settings = settings ?? DICOMWriteSettings.Default();
//If image is compressed, lets not change the transfer syntax UID (so image will not be read incorrectly)
var setSyntax = GetSelector().TransferSyntaxUID?.Data;
if (setSyntax != null && TransferSyntaxHelper.IsCompressedImage(setSyntax))
{
settings.TransferSyntax = TransferSyntaxHelper.GetSyntax(setSyntax);
}
DICOMFileWriter.Write(file, settings, this);
}
public string WriteFiles(string path)
{
var settings = new DICOMWriteSettings();
var meta = settings.GetFileMetaSettings();
meta.TransferSyntax = EvilDICOM.Core.Enums.TransferSyntax.EXPLICIT_VR_LITTLE_ENDIAN;
DICOMFileWriter.Write(path + "RP." + this.planUID + ".dcm", meta, plan);
DICOMFileWriter.Write(path + "RD." + this.doseUID + ".dcm", meta, dose);
//DICOMFileWriter.WriteLittleEndian(path + "RP." + this.planUID + ".dcm", plan);
//DICOMFileWriter.WriteLittleEndian(path + this.doseUID + ".dcm", dose);
return("Plan: RP." + this.planUID + ".dcm\r\nDose: RD." + this.doseUID + ".dcm\r\nWritten to " + path);
}
public FileWriterSCP(Entity ae, string storageLocation)
: base(ae)
{
_token = new CancellationToken();
_storagePath = storageLocation;
DIMSEService.CStorePayloadAction = (dcm, asc) =>
{
var uid = dcm.GetSelector().SOPInstanceUID.Data;
var path = Path.Combine(_storagePath, uid + ".dcm");
using (var fs = new FileStream(path, FileMode.Create))
{
Logger.Log("Writing file {0}...", path);
DICOMFileWriter.Write(fs, DICOMWriteSettings.Default(), dcm);
}
return(true);
};
}
public void WriteBigEndian()
{
var dcm = DICOMFileReader.Read(Resources.explicitLittleEndian);
var els = dcm.Elements.Count;
byte[] bytes;
using (var ms = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(ms))
{
var settings = new DICOMWriteSettings()
{
TransferSyntax = Enums.TransferSyntax.EXPLICIT_VR_BIG_ENDIAN, DoWriteIndefiniteSequences = false
};
DICOMObjectWriter.Write(dw, settings, dcm);
}
bytes = ms.ToArray();
}
var dcm2 = DICOMFileReader.Read(bytes);
Assert.AreEqual(dcm2.Elements.Count, els);
}
public void WriteDecimalString()
{
var ds = new DecimalString();
ds.DData_ = Enumerable.Range(1, 15000).Select(i => ((double)i) + 0.005).ToList();
ds.Tag = new Tag("00082130");
byte[] written;
var settings = DICOMWriteSettings.Default();
using (var ms = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(ms))
{
DICOMElementWriter.Write(dw, DICOMWriteSettings.Default(), ds);
}
written = ms.ToArray();
}
using (var dr = new DICOMBinaryReader(written))
{
var read = DICOMElementReader.ReadElementImplicitLittleEndian(dr) as DecimalString;
CollectionAssert.AreEqual(ds.DData_, read.Data_);
}
}
/// <summary>
/// Writes DICOM object to a file
/// </summary>
/// <param name="file">the path to write</param>
/// <param name="settings">the DICOM settings to write (endianness, and indefinite sequences)</param>
public void Write(string file, DICOMWriteSettings settings = null)
{
settings = settings ?? DICOMWriteSettings.Default();
DICOMFileWriter.Write(file, settings, this);
}
public void SetGroupLength()
{
var bytes = GroupWriter.WriteGroupBytes(new DICOMObject(Elements), DICOMWriteSettings.Default(), "0000");
GroupLength = (uint)bytes.Length;
}
