pixeldata.cs

Open Dicom source code C#

        /// <summary>
        ///     Determines by the DICOM transfer syntax whether pixel data
        ///     is stored as JPEG. If the transfer syntax is unknown,
        ///     pixel data will not be understood as JPEG data.
        /// </summary>
        public bool IsJpeg
        {
            get
            {
                if (transferSyntax != null)
                    return Regex.IsMatch(transferSyntax.Uid.ToString(),
                        "^1\\.2\\.840\\.10008\\.1\\.2\\.4");
                else
                    return false;
            }
        }


        public PixelData(int samplesPerPixel, int planarConfiguration, int rows,
            int columns, int bitsAllocated, int bitsStored, int highBit,
            DataElement data, TransferSyntax transferSyntax)
        {
            LoadFrom(samplesPerPixel, planarConfiguration, rows, columns,
                bitsAllocated, bitsStored, highBit, data, transferSyntax);
        }

        public PixelData(DataElement samplesPerPixel, 
            DataElement planarConfiguration, DataElement rows,
            DataElement columns, DataElement bitsAllocated, 
            DataElement bitsStored, DataElement highBit, DataElement data)
        {
            LoadFrom(samplesPerPixel, planarConfiguration, rows, columns, 
                bitsAllocated, bitsStored, highBit, data);
        }

        /// <summary>
        ///     Creates a pixel data instance from the specified data set.
        /// </summary>
        public PixelData(DataSet dataSet)
        {
            LoadFrom(dataSet);
        }

        public void LoadFrom(int samplesPerPixel, int planarConfiguration, 
            int rows, int columns, int bitsAllocated, int bitsStored, 
            int highBit, DataElement data, TransferSyntax transferSyntax)
        {
            this.samplesPerPixel = samplesPerPixel;
            this.planarConfiguration = planarConfiguration;
            this.rows = rows;
            this.columns = columns;
            this.bitsAllocated = bitsAllocated;
            this.bitsAllocated = bitsStored;
            this.highBit = highBit;
            this.data = data;
            this.transferSyntax = transferSyntax;
        }

        public void LoadFrom(DataElement samplesPerPixel, 
            DataElement planarConfiguration, DataElement rows,
            DataElement columns, DataElement bitsAllocated, 
            DataElement bitsStored, DataElement highBit, DataElement data)
        {
            this.samplesPerPixel = ToValue(samplesPerPixel);
            this.planarConfiguration = ToValue(planarConfiguration);
            this.rows = ToValue(rows);
            this.columns = ToValue(columns);
            this.bitsAllocated = ToValue(bitsAllocated);
            this.bitsStored = ToValue(bitsStored);
            this.highBit = ToValue(highBit);
            this.data = data;
        }

        /// <summary>
        ///     Re-creates a pixel data instance from the specified data set.
        /// </summary>
        public void LoadFrom(DataSet dataSet)
        {
            if (dataSet != null)
            {
                foreach (DataElement element in dataSet)
                {
                    if (element.Tag.Equals(SamplesPerPixelTag))
                        samplesPerPixel = ToValue(element);
                    else if (element.Tag.Equals(PlanarConfigurationTag))
                        planarConfiguration = ToValue(element);
                    else if (element.Tag.Equals(RowsTag))
                        rows = ToValue(element);
                    else if (element.Tag.Equals(ColumnsTag))
                        columns = ToValue(element);
                    else if (element.Tag.Equals(BitsAllocatedTag))
                        bitsAllocated = ToValue(element);
                    else if (element.Tag.Equals(BitsStoredTag))
                        bitsStored = ToValue(element);
                    else if (element.Tag.Equals(HighBitTag))
                        highBit = ToValue(element);
                    else if (element.Tag.Equals(PixelDataTag))
                        data = element;
                    else if (element.Tag.Equals(TransferSyntax.UidTag))
                        transferSyntax = new TransferSyntax(element);
                }
            }
            else
                throw new DicomException("Data set is null.", "dataSet");
        }

        private int ToValue(DataElement element)
        {
            if (element != null)
            {
                if ( ! element.Tag.Equals(PixelDataTag))
                    return (ushort) element.Value[0];
                else
                    throw new DicomException("Data element does not belong " +
                        "to pixel data.", "element.Tag", 
                        element.Tag.ToString());
            }
            else
                throw new DicomException("Data element is null.", "element");            
        }

        /// <summary>
        ///     Determines whether specified data set contains pixel data.
        /// </summary>
        public static bool HasPixelData(DataSet dataSet)
        {
            if (dataSet != null)
                return dataSet.Contains(PixelDataTag);
            else
                return false;
        }

        /// <summary>
        ///     Determines whether specified data set contains the minimum
        ///     of necessary content for working with pixel data.
        /// </summary>
        public static bool IsValid(DataSet dataSet)
        {
            if (dataSet != null)
                return dataSet.Contains(SamplesPerPixelTag)
                    && dataSet.Contains(PlanarConfigurationTag)
                    && dataSet.Contains(RowsTag)
                    && dataSet.Contains(ColumnsTag)
                    && dataSet.Contains(BitsAllocatedTag)
                    && dataSet.Contains(BitsStoredTag) 
                    && dataSet.Contains(HighBitTag)
                    && dataSet.Contains(PixelDataTag);
            else
                return false;
        }

        /// <summary>
        ///     Returns the entire DICOM pixel data as array of binary arrays.
        /// </summary>
        /// <remarks>
        ///     If a DICOM pixel data element is not a DICOM sequence of items,
        ///     an array with a single binary array entry will be returned.
        ///     Binary arrays are supposed to be of the type byte[], ushort[]
        ///     or short[].
        /// </remarks>
        public object[] ToArray()
        {
            if (Data.Value.IsSequence)
            {
                Sequence sq = (Sequence) Data.Value[0];
                object[] array = new object[sq.Count];
                for (int i = 0; i < sq.Count; i++)
                    array[i] = sq[i].Value[0];
                return array;
            }
            else
                return new object[1] { Data.Value[0] };
        }

        /// <summary>
        ///     Returns the entire DICOM pixel data as array of byte arrays.
        /// </summary>
        /// <remarks>
        ///     All non-byte arrays are transcoded into byte arrays. If a DICOM
        ///     pixel data element is not a DICOM sequence of items, an array
        ///     with a single byte array entry will be returned.
        /// </remarks>
        public byte[][] ToBytesArray()
        {
            byte[][] bytesArray;
            if (Data.Value.IsSequence)
            {
                Sequence sq = (Sequence) Data.Value[0];
                bytesArray = new byte[sq.Count][];
                for (int i = 0; i < sq.Count; i++)
                {
                    if (sq[i].Value[0] is ushort[])
                        bytesArray[i] = ByteConvert.ToBytes(
                            (ushort[]) sq[i].Value[0]);
                    else
                        bytesArray[i] = (byte[]) sq[i].Value[0];
                }
            }
            else
            {
                bytesArray = new byte[1][];
                if (Data.Value[0] is ushort[])
                    bytesArray[0] = ByteConvert.ToBytes(
                        (ushort[]) Data.Value[0]);
                else
                    bytesArray[0] = (byte[]) Data.Value[0];
            }
            return bytesArray;
        }
    }

}