/// <summary> /// Validates that the photometric interpretation is not unknown. /// </summary> /// <param name="photometricInterpretation"></param> public static void ValidatePhotometricInterpretation(PhotometricInterpretation photometricInterpretation) { if (photometricInterpretation == PhotometricInterpretation.Unknown) { throw new DicomDataException(String.Format(SR.ExceptionInvalidPhotometricInterpretation, photometricInterpretation)); } }
public static IPixelData Create(DcmPixelData pixelData, int frame) { PhotometricInterpretation pi = PhotometricInterpretation.Lookup(pixelData.PhotometricInterpretation); if (pi == PhotometricInterpretation.Monochrome1 || pi == PhotometricInterpretation.Monochrome2 || pi == PhotometricInterpretation.PaletteColor) { if (pixelData.BitsStored <= 8) { return(new GrayscalePixelDataU8(pixelData.ImageWidth, pixelData.ImageHeight, pixelData.GetFrameDataU8(frame))); } else if (pixelData.BitsStored <= 16) { if (pixelData.IsSigned) { return(new GrayscalePixelDataS16(pixelData.ImageWidth, pixelData.ImageHeight, pixelData.GetFrameDataS16(frame))); } else { return(new GrayscalePixelDataU16(pixelData.ImageWidth, pixelData.ImageHeight, pixelData.GetFrameDataU16(frame))); } } else { throw new DicomImagingException("Unsupported pixel data value for bits stored: {0}", pixelData.BitsStored); } } else if (pi == PhotometricInterpretation.Rgb || pi == PhotometricInterpretation.YbrFull) { return(new ColorPixelData24(pixelData.ImageWidth, pixelData.ImageHeight, pixelData.GetFrameDataU8(frame))); } else { throw new DicomImagingException("Unsupported pixel data photometric interpretation: {0}", pi.Value); } }
public void ConvertPaletteColorToRgb() { Platform.CheckTrue(PhotometricInterpretation.Equals("PALETTE COLOR"), "Photometric Interpretation Palette Color Check"); List <FrameData> frames = new List <FrameData>(); for (int i = 0; i < NumberOfFrames; i++) { byte[] currentFrame = GetFrame(i); byte[] newFrame = new byte[UncompressedFrameSize * 3]; PaletteColorToRgb(BitsAllocated, IsSigned, currentFrame, newFrame, PaletteColorLut); frames.Add(new FrameDataBytes(this, newFrame, false)); } // change the Pixel Data element so we don't affect the original _pd = _pd.Tag.VR.CreateDicomAttribute(_pd.Tag); _fd.Clear(); _fd.AddRange(frames); SamplesPerPixel = 3; PhotometricInterpretation = "RGB"; PlanarConfiguration = 0; HasPaletteColorLut = false; }
public static NativePixelData ToNativePixelData(this DicomPixelData dicomPixelData) { return(new NativePixelData { NumberOfFrames = dicomPixelData.NumberOfFrames, Width = dicomPixelData.Width, Height = dicomPixelData.Height, SamplesPerPixel = dicomPixelData.SamplesPerPixel, HighBit = dicomPixelData.HighBit, BitsStored = dicomPixelData.BitsStored, BitsAllocated = dicomPixelData.BitsAllocated, BytesAllocated = dicomPixelData.BytesAllocated, UncompressedFrameSize = dicomPixelData.UncompressedFrameSize, PlanarConfiguration = (int)dicomPixelData.PlanarConfiguration, PixelRepresentation = (int)dicomPixelData.PixelRepresentation, TransferSyntaxIsLossy = dicomPixelData.Syntax.IsLossy, PhotometricInterpretation = dicomPixelData.PhotometricInterpretation.Value, GetFrameImpl = index => dicomPixelData.GetFrame(index).Data, AddFrameImpl = buffer => dicomPixelData.AddFrame(new MemoryByteBuffer(buffer)), SetPlanarConfigurationImpl = value => dicomPixelData.PlanarConfiguration = (PlanarConfiguration)value, SetPhotometricInterpretationImpl = value => dicomPixelData.PhotometricInterpretation = PhotometricInterpretation.Parse(value) }); }
// Create a 256 x 256 Secondary Capture Image Storage static private void CreateSmallDICOM(string fileName) { using (var writer = new gdcm.PixmapWriter()) { gdcm.Pixmap img = writer.GetImage(); img.SetNumberOfDimensions(3); img.SetDimension(0, 512); img.SetDimension(1, 512); img.SetDimension(2, 2); // fake a 3d volume PhotometricInterpretation pi = new PhotometricInterpretation(PhotometricInterpretation.PIType.MONOCHROME2); img.SetPhotometricInterpretation(pi); gdcm.DataElement pixeldata = new gdcm.DataElement(new gdcm.Tag(0x7fe0, 0x0010)); byte[] buffer = new byte[512 * 512 * 2]; pixeldata.SetByteValue(buffer, new gdcm.VL((uint)buffer.Length)); img.SetDataElement(pixeldata); gdcm.File file = writer.GetFile(); gdcm.DataSet ds = file.GetDataSet(); gdcm.DataElement ms = new gdcm.DataElement(new gdcm.Tag(0x0008, 0x0016)); string mediastorage = "1.2.840.10008.5.1.4.1.1.7.2"; // Multi-frame Grayscale Byte Secondary Capture Image Storage byte[] val = StrToByteArray(mediastorage); ms.SetByteValue(val, new gdcm.VL((uint)val.Length)); ds.Insert(ms); writer.SetFileName(fileName); writer.Write(); } }
// Create a 256 x 256 Secondary Capture Image Storage static private void CreateSmallDICOM(string fileName) { using( var writer = new gdcm.PixmapWriter() ) { gdcm.Pixmap img = writer.GetImage(); img.SetNumberOfDimensions( 3 ); img.SetDimension(0, 512 ); img.SetDimension(1, 512 ); img.SetDimension(2, 2 ); // fake a 3d volume PhotometricInterpretation pi = new PhotometricInterpretation( PhotometricInterpretation.PIType.MONOCHROME2 ); img.SetPhotometricInterpretation( pi ); gdcm.DataElement pixeldata = new gdcm.DataElement( new gdcm.Tag(0x7fe0,0x0010) ); byte[] buffer = new byte[ 512 * 512 * 2 ]; pixeldata.SetByteValue( buffer, new gdcm.VL((uint)buffer.Length) ); img.SetDataElement( pixeldata ); gdcm.File file = writer.GetFile(); gdcm.DataSet ds = file.GetDataSet(); gdcm.DataElement ms = new gdcm.DataElement(new gdcm.Tag(0x0008,0x0016)); string mediastorage = "1.2.840.10008.5.1.4.1.1.7.2"; // Multi-frame Grayscale Byte Secondary Capture Image Storage byte[] val = StrToByteArray(mediastorage); ms.SetByteValue( val, new gdcm.VL( (uint)val.Length) ); ds.Insert( ms ); writer.SetFileName( fileName ); writer.Write(); } }
private static JpegColorSpace GetJpegColorSpace(PhotometricInterpretation photometricInterpretation) { if (photometricInterpretation == PhotometricInterpretation.Rgb) { return(JpegColorSpace.sRGB); } else if (photometricInterpretation == PhotometricInterpretation.Monochrome1 || photometricInterpretation == PhotometricInterpretation.Monochrome2) { return(JpegColorSpace.GreyScale); } else if (photometricInterpretation == PhotometricInterpretation.PaletteColor) { return(JpegColorSpace.GreyScale); } else if (photometricInterpretation == PhotometricInterpretation.YbrFull || photometricInterpretation == PhotometricInterpretation.YbrFull422 || photometricInterpretation == PhotometricInterpretation.YbrPartial422) { return(JpegColorSpace.sYCC); } else { return(JpegColorSpace.Unknown); } }
private static void YbrTripletToArgb( byte[] ybrPixelData, byte[] argbPixelData, int sizeInPixels, PhotometricInterpretation photometricInterpretation) { fixed(byte *pYbrPixelData = ybrPixelData) { fixed(byte *pArgbPixelData = argbPixelData) { int src = 0; int dst = 0; YbrToRgb converter = GetYbrToRgbConverter(photometricInterpretation); for (int i = 0; i < sizeInPixels; i++) { int rgb = converter( pYbrPixelData[src], pYbrPixelData[src + 1], pYbrPixelData[src + 2]); pArgbPixelData[dst] = Color.FromArgb(rgb).B; pArgbPixelData[dst + 1] = Color.FromArgb(rgb).G; pArgbPixelData[dst + 2] = Color.FromArgb(rgb).R; pArgbPixelData[dst + 3] = 0xff; src += 3; dst += 4; } } } }
private static YbrToRgb GetYbrToRgbConverter(PhotometricInterpretation photometricInterpretation) { YbrToRgb converter; if (photometricInterpretation == PhotometricInterpretation.YbrFull) { converter = new YbrToRgb(YbrFullToRgb); } else if (photometricInterpretation == PhotometricInterpretation.YbrFull422) { converter = new YbrToRgb(YbrFull422ToRgb); } else if (photometricInterpretation == PhotometricInterpretation.YbrIct) { converter = new YbrToRgb(YbrIctToRgb); } else if (photometricInterpretation == PhotometricInterpretation.YbrPartial422) { converter = new YbrToRgb(YbrPartial422ToRgb); } else { converter = new YbrToRgb(YbrRctToRgb); } return(converter); }
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); } }
protected override byte[] CreateNormalizedPixelData() { string photometricInterpretation; byte[] pixelData = _framePixelData.GetUncompressedPixelData(out photometricInterpretation); string photometricInterpretationCode = photometricInterpretation ?? Parent[DicomTags.PhotometricInterpretation].ToString(); PhotometricInterpretation pi = PhotometricInterpretation.FromCodeString(photometricInterpretationCode); if (pi.IsColor) { pixelData = ToArgb(this.Parent, pixelData, pi); } else { var overlayPlaneModuleIod = new OverlayPlaneModuleIod(Parent); foreach (var overlayPlane in overlayPlaneModuleIod) { if (!overlayPlane.HasOverlayData && _overlayData[overlayPlane.Index] == null) { // if the overlay is embedded in pixel data and we haven't cached it yet, extract it now before we normalize the frame pixel data var overlayData = OverlayData.UnpackFromPixelData(overlayPlane.OverlayBitPosition, Parent[DicomTags.BitsAllocated].GetInt32(0, 0), false, pixelData); _overlayData[overlayPlane.Index] = overlayData; } } NormalizeGrayscalePixels(this.Parent, pixelData); } return(pixelData); }
private void UpdateImageBox(DcmImageBox imageBox, String filename, int index) { //try //{ var ff = new DicomFileFormat(); ff.Load(filename, DicomReadOptions.DefaultWithoutDeferredLoading); if (ff.Dataset == null) { return; } ff.Dataset.ChangeTransferSyntax(DicomTransferSyntax.ImplicitVRLittleEndian, null); var pixelData = new DcmPixelData(ff.Dataset); var pi = PhotometricInterpretation.Lookup(pixelData.PhotometricInterpretation); // Grayscale only printer? if (pi.IsColor && _supportsColorPrinting == false) { pixelData.Unload(); return; } // Color only printer? if (pi.IsColor == false && _supportsGrayscalePrinting == false) { pixelData.Unload(); return; } DicomUID imageBoxSOPClassUID; DcmItemSequence seq; var item = new DcmItemSequenceItem(); pixelData.UpdateDataset(item.Dataset); if (pi.IsColor) { imageBoxSOPClassUID = DicomUID.BasicColorImageBoxSOPClass; seq = new DcmItemSequence(DicomTags.BasicColorImageSequence); } else { imageBoxSOPClassUID = DicomUID.BasicGrayscaleImageBoxSOPClass; seq = new DcmItemSequence(DicomTags.BasicGrayscaleImageSequence); } seq.AddSequenceItem(item); imageBox.Dataset.AddItem(seq); pixelData.Unload(); imageBox.UpdateImageBox(imageBoxSOPClassUID); imageBox.ImageBoxPosition = (ushort)index; //} //catch (Exception) //{ //} }
/// <summary> /// Constructor. /// </summary> /// <param name="collection"></param> protected DicomPixelData(DicomAttributeCollection collection) { collection.LoadDicomFields(this); SopClass = SopClass.GetSopClass(collection[DicomTags.SopClassUid].GetString(0, string.Empty)); if (collection.Contains(DicomTags.NumberOfFrames)) { NumberOfFrames = collection[DicomTags.NumberOfFrames].GetInt32(0, 1); } if (collection.Contains(DicomTags.PlanarConfiguration)) { PlanarConfiguration = collection[DicomTags.PlanarConfiguration].GetUInt16(0, 1); } if (collection.Contains(DicomTags.LossyImageCompression)) { LossyImageCompression = collection[DicomTags.LossyImageCompression].GetString(0, string.Empty); } if (collection.Contains(DicomTags.LossyImageCompressionRatio)) { LossyImageCompressionRatio = collection[DicomTags.LossyImageCompressionRatio].GetFloat32(0, 1.0f); } if (collection.Contains(DicomTags.LossyImageCompressionMethod)) { LossyImageCompressionMethod = collection[DicomTags.LossyImageCompressionMethod].GetString(0, string.Empty); } if (collection.Contains(DicomTags.DerivationDescription)) { DerivationDescription = collection[DicomTags.DerivationDescription].GetString(0, string.Empty); } if (collection.Contains(DicomTags.RescaleSlope)) { RescaleSlope = collection[DicomTags.RescaleSlope].ToString(); } if (collection.Contains(DicomTags.RescaleIntercept)) { RescaleIntercept = collection[DicomTags.RescaleIntercept].ToString(); } if (collection.Contains(DicomTags.ModalityLutSequence)) { DicomAttribute attrib = collection[DicomTags.ModalityLutSequence]; _hasDataModalityLut = !attrib.IsEmpty && !attrib.IsNull; } _linearVoiLuts = Window.GetWindowCenterAndWidth(collection); if (collection.Contains(DicomTags.VoiLutSequence)) { DicomAttribute attrib = collection[DicomTags.VoiLutSequence]; _hasDataVoiLuts = !attrib.IsEmpty && !attrib.IsNull; } if (PhotometricInterpretation.Equals(Iod.PhotometricInterpretation.PaletteColor.Code) && collection.Contains(DicomTags.RedPaletteColorLookupTableDescriptor)) { _paletteColorLut = PaletteColorLut.Create(collection); _hasPaletteColorLut = true; } }
public void PhotometricInterpretationTest1() { Page target = new Page(); PhotometricInterpretation expected = new PhotometricInterpretation(); PhotometricInterpretation actual; actual = target.PhotometricInterpretation; Assert.Equal(expected, actual); }
public void GivenSupported16bitTransferSyntax_WhenRetrievingFrameAndAskingForConversion_ReturnedFileHasExpectedTransferSyntax( DicomTransferSyntax tsFrom, DicomTransferSyntax tsTo, PhotometricInterpretation photometricInterpretation) { DicomFile dicomFile = StreamAndStoredFileFromDataset(photometricInterpretation, false, tsFrom).Result.dicomFile; dicomFile.Dataset.ToInstanceIdentifier(); _transcoder.TranscodeFrame(dicomFile, 1, tsTo.UID.UID); }
public async Task GivenSupported16bitTransferSyntax_WhenRetrievingFileAndAskingForConversion_ReturnedFileHasExpectedTransferSyntax( DicomTransferSyntax tsFrom, DicomTransferSyntax tsTo, PhotometricInterpretation photometricInterpretation) { (DicomFile dicomFile, Stream stream) = await StreamAndStoredFileFromDataset(photometricInterpretation, false, tsFrom); dicomFile.Dataset.ToInstanceIdentifier(); Stream transcodedFile = await _transcoder.TranscodeFileAsync(stream, tsTo.UID.UID); ValidateTransferSyntax(tsTo, transcodedFile); }
/// <summary> /// Called by the base class to create a new byte buffer containing normalized pixel data /// for this frame (8 or 16-bit grayscale, or 32-bit ARGB). /// </summary> /// <returns>A new byte buffer containing the normalized pixel data.</returns> protected override byte[] CreateNormalizedPixelData() { DicomMessageBase message = this.Parent.SourceMessage; CodeClock clock = new CodeClock(); clock.Start(); PhotometricInterpretation photometricInterpretation; byte[] rawPixelData = null; if (!message.TransferSyntax.Encapsulated) { DicomUncompressedPixelData pixelData = new DicomUncompressedPixelData(message); // DICOM library uses zero-based frame numbers MemoryManager.Execute(delegate { rawPixelData = pixelData.GetFrame(_frameIndex); }); ExtractOverlayFrames(rawPixelData, pixelData.BitsAllocated); photometricInterpretation = PhotometricInterpretation.FromCodeString(message.DataSet[DicomTags.PhotometricInterpretation]); } else if (DicomCodecRegistry.GetCodec(message.TransferSyntax) != null) { DicomCompressedPixelData pixelData = new DicomCompressedPixelData(message); string pi = null; MemoryManager.Execute(delegate { rawPixelData = pixelData.GetFrame(_frameIndex, out pi); }); photometricInterpretation = PhotometricInterpretation.FromCodeString(pi); } else { throw new DicomCodecException("Unsupported transfer syntax"); } if (photometricInterpretation.IsColor) { rawPixelData = ToArgb(message.DataSet, rawPixelData, photometricInterpretation); } else { NormalizeGrayscalePixels(message.DataSet, rawPixelData); } clock.Stop(); PerformanceReportBroker.PublishReport("DicomMessageSopDataSource", "CreateFrameNormalizedPixelData", clock.Seconds); return(rawPixelData); }
public void SetPixelData(PixelData pixeldata) { if (IsColor) { _internalPhotometricInterpretation = null; PhotometricInterpretation = "RGB"; byte[] final = new byte[3 * Rows * Columns]; ArgbToRgb(pixeldata.Raw, final); PixelData = final; } else { PixelData = pixeldata.Raw; } }
protected override byte[] CreateNormalizedPixelData() { byte[] pixelData = _framePixelData.GetUncompressedPixelData(); string photometricInterpretationCode = this.Parent[DicomTags.PhotometricInterpretation].ToString(); PhotometricInterpretation pi = PhotometricInterpretation.FromCodeString(photometricInterpretationCode); TransferSyntax ts = TransferSyntax.GetTransferSyntax(this.Parent.TransferSyntaxUid); if (pi.IsColor) { if (ts == TransferSyntax.Jpeg2000ImageCompression || ts == TransferSyntax.Jpeg2000ImageCompressionLosslessOnly || ts == TransferSyntax.JpegExtendedProcess24 || ts == TransferSyntax.JpegBaselineProcess1) { pi = PhotometricInterpretation.Rgb; } pixelData = ToArgb(this.Parent, pixelData, pi); } else { OverlayPlaneModuleIod opmi = new OverlayPlaneModuleIod(this.Parent); foreach (OverlayPlane overlayPlane in opmi) { if (IsOverlayEmbedded(overlayPlane) && _overlayData[overlayPlane.Index] == null) { byte[] overlayData = OverlayData.UnpackFromPixelData(overlayPlane.OverlayBitPosition, this.Parent[DicomTags.BitsAllocated].GetInt32(0, 0), false, pixelData); _overlayData[overlayPlane.Index] = overlayData; } else if (!overlayPlane.HasOverlayData) { Platform.Log(LogLevel.Warn, "The image {0} appears to be missing OverlayData for group 0x{1:X4}.", this.Parent.SopInstanceUid, overlayPlane.Group); } } NormalizeGrayscalePixels(this.Parent, pixelData); } return(pixelData); }
public static IPixelData Create(DicomPixelData pixelData, int frame) { PhotometricInterpretation pi = pixelData.PhotometricInterpretation; if (pi == PhotometricInterpretation.Monochrome1 || pi == PhotometricInterpretation.Monochrome2 || pi == PhotometricInterpretation.PaletteColor) { if (pixelData.BitsStored <= 8) { return(new GrayscalePixelDataU8(pixelData.Width, pixelData.Height, pixelData.GetFrame(frame))); } else if (pixelData.BitsStored <= 16) { if (pixelData.PixelRepresentation == PixelRepresentation.Signed) { return(new GrayscalePixelDataS16(pixelData.Width, pixelData.Height, pixelData.BitDepth, pixelData.GetFrame(frame))); } else { return(new GrayscalePixelDataU16(pixelData.Width, pixelData.Height, pixelData.BitDepth, pixelData.GetFrame(frame))); } } else { throw new DicomImagingException("Unsupported pixel data value for bits stored: {0}", pixelData.BitsStored); } } else if (pi == PhotometricInterpretation.Rgb || pi == PhotometricInterpretation.YbrFull) { var buffer = pixelData.GetFrame(frame); if (pixelData.PlanarConfiguration == PlanarConfiguration.Planar) { buffer = PixelDataConverter.PlanarToInterleaved24(buffer); } return(new ColorPixelData24(pixelData.Width, pixelData.Height, buffer)); } else { throw new DicomImagingException("Unsupported pixel data photometric interpretation: {0}", pi.Value); } }
protected override byte[] CreateNormalizedPixelData() { byte[] pixelData = _framePixelData.GetUncompressedPixelData(); string photometricInterpretationCode = this.Parent[DicomTags.PhotometricInterpretation].ToString(); PhotometricInterpretation pi = PhotometricInterpretation.FromCodeString(photometricInterpretationCode); TransferSyntax ts = TransferSyntax.GetTransferSyntax(this.Parent.TransferSyntaxUid); if (pi.IsColor) { if (ts == TransferSyntax.Jpeg2000ImageCompression || ts == TransferSyntax.Jpeg2000ImageCompressionLosslessOnly || ts == TransferSyntax.JpegExtendedProcess24 || ts == TransferSyntax.JpegBaselineProcess1) { pi = PhotometricInterpretation.Rgb; } pixelData = ToArgb(this.Parent, pixelData, pi); } else { var overlayPlaneModuleIod = new OverlayPlaneModuleIod(Parent); foreach (var overlayPlane in overlayPlaneModuleIod) { if (!overlayPlane.HasOverlayData && _overlayData[overlayPlane.Index] == null) { // if the overlay is embedded in pixel data and we haven't cached it yet, extract it now before we normalize the frame pixel data var overlayData = OverlayData.UnpackFromPixelData(overlayPlane.OverlayBitPosition, Parent[DicomTags.BitsAllocated].GetInt32(0, 0), false, pixelData); _overlayData[overlayPlane.Index] = overlayData; } } NormalizeGrayscalePixels(this.Parent, pixelData); } return(pixelData); }
/// <summary> /// Converts pixel data of a particular photometric interpretation /// to ARGB. /// </summary> /// <param name="photometricInterpretation">The <see cref="PhotometricInterpretation"/> of <paramref name="srcPixelData"/>.</param> /// <param name="planarConfiguration">The planar configuration of <paramref name="srcPixelData"/>.</param> /// <param name="srcPixelData">The input pixel data to be converted.</param> /// <param name="argbPixelData">The converted output pixel data in ARGB format.</param> /// <remarks> /// Only RGB and YBR variants can be converted. For PALETTE COLOR, use <see cref="ToArgb(int,bool,byte[],byte[],IDataLut)"/>. /// </remarks> public static void ToArgb( PhotometricInterpretation photometricInterpretation, int planarConfiguration, byte[] srcPixelData, byte[] argbPixelData) { int sizeInPixels = argbPixelData.Length / 4; if (photometricInterpretation == PhotometricInterpretation.Monochrome1 || photometricInterpretation == PhotometricInterpretation.Monochrome2 || photometricInterpretation == PhotometricInterpretation.PaletteColor || photometricInterpretation == PhotometricInterpretation.Unknown) { throw new Exception("Invalid photometric interpretation. Must be either RGB or a YBR variant."); } if (photometricInterpretation == PhotometricInterpretation.Rgb) { if (planarConfiguration == 0) { RgbTripletToArgb(srcPixelData, argbPixelData, sizeInPixels); } else { RgbPlanarToArgb(srcPixelData, argbPixelData, sizeInPixels); } } else { if (planarConfiguration == 0) { YbrTripletToArgb(srcPixelData, argbPixelData, sizeInPixels, photometricInterpretation); } else { YbrPlanarToArgb(srcPixelData, argbPixelData, sizeInPixels, photometricInterpretation); } } }
private static Colorspace GetColorSpace(PhotometricInterpretation photometricInterpretation) { if (photometricInterpretation == PhotometricInterpretation.Rgb) { return(Colorspace.RGB); } else if (photometricInterpretation == PhotometricInterpretation.Monochrome1 || photometricInterpretation == PhotometricInterpretation.Monochrome2) { return(Colorspace.Grayscale); } else if (photometricInterpretation == PhotometricInterpretation.PaletteColor) { return(Colorspace.Grayscale); } else if (photometricInterpretation == PhotometricInterpretation.YbrFull || photometricInterpretation == PhotometricInterpretation.YbrFull422 || photometricInterpretation == PhotometricInterpretation.YbrPartial422) { return(Colorspace.YCbCr); } return(Colorspace.Unknown); }
public static int Main(string[] args) { string filename = args[0]; uint file_size = gdcm.PosixEmulation.FileSize(filename); // instantiate the reader: gdcm.ImageRegionReader reader = new gdcm.ImageRegionReader(); reader.SetFileName(filename); // pull DICOM info: if (!reader.ReadInformation()) { return(1); } // store current offset: uint cur_pos = reader.GetStreamCurrentPosition(); uint remaining = file_size - cur_pos; Console.WriteLine("Remaining bytes to read (Pixel Data): " + remaining.ToString()); // Get file infos gdcm.File f = reader.GetFile(); // get some info about image UIntArrayType dims = ImageHelper.GetDimensionsValue(f); PixelFormat pf = ImageHelper.GetPixelFormatValue(f); int pixelsize = pf.GetPixelSize(); PhotometricInterpretation pi = ImageHelper.GetPhotometricInterpretationValue(f); Console.WriteLine(pi.toString()); // buffer to get the pixels byte[] buffer = new byte[dims[0] * dims[1] * pixelsize]; // define a simple box region. BoxRegion box = new BoxRegion(); for (uint z = 0; z < dims[2]; z++) { // Define that I want the image 0, full size (dimx x dimy pixels) // and do that for each z: box.SetDomain(0, dims[0] - 1, 0, dims[1] - 1, z, z); //System.Console.WriteLine( box.toString() ); reader.SetRegion(box); // reader will try to load the uncompressed image region into buffer. // the call returns an error when buffer.Length is too small. For instance // one can call: // uint buf_len = reader.ComputeBufferLength(); // take into account pixel size // to get the exact size of minimum buffer if (reader.ReadIntoBuffer(buffer, (uint)buffer.Length)) { using (System.IO.Stream stream = System.IO.File.Open(@"/tmp/frame.raw", System.IO.FileMode.Create)) { System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream); writer.Write(buffer); } } else { throw new Exception("can't read pixels error"); } } return(0); }
public static int Main(string[] args) { string file1 = args[0]; System.IO.FileStream infile = new System.IO.FileStream(file1, System.IO.FileMode.Open, System.IO.FileAccess.Read); uint fsize = gdcm.PosixEmulation.FileSize(file1); byte[] jstream = new byte[fsize]; infile.Read(jstream, 0, jstream.Length); Trace.DebugOn(); Image image = new Image(); image.SetNumberOfDimensions(2); // important for now DataElement pixeldata = new DataElement(new gdcm.Tag(0x7fe0, 0x0010)); // DO NOT set a ByteValue here, JPEG is a particular kind of encapsulated syntax // in which can one cannot use a simple byte array for storage. Instead, see // gdcm.SequenceOfFragments //pixeldata.SetByteValue( jstream, new gdcm.VL( (uint)jstream.Length ) ); // Create a new SequenceOfFragments C++ object, store it as a SmartPointer : SmartPtrFrag sq = SequenceOfFragments.New(); Fragment frag = new Fragment(); frag.SetByteValue(jstream, new gdcm.VL((uint)jstream.Length)); // Single file => single fragment sq.AddFragment(frag); // Pass by reference: pixeldata.SetValue(sq.__ref__()); // insert: image.SetDataElement(pixeldata); // JPEG use YBR to achieve better compression ratio by default (not RGB) // FIXME hardcoded: PhotometricInterpretation pi = new PhotometricInterpretation(PhotometricInterpretation.PIType.YBR_FULL); image.SetPhotometricInterpretation(pi); // FIXME hardcoded: PixelFormat pixeltype = new PixelFormat(3, 8, 8, 7); image.SetPixelFormat(pixeltype); // FIXME hardcoded: image.SetTransferSyntax(new TransferSyntax(TransferSyntax.TSType.JPEGLosslessProcess14_1)); image.SetDimension(0, 692); image.SetDimension(1, 721); // Decompress ! byte[] decompressedData = new byte[(int)image.GetBufferLength()]; image.GetBuffer(decompressedData); // Write out the decompressed bytes System.Console.WriteLine(image.toString()); using (System.IO.Stream stream = System.IO.File.Open(@"/tmp/dd.raw", System.IO.FileMode.Create)) { System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream); writer.Write(decompressedData); } return(0); }
private async Task <(DicomFile dicomFile, Stream stream)> StreamAndStoredFileFromDataset(PhotometricInterpretation photometricInterpretation, bool is8BitPixelData, DicomTransferSyntax transferSyntax) { var dicomFile = is8BitPixelData ? Samples.CreateRandomDicomFileWith8BitPixelData(transferSyntax: transferSyntax.UID.UID, photometricInterpretation: photometricInterpretation.Value, frames: 2) : Samples.CreateRandomDicomFileWith16BitPixelData(transferSyntax: transferSyntax.UID.UID, photometricInterpretation: photometricInterpretation.Value, frames: 2); MemoryStream stream = _recyclableMemoryStreamManager.GetStream(); await dicomFile.SaveAsync(stream); stream.Position = 0; return(dicomFile, stream); }
/// <summary> /// Create <see cref="IPixelData"/> form <see cref="DicomPixelData"/> /// according to the input <paramref name="pixelData"/> <seealso cref="PhotometricInterpretation"/> /// </summary> /// <param name="pixelData">Input pixel data</param> /// <param name="frame">Frame number (0 based)</param> /// <returns>Implementation of <seealso cref="IPixelData"/> according to <seealso cref="PhotometricInterpretation"/></returns> public static IPixelData Create(DicomPixelData pixelData, int frame) { PhotometricInterpretation pi = pixelData.PhotometricInterpretation; if (pi == null) { // generally ACR-NEMA var samples = pixelData.SamplesPerPixel; if (samples == 0 || samples == 1) { pi = pixelData.Dataset.Contains(DicomTag.RedPaletteColorLookupTableData) ? PhotometricInterpretation.PaletteColor : PhotometricInterpretation.Monochrome2; } else { // assume, probably incorrectly, that the image is RGB pi = PhotometricInterpretation.Rgb; } } if (pixelData.BitsStored == 1) { if (pixelData.Dataset.GetSingleValue<DicomUID>(DicomTag.SOPClassUID) == DicomUID.MultiFrameSingleBitSecondaryCaptureImageStorage) // Multi-frame Single Bit Secondary Capture is stored LSB -> MSB return new SingleBitPixelData( pixelData.Width, pixelData.Height, PixelDataConverter.ReverseBits(pixelData.GetFrame(frame))); else // Need sample images to verify that this is correct return new SingleBitPixelData(pixelData.Width, pixelData.Height, pixelData.GetFrame(frame)); } else if (pi == PhotometricInterpretation.Monochrome1 || pi == PhotometricInterpretation.Monochrome2 || pi == PhotometricInterpretation.PaletteColor) { if (pixelData.BitsAllocated == 8 && pixelData.HighBit == 7 && pixelData.BitsStored == 8) return new GrayscalePixelDataU8(pixelData.Width, pixelData.Height, pixelData.GetFrame(frame)); else if (pixelData.BitsAllocated <= 16) { if (pixelData.PixelRepresentation == PixelRepresentation.Signed) return new GrayscalePixelDataS16( pixelData.Width, pixelData.Height, pixelData.BitDepth, pixelData.GetFrame(frame)); else return new GrayscalePixelDataU16( pixelData.Width, pixelData.Height, pixelData.BitDepth, pixelData.GetFrame(frame)); } else if (pixelData.BitsAllocated <= 32) { if (pixelData.PixelRepresentation == PixelRepresentation.Signed) return new GrayscalePixelDataS32( pixelData.Width, pixelData.Height, pixelData.BitDepth, pixelData.GetFrame(frame)); else return new GrayscalePixelDataU32( pixelData.Width, pixelData.Height, pixelData.BitDepth, pixelData.GetFrame(frame)); } else throw new DicomImagingException( "Unsupported pixel data value for bits stored: {0}", pixelData.BitsStored); } else if (pi == PhotometricInterpretation.Rgb || pi == PhotometricInterpretation.YbrFull || pi == PhotometricInterpretation.YbrFull422 || pi == PhotometricInterpretation.YbrPartial422) { var buffer = pixelData.GetFrame(frame); if (pixelData.PlanarConfiguration == PlanarConfiguration.Planar) buffer = PixelDataConverter.PlanarToInterleaved24(buffer); if (pi == PhotometricInterpretation.YbrFull) buffer = PixelDataConverter.YbrFullToRgb(buffer); else if (pi == PhotometricInterpretation.YbrFull422) buffer = PixelDataConverter.YbrFull422ToRgb(buffer, pixelData.Width); else if (pi == PhotometricInterpretation.YbrPartial422) buffer = PixelDataConverter.YbrPartial422ToRgb(buffer, pixelData.Width); return new ColorPixelData24(pixelData.Width, pixelData.Height, buffer); } else if (pi == PhotometricInterpretation.YbrFull422) { var buffer = pixelData.GetFrame(frame); if (pixelData.PlanarConfiguration == PlanarConfiguration.Planar) throw new DicomImagingException("Unsupported planar configuration for YBR_FULL_422"); return new ColorPixelData24(pixelData.Width, pixelData.Height, buffer); } else { throw new DicomImagingException( "Unsupported pixel data photometric interpretation: {0}", pi.Value); } }
public static int Main(string[] args) { string file1 = args[0]; Mpeg2VideoInfo info = new Mpeg2VideoInfo(file1); System.Console.WriteLine( info.StartTime ); System.Console.WriteLine( info.EndTime ); System.Console.WriteLine( info.Duration ); System.Console.WriteLine( info.AspectRatio ); System.Console.WriteLine( info.FrameRate ); System.Console.WriteLine( info.PictureWidth ); System.Console.WriteLine( info.PictureHeight ); ImageReader r = new ImageReader(); //Image image = new Image(); Image image = r.GetImage(); image.SetNumberOfDimensions( 3 ); DataElement pixeldata = new DataElement( new gdcm.Tag(0x7fe0,0x0010) ); System.IO.FileStream infile = new System.IO.FileStream(file1, System.IO.FileMode.Open, System.IO.FileAccess.Read); uint fsize = gdcm.PosixEmulation.FileSize(file1); byte[] jstream = new byte[fsize]; infile.Read(jstream, 0 , jstream.Length); SmartPtrFrag sq = SequenceOfFragments.New(); Fragment frag = new Fragment(); frag.SetByteValue( jstream, new gdcm.VL( (uint)jstream.Length) ); sq.AddFragment( frag ); pixeldata.SetValue( sq.__ref__() ); // insert: image.SetDataElement( pixeldata ); PhotometricInterpretation pi = new PhotometricInterpretation( PhotometricInterpretation.PIType.YBR_PARTIAL_420 ); image.SetPhotometricInterpretation( pi ); // FIXME hardcoded: PixelFormat pixeltype = new PixelFormat(3,8,8,7); image.SetPixelFormat( pixeltype ); // FIXME hardcoded: TransferSyntax ts = new TransferSyntax( TransferSyntax.TSType.MPEG2MainProfile); image.SetTransferSyntax( ts ); image.SetDimension(0, (uint)info.PictureWidth); image.SetDimension(1, (uint)info.PictureHeight); image.SetDimension(2, 721); ImageWriter writer = new ImageWriter(); gdcm.File file = writer.GetFile(); file.GetHeader().SetDataSetTransferSyntax( ts ); Anonymizer anon = new Anonymizer(); anon.SetFile( file ); MediaStorage ms = new MediaStorage( MediaStorage.MSType.VideoEndoscopicImageStorage); UIDGenerator gen = new UIDGenerator(); anon.Replace( new Tag(0x0008,0x16), ms.GetString() ); anon.Replace( new Tag(0x0018,0x40), "25" ); anon.Replace( new Tag(0x0018,0x1063), "40.000000" ); anon.Replace( new Tag(0x0028,0x34), "4\\3" ); anon.Replace( new Tag(0x0028,0x2110), "01" ); writer.SetImage( image ); writer.SetFileName( "dummy.dcm" ); if( !writer.Write() ) { System.Console.WriteLine( "Could not write" ); return 1; } return 0; }
public ImageLoader (ImageDirectory directory) { width = directory.Lookup (TagId.ImageWidth).ValueAsLong [0]; length = directory.Lookup (TagId.ImageLength).ValueAsLong [0]; bps = directory.Lookup (TagId.BitsPerSample).ValueAsLong; compression = (Compression) directory.Lookup (TagId.Compression).ValueAsLong [0]; interpretation = (PhotometricInterpretation) directory.Lookup (TagId.PhotometricInterpretation).ValueAsLong [0]; offsets = directory.Lookup (TagId.StripOffsets).ValueAsLong; strip_byte_counts = directory.Lookup (TagId.StripByteCounts).ValueAsLong; rows_per_strip = directory.Lookup (TagId.RowsPerStrip).ValueAsLong [0]; if (interpretation != }
public static int Main(string[] args) { string directory = args[0]; gdcm.Directory dir = new gdcm.Directory(); uint nfiles = dir.Load(directory); //System.Console.WriteLine(dir.toString()); gdcm.FilenamesType filenames = dir.GetFilenames(); Image image = new Image(); image.SetNumberOfDimensions( 3 ); // important for now DataElement pixeldata = new DataElement( new gdcm.Tag(0x7fe0,0x0010) ); // Create a new SequenceOfFragments C++ object, store it as a SmartPointer : SmartPtrFrag sq = SequenceOfFragments.New(); // Yeah, the file are not garantee to be in order, please adapt... for(uint i = 0; i < nfiles; ++i) { System.Console.WriteLine( filenames[(int)i] ); string file = filenames[(int)i]; System.IO.FileStream infile = new System.IO.FileStream(file, System.IO.FileMode.Open, System.IO.FileAccess.Read); uint fsize = gdcm.PosixEmulation.FileSize(file); byte[] jstream = new byte[fsize]; infile.Read(jstream, 0 , jstream.Length); Fragment frag = new Fragment(); frag.SetByteValue( jstream, new gdcm.VL( (uint)jstream.Length) ); sq.AddFragment( frag ); } // Pass by reference: pixeldata.SetValue( sq.__ref__() ); // insert: image.SetDataElement( pixeldata ); // JPEG use YBR to achieve better compression ratio by default (not RGB) // FIXME hardcoded: PhotometricInterpretation pi = new PhotometricInterpretation( PhotometricInterpretation.PIType.MONOCHROME2 ); image.SetPhotometricInterpretation( pi ); // FIXME hardcoded: PixelFormat pixeltype = new PixelFormat(1,8,8,7); image.SetPixelFormat( pixeltype ); // FIXME hardcoded: image.SetTransferSyntax( new TransferSyntax( TransferSyntax.TSType.JPEGLosslessProcess14_1 ) ); image.SetDimension(0, 512); image.SetDimension(1, 512); image.SetDimension(2, 355); // Decompress ! byte[] decompressedData = new byte[(int)image.GetBufferLength()]; image.GetBuffer(decompressedData); // Write out the decompressed bytes System.Console.WriteLine(image.toString()); using (System.IO.Stream stream = System.IO.File.Open(@"/tmp/dd.raw", System.IO.FileMode.Create)) { System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream); writer.Write(decompressedData); } return 0; }
/// <summary> /// Validates that the input image property relationships are compatible. /// </summary> public static void ValidateImagePropertyRelationships(int bitsStored, int bitsAllocated, int highBit, PhotometricInterpretation photometricInterpretation, int planarConfiguration, int samplesPerPixel) { if (bitsStored > bitsAllocated) { throw new DicomDataException(String.Format(SR.ExceptionInvalidBitsStoredBitsAllocated, bitsStored, bitsAllocated)); } if (highBit > bitsAllocated - 1) { throw new DicomDataException(String.Format(SR.ExceptionInvalidHighBitBitsAllocated, highBit, bitsAllocated)); } if ((photometricInterpretation == PhotometricInterpretation.Monochrome1 || photometricInterpretation == PhotometricInterpretation.Monochrome2) && samplesPerPixel != 1) { throw new DicomDataException(String.Format(SR.ExceptionInvalidPhotometricInterpretationSamplesPerPixel, photometricInterpretation, samplesPerPixel)); } if (samplesPerPixel != 1) { if (planarConfiguration != 0 && planarConfiguration != 1) { throw new DicomDataException(String.Format(SR.ExceptionInvalidPlanarConfiguration)); } } if ((photometricInterpretation == PhotometricInterpretation.Rgb || photometricInterpretation == PhotometricInterpretation.YbrFull || photometricInterpretation == PhotometricInterpretation.YbrFull422 || photometricInterpretation == PhotometricInterpretation.YbrPartial422 || photometricInterpretation == PhotometricInterpretation.YbrIct || photometricInterpretation == PhotometricInterpretation.YbrRct) && samplesPerPixel != 3) { throw new DicomDataException(String.Format(SR.ExceptionInvalidPhotometricInterpretationSamplesPerPixel, photometricInterpretation, samplesPerPixel)); } }
/// <summary> /// Converts colour pixel data to ARGB. /// </summary> protected static byte[] ToArgb(IDicomAttributeProvider dicomAttributeProvider, byte[] pixelData, PhotometricInterpretation photometricInterpretation) { CodeClock clock = new CodeClock(); clock.Start(); int rows = dicomAttributeProvider[DicomTags.Rows].GetInt32(0, 0); int columns = dicomAttributeProvider[DicomTags.Columns].GetInt32(0, 0); int sizeInBytes = rows * columns * 4; byte[] argbPixelData = MemoryManager.Allocate <byte>(sizeInBytes); // Convert palette colour images to ARGB so we don't get interpolation artifacts // when rendering. if (photometricInterpretation == PhotometricInterpretation.PaletteColor) { int bitsAllocated = dicomAttributeProvider[DicomTags.BitsAllocated].GetInt32(0, 0); int pixelRepresentation = dicomAttributeProvider[DicomTags.PixelRepresentation].GetInt32(0, 0); ColorSpaceConverter.ToArgb( bitsAllocated, pixelRepresentation != 0 ? true : false, pixelData, argbPixelData, PaletteColorMap.Create(dicomAttributeProvider)); } // Convert RGB and YBR variants to ARGB else { int planarConfiguration = dicomAttributeProvider[DicomTags.PlanarConfiguration].GetInt32(0, 0); ColorSpaceConverter.ToArgb( photometricInterpretation, planarConfiguration, pixelData, argbPixelData); } clock.Stop(); PerformanceReportBroker.PublishReport("DicomMessageSopDataSource", "ToArgb", clock.Seconds); return(argbPixelData); }
public static int Main(string[] args) { string file1 = args[0]; System.IO.FileStream infile = new System.IO.FileStream(file1, System.IO.FileMode.Open, System.IO.FileAccess.Read); uint fsize = gdcm.PosixEmulation.FileSize(file1); byte[] jstream = new byte[fsize]; infile.Read(jstream, 0 , jstream.Length); Trace.DebugOn(); Image image = new Image(); image.SetNumberOfDimensions( 2 ); // important for now DataElement pixeldata = new DataElement( new gdcm.Tag(0x7fe0,0x0010) ); // DO NOT set a ByteValue here, JPEG is a particular kind of encapsulated syntax // in which can one cannot use a simple byte array for storage. Instead, see // gdcm.SequenceOfFragments //pixeldata.SetByteValue( jstream, new gdcm.VL( (uint)jstream.Length ) ); // Create a new SequenceOfFragments C++ object, store it as a SmartPointer : SmartPtrFrag sq = SequenceOfFragments.New(); Fragment frag = new Fragment(); frag.SetByteValue( jstream, new gdcm.VL( (uint)jstream.Length) ); // Single file => single fragment sq.AddFragment( frag ); // Pass by reference: pixeldata.SetValue( sq.__ref__() ); // insert: image.SetDataElement( pixeldata ); // JPEG use YBR to achieve better compression ratio by default (not RGB) // FIXME hardcoded: PhotometricInterpretation pi = new PhotometricInterpretation( PhotometricInterpretation.PIType.YBR_FULL ); image.SetPhotometricInterpretation( pi ); // FIXME hardcoded: PixelFormat pixeltype = new PixelFormat(3,8,8,7); image.SetPixelFormat( pixeltype ); // FIXME hardcoded: image.SetTransferSyntax( new TransferSyntax( TransferSyntax.TSType.JPEGLosslessProcess14_1 ) ); image.SetDimension(0, 692); image.SetDimension(1, 721); // Decompress ! byte[] decompressedData = new byte[(int)image.GetBufferLength()]; image.GetBuffer(decompressedData); // Write out the decompressed bytes System.Console.WriteLine(image.toString()); using (System.IO.Stream stream = System.IO.File.Open(@"/tmp/dd.raw", System.IO.FileMode.Create)) { System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream); writer.Write(decompressedData); } return 0; }
public static int Main(string[] args) { string directory = args[0]; gdcm.Directory dir = new gdcm.Directory(); uint nfiles = dir.Load(directory); //System.Console.WriteLine(dir.toString()); gdcm.FilenamesType filenames = dir.GetFilenames(); Image image = new Image(); image.SetNumberOfDimensions(3); // important for now DataElement pixeldata = new DataElement(new gdcm.Tag(0x7fe0, 0x0010)); // Create a new SequenceOfFragments C++ object, store it as a SmartPointer : SmartPtrFrag sq = SequenceOfFragments.New(); // Yeah, the file are not garantee to be in order, please adapt... for (uint i = 0; i < nfiles; ++i) { System.Console.WriteLine(filenames[(int)i]); string file = filenames[(int)i]; System.IO.FileStream infile = new System.IO.FileStream(file, System.IO.FileMode.Open, System.IO.FileAccess.Read); uint fsize = gdcm.PosixEmulation.FileSize(file); byte[] jstream = new byte[fsize]; infile.Read(jstream, 0, jstream.Length); Fragment frag = new Fragment(); frag.SetByteValue(jstream, new gdcm.VL((uint)jstream.Length)); sq.AddFragment(frag); } // Pass by reference: pixeldata.SetValue(sq.__ref__()); // insert: image.SetDataElement(pixeldata); // JPEG use YBR to achieve better compression ratio by default (not RGB) // FIXME hardcoded: PhotometricInterpretation pi = new PhotometricInterpretation(PhotometricInterpretation.PIType.MONOCHROME2); image.SetPhotometricInterpretation(pi); // FIXME hardcoded: PixelFormat pixeltype = new PixelFormat(1, 8, 8, 7); image.SetPixelFormat(pixeltype); // FIXME hardcoded: image.SetTransferSyntax(new TransferSyntax(TransferSyntax.TSType.JPEGLosslessProcess14_1)); image.SetDimension(0, 512); image.SetDimension(1, 512); image.SetDimension(2, 355); // Decompress ! byte[] decompressedData = new byte[(int)image.GetBufferLength()]; image.GetBuffer(decompressedData); // Write out the decompressed bytes System.Console.WriteLine(image.toString()); using (System.IO.Stream stream = System.IO.File.Open(@"/tmp/dd.raw", System.IO.FileMode.Create)) { System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream); writer.Write(decompressedData); } return(0); }
public static int Main(string[] args) { string file1 = args[0]; string file2 = args[1]; ImageReader reader = new ImageReader(); reader.SetFileName(file1); bool ret = reader.Read(); if (!ret) { return(1); } Image image = new Image(); Image ir = reader.GetImage(); image.SetNumberOfDimensions(ir.GetNumberOfDimensions()); //Just for fun: //int dircos = ir.GetDirectionCosines(); //t = gdcm.Orientation.GetType(dircos); //int l = gdcm.Orientation.GetLabel(t); //System.Console.WriteLine( "Orientation label:" + l ); // Set the dimensions, // 1. either one at a time //image.SetDimension(0, ir.GetDimension(0) ); //image.SetDimension(1, ir.GetDimension(1) ); // 2. the array at once uint[] dims = { 0, 0 }; // Just for fun let's invert the dimensions: dims[0] = ir.GetDimension(1); dims[1] = ir.GetDimension(0); ir.SetDimensions(dims); PixelFormat pixeltype = ir.GetPixelFormat(); image.SetPixelFormat(pixeltype); PhotometricInterpretation pi = ir.GetPhotometricInterpretation(); image.SetPhotometricInterpretation(pi); DataElement pixeldata = new DataElement(new Tag(0x7fe0, 0x0010)); byte[] str1 = new byte[ir.GetBufferLength()]; ir.GetBuffer(str1); //System.Console.WriteLine( ir.GetBufferLength() ); pixeldata.SetByteValue(str1, new VL((uint)str1.Length)); //image.SetDataElement( pixeldata ); ir.SetDataElement(pixeldata); ImageWriter writer = new ImageWriter(); writer.SetFileName(file2); writer.SetFile(reader.GetFile()); writer.SetImage(ir); ret = writer.Write(); if (!ret) { return(1); } return(0); }