private void _sendImage(PSImage image, Stream outputStream, BinaryWriter writer)
{
var transferSyntax = TransferSyntaxes.Lookup(image.TransferSyntaxID);
if (transferSyntax.Compression != DICOMSharp.Data.Compression.CompressionInfo.None)
{
// Need to decompress
var data = new DICOMData();
data.ParseFile(PSUtils.GetParsedFilePath(image.Path), true, PSUtils.GetLogger());
data.Uncompress();
var memStream = new MemoryStream();
data.WriteToStreamAsPart10File(memStream, PSUtils.GetLogger());
writer.Write((UInt32)(memStream.Length + 4));
memStream.Position = 0;
memStream.CopyTo(outputStream);
}
else
{
// Write the file out directly.
var fileInfo = new FileInfo(PSUtils.GetParsedFilePath(image.Path));
var size = fileInfo.Length;
writer.Write((UInt32)(size + 4));
fileInfo.OpenRead().CopyTo(outputStream);
}
}
public static void RoundTripAndRender()
{
foreach (FileInfo fi in new DirectoryInfo("..\\CompressionSamples").GetFiles("*.dcm"))
{
Console.WriteLine("Compression Test -- Filename: " + fi.Name);
DICOMData data = new DICOMData();
data.ParseFile(fi.FullName, true, new NullLogger());
TransferSyntax syntax = data.TransferSyntax;
int compressedLength = (int)data[DICOMTags.PixelData].GetDataLength(false);
data.Uncompress();
Image testImage = DICOMQuickRenderer.QuickRender(data, 0);
Assert.IsNotNull(testImage);
int uncompressedLength = (int)data[DICOMTags.PixelData].GetDataLength(false);
Assert.IsTrue(uncompressedLength > compressedLength);
if (CompressionWorker.SupportsCompression(syntax.Compression))
{
data.ChangeTransferSyntax(syntax);
int recompressedLength = (int)data[DICOMTags.PixelData].GetDataLength(false);
Assert.IsTrue(recompressedLength < uncompressedLength);
}
//data.WriteFile(fi.FullName.Replace(".dcm", "_un.dcm"));
}
}
private void menuItem8_Click(object sender, EventArgs e)
{
//Tools/uncompress
CurDCM.Uncompress();
RefreshView();
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
DICOMData loadedData = new DICOMData();
loadedData.ParseFile(openFileDialog1.FileName, true, new NullLogger());
loadedData.Uncompress();
if (loadedData.Elements.ContainsKey(DICOMTags.PixelData))
{
viewer.AddImage(loadedData);
}
}
}
private void listener_StoreRequest(DICOMConnection conn, DICOMData data)
{
try
{
if (!this._settings.StoreMetadataOnlyFiles && !data.Elements.ContainsKey(DICOMTags.PixelData))
{
this._logger.Log(LogLevel.Info, "Data set has no image data (only metadata). Metadata storing is disabled, so image will not be persisted.");
conn.SendCSTORERSP(CommandStatus.Error_MissingAttribute);
return;
}
if (this._settings.AutoDecompress && data.TransferSyntax.Compression != DICOMSharp.Data.Compression.CompressionInfo.None)
{
this._logger.Log(LogLevel.Info, "Image is compressed, decompressing before storage!");
if (!data.Uncompress())
{
this._logger.Log(LogLevel.Warning, "Image decompression failed! Storing compressed image.");
}
}
string postName = FileUtil.GenerateFilenameFromImage(data, this._logger);
//form full file path
string diskPath = _db.FixImagePath(this._settings.ImageStoragePath);
if (!diskPath.EndsWith("\\"))
{
diskPath += "\\";
}
diskPath += postName;
data.WriteFile(diskPath, this._logger);
// Db path can save a ~ path, so recalc without MapPath
string dbPath = this._settings.ImageStoragePath;
if (!dbPath.EndsWith("\\"))
{
dbPath += "\\";
}
dbPath += postName;
this._db.PersistImage(data, diskPath, dbPath);
conn.SendCSTORERSP(CommandStatus.Success);
}
catch (Exception e)
{
this._logger.Log(LogLevel.Error, "Error in StoreRequest: " + e.ToString());
conn.SendCSTORERSP(CommandStatus.Error_UnrecognizedOperation);
}
}
/// <summary>
/// Sets/changes the DICOMData that the RenderAssistant will be rendering. Important information about
/// the image is pre-loaded for faster repeated rendering.
/// Note: Calling this function does not automatically cause a redraw.
/// You may also
/// </summary>
/// <param name="newData">New DICOMData to draw from (may be null to clear parameters)</param>
public void SetSource(DICOMData newData)
{
if (newData == data)
{
return;
}
data = newData;
if (data == null)
{
FrameCount = 0;
return;
}
if (!data.Uncompress())
{
throw new Exception("Unsupported Compression, can't decompress.");
}
if (!data.Elements.ContainsKey(DICOMTags.BitsAllocated))
{
throw new MissingMemberException("Missing the Bits Allocated field, can't render.");
}
bitsAllocated = (ushort)data.Elements[DICOMTags.BitsAllocated].Data;
bytes = (bitsAllocated == 8) ? 1 : 2;
if (!data.Elements.ContainsKey(DICOMTags.PhotometricInterpretation))
{
throw new MissingMemberException("Missing the Photometric Interpretation field, can't render.");
}
photoInterp = data.Elements[DICOMTags.PhotometricInterpretation].Display.Trim();
bFlipMono = (photoInterp == "MONOCHROME1");
bRGB = (photoInterp == "RGB");
bPalette = (photoInterp == "PALETTE COLOR");
if (bPalette)
{
if (!data.Elements.ContainsKey(DICOMTags.RedPaletteColorLookupTableData) || !data.Elements.ContainsKey(DICOMTags.GreenPaletteColorLookupTableData) || !data.Elements.ContainsKey(DICOMTags.BluePaletteColorLookupTableData))
{
throw new MissingMemberException("Missing a Palette Lookup field on a PALETTE COLORed image, can't render.");
}
palettes = new byte[3][] {
(byte[])data.Elements[DICOMTags.RedPaletteColorLookupTableData].Data,
(byte[])data.Elements[DICOMTags.GreenPaletteColorLookupTableData].Data,
(byte[])data.Elements[DICOMTags.BluePaletteColorLookupTableData].Data
};
//PS 3, Page 417-418
if (!data.Elements.ContainsKey(DICOMTags.RedPaletteColorLookupTableDescriptor) || !data.Elements.ContainsKey(DICOMTags.GreenPaletteColorLookupTableDescriptor) || !data.Elements.ContainsKey(DICOMTags.BluePaletteColorLookupTableDescriptor))
{
throw new MissingMemberException("Missing a Palette Descriptor field on a PALETTE COLORed image, can't render.");
}
palette16 = (((ushort[])data.Elements[DICOMTags.RedPaletteColorLookupTableDescriptor].Data)[2] == 16);
paletteNumEntries = ((ushort[])data.Elements[DICOMTags.RedPaletteColorLookupTableDescriptor].Data)[0];
if (paletteNumEntries == 0)
{
// Apparently 0 means 65536
paletteNumEntries = 65536;
}
paletteFirstEntry = ((ushort[])data.Elements[DICOMTags.RedPaletteColorLookupTableDescriptor].Data)[1];
//figure out supplemental palette color LUT at some point
if (palette16)
{
// Flip endianness of the palettes
palettes16 = new ushort[3][]
{
new ushort[paletteNumEntries],
new ushort[paletteNumEntries],
new ushort[paletteNumEntries]
};
for (int i = 0; i < paletteNumEntries; i++)
{
palettes16[0][i] = (ushort)(palettes[0][2 * i + 1] | (palettes[0][2 * i] << 8));
palettes16[1][i] = (ushort)(palettes[1][2 * i + 1] | (palettes[1][2 * i] << 8));
palettes16[2][i] = (ushort)(palettes[2][2 * i + 1] | (palettes[2][2 * i] << 8));
}
}
}
else
{
palettes = new byte[3][];
palettes16 = new ushort[3][];
}
bPlanarOne = false;
if (data.Elements.ContainsKey(DICOMTags.PlanarConfiguration))
{
bPlanarOne = ((ushort)data.Elements[DICOMTags.PlanarConfiguration].Data == 1);
}
if (!data.Elements.ContainsKey(DICOMTags.ImageWidth))
{
throw new MissingMemberException("Missing the Image Width field, can't render.");
}
if (!data.Elements.ContainsKey(DICOMTags.ImageHeight))
{
throw new MissingMemberException("Missing the Image Height field, can't render.");
}
imWidth = (ushort)data.Elements[DICOMTags.ImageWidth].Data;
imHeight = (ushort)data.Elements[DICOMTags.ImageHeight].Data;
signedData = false;
if (data.Elements.ContainsKey(DICOMTags.PixelRepresentation))
{
signedData = Convert.ToInt32(data.Elements[DICOMTags.PixelRepresentation].Data) == 1;
}
bRescaling = (data.Elements.ContainsKey(DICOMTags.RescaleIntercept) && data.Elements.ContainsKey(DICOMTags.RescaleSlope));
adjM = 1.0f; adjB = 0;
if (bRescaling)
{
adjB = float.Parse((string)data.Elements[DICOMTags.RescaleIntercept].Data);
adjM = float.Parse((string)data.Elements[DICOMTags.RescaleSlope].Data);
if (adjB == 0 && adjM == 1.0f)
{
bRescaling = false;
}
}
if (data.Elements.ContainsKey(DICOMTags.PixelIntensityRelationship))
{
string intensityRelationship = data.Elements[DICOMTags.PixelIntensityRelationship].Data.ToString().Trim().ToUpperInvariant();
if (intensityRelationship == "LIN")
{
if (data.Elements.ContainsKey(DICOMTags.PixelIntensityRelationshipSign))
{
float newAdj = float.Parse(data.Elements[DICOMTags.PixelIntensityRelationshipSign].Data.ToString());
if (newAdj == -1)
{
adjM *= newAdj;
ushort bitsStored = (ushort)data.Elements[DICOMTags.BitsStored].Data;
if (bitsStored == 16)
{
adjB += 65536;
}
else if (bitsStored == 12)
{
adjB += 4096;
}
else if (bitsStored == 8)
{
adjB += 256;
}
bRescaling = true;
}
}
}
}
bMultiframe = (data.Elements.ContainsKey(DICOMTags.NumberOfFrames));
if (bMultiframe)
{
FrameCount = int.Parse((string)data.Elements[DICOMTags.NumberOfFrames].Data);
}
else
{
FrameCount = 1;
}
if (!data.Elements.ContainsKey(DICOMTags.PixelData))
{
throw new MissingMemberException("Missing the Pixel Data field, can't render.");
}
pixelData = data.Elements[DICOMTags.PixelData];
}
private TaskInfo ImportFromPath(string basePath)
{
var taskInfo = new TaskInfo()
{
Token = new CancellationTokenSource()
};
taskInfo.Task = Task.Run(() =>
{
taskInfo.Token.Token.ThrowIfCancellationRequested();
this._logger.Log(LogLevel.Info, "Importing from Path: " + basePath);
DirectoryInfo di = new DirectoryInfo(basePath);
if (!di.Exists)
{
this._logger.Log(LogLevel.Error, "Directory not found!");
return;
}
else
{
FileUtil.ImageAddedHandler callback = (DICOMData data, string path) =>
{
taskInfo.ProgressCount++;
taskInfo.ProgressTotal++;
if (!data.Elements.ContainsKey(DICOMTags.PixelData) && !this._settings.StoreMetadataOnlyFiles)
{
this._logger.Log(LogLevel.Info, "Data set has no image data (only metadata). Metadata storing is disabled, so image will not be persisted.");
return;
}
if (this._settings.AutoDecompress && data.TransferSyntax.Compression != DICOMSharp.Data.Compression.CompressionInfo.None)
{
this._logger.Log(LogLevel.Info, "Image is compressed, decompressing in place!");
DICOMData fullData = new DICOMData();
if (fullData.ParseFile(path, true, this._logger))
{
if (fullData.Uncompress())
{
if (fullData.WriteFile(path, this._logger))
{
// Stuff the new decompressed and written file into the DB instead
data = fullData;
}
else
{
this._logger.Log(LogLevel.Warning, "Failed to write out decompressed file! Storing compressed image.");
}
}
else
{
this._logger.Log(LogLevel.Warning, "Image decompression failed! Storing compressed image.");
}
}
else
{
this._logger.Log(LogLevel.Warning, "Couldn't parse full image data! Storing compressed image.");
}
}
this._db.PersistImage(data, path, path);
};
FileUtil.ParseAndLoadImagesFromDirectoryRecursively(di, callback, this._logger, taskInfo.Token.Token);
}
this._logger.Log(LogLevel.Info, "Done Importing from Path: " + basePath);
}, taskInfo.Token.Token);
return(taskInfo);
}
