/// <summary>
        /// Try to get VR for given string value.
        /// </summary>
        /// <param name="vr">String representation of VR</param>
        /// <param name="result">VR code</param>
        /// <returns>true if VR was successfully parsed, false otherwise</returns>
        public static bool TryParse(string vr, out DicomVR result)
        {
            bool valid;

            result = TryParse(vr, out valid);
            return(valid);
        }
Exemple #2
0
        private void ReadInlineBinary
        (
            fo.DicomTag tag,
            fo.DicomVR vr,
            JsonTextReader reader,
            fo.DicomDataset dataset,
            int level
        )
        {
            if (reader.Read( ))
            {
                fo.IO.Buffer.MemoryByteBuffer buffer = null;
                byte[] data   = new byte[0];
                string base64 = (string)reader.Value;


                if (!string.IsNullOrEmpty(base64))
                {
                    buffer = new fo.IO.Buffer.MemoryByteBuffer(System.Convert.FromBase64String(base64));
                }

                if (tag == fo.DicomTag.PixelData && level == 0)
                {
                    dataset.AddOrUpdatePixelData(vr, buffer, fo.DicomTransferSyntax.Parse(TransferSyntaxUID));
                }
                else
                {
                    dataset.AddOrUpdate <fo.IO.Buffer.IByteBuffer> (vr, tag, buffer);
                }
            }
        }
Exemple #3
0
        private void ReadBulkData
        (
            fo.DicomTag tag,
            fo.DicomVR vr,
            JsonTextReader reader,
            fo.DicomDataset dataset,
            int level
        )
        {
            fo.IO.Buffer.BulkDataUriByteBuffer data = null;


            if (reader.Read( ))
            {
                string uri = (string)reader.Value;


                if (!string.IsNullOrEmpty(uri))
                {
                    data = new fo.IO.Buffer.BulkDataUriByteBuffer(uri);
                }

                if (tag == fo.DicomTag.PixelData && level == 0)
                {
                    dataset.AddOrUpdatePixelData(vr, data, fo.DicomTransferSyntax.Parse(TransferSyntaxUID));
                }
                else
                {
                    dataset.AddOrUpdate <fo.IO.Buffer.IByteBuffer> (vr, tag, data);
                }
            }
        }
Exemple #4
0
        protected virtual void WriteVR_Default(fo.DicomDataset ds, fo.DicomElement element, XmlWriter writer)
        {
            fo.DicomVR dicomVr = element.ValueRepresentation;


            for (int index = 0; index < element.Count; index++)
            {
                writer.WriteStartElement(Constants.ATTRIBUTE_VALUE_NAME);

                WriteNumberAttrib(writer, index);

                if (dicomVr.Equals(fo.DicomVR.AT))
                {
                    var    atElement   = ds.Get <fo.DicomElement>    (element.Tag, null);
                    var    tagValue    = atElement.Get <fo.DicomTag> ( );
                    string stringValue = tagValue.ToString("J", null);

                    writer.WriteString(stringValue);
                }
                else
                {
                    writer.WriteString(GetTrimmedString(ds.Get <string> (element.Tag, index, string.Empty)));
                }

                writer.WriteEndElement( );
            }
        }
Exemple #5
0
        /// <summary>
        /// Get VR for given string value.
        /// </summary>
        /// <param name="vr">String representation of VR</param>
        /// <returns>VR</returns>
        public static DicomVR Parse(string vr)
        {
            DicomVR result = TryParse(vr, out bool valid);

            if (!valid)
            {
                throw new DicomDataException($"Unknown VR: '{vr}'");
            }
            return(result);
        }
        /// <summary>
        /// Get VR for given string value.
        /// </summary>
        /// <param name="vr">String representation of VR</param>
        /// <returns>VR</returns>
        public static DicomVR Parse(string vr)
        {
            bool    valid;
            DicomVR result = TryParse(vr, out valid);

            if (!valid)
            {
                throw new DicomDataException(string.Format("Unknown VR: '{0}'", vr));
            }
            return(result);
        }
Exemple #7
0
        /// <summary>
        /// Add or update the image pixel data element in the dataset
        /// </summary>
        /// <param name="vr">DICOM vr of the image pixel. For a PixelData element this value should be either DicomVR.OB or DicomVR.OW DICOM VR.</param>
        /// <param name="pixelData">An <see cref="IByteBuffer"/> that holds the image pixel data </param>
        /// <param name="transferSyntax">A DicomTransferSyntax object of the <paramref name="pixelData"/> parameter.
        /// If parameter is not provided (null), then the default TransferSyntax "ExplicitVRLittleEndian" will be applied to the dataset</param>
        /// <remarks>Use this method whenever you are attaching an external image pixel data to the dataset and provide the proper TransferSyntax</remarks>
        /// <returns>The dataset instance.</returns>
        public DicomDataset AddOrUpdatePixelData(DicomVR vr, IByteBuffer pixelData, DicomTransferSyntax transferSyntax = null)
        {
            this.AddOrUpdate(vr, DicomTag.PixelData, pixelData);

            if (null != transferSyntax)
            {
                InternalTransferSyntax = transferSyntax;
            }

            return(this);
        }
Exemple #8
0
        protected virtual void ReadDefaultVr
        (
            fo.DicomTag tag,
            fo.DicomVR vr,
            JsonTextReader reader,
            fo.DicomDataset dataset,
            int level
        )
        {
            //if VR was the first property we already read the right thing above,
            //otherwise we'll got it from the dictionary. Could it be defined after the value?
            switch (vr.Code)
            {
            case fo.DicomVRCode.SQ:
            {
                ReadVr_SQ(reader, tag, dataset, level);
            }
            break;

            case fo.DicomVRCode.PN:
            {
                ReadVr_PN(reader, tag, dataset);
            }
            break;

            default:
            {
                List <string> values = new List <string> ( );


                while (reader.Read( ) && reader.TokenType == JsonToken.StartArray)
                {
                    while (reader.Read( ) && reader.TokenType != JsonToken.EndArray)
                    {
                        values.Add(System.Convert.ToString(reader.Value));
                    }

                    break;
                }

                if (tag == fo.DicomTag.TransferSyntaxUID)
                {
                    TransferSyntaxUID = values.FirstOrDefault( );
                }

                dataset.AddOrUpdate <string> (vr, tag, values.ToArray( ));
            }
            break;
            }
        }
Exemple #9
0
        private bool MatchVr(fo.DicomItem element)
        {
            fo.DicomVR elementVr = element.ValueRepresentation;
            if (!elementVr.Equals(fo.DicomVR.DA) && !elementVr.Equals(fo.DicomVR.TM) && !elementVr.Equals(fo.DicomVR.DT))
            {
                return(false);
            }

            if (HasWildcardMatching(element.ToString( )))
            {
                return(false);
            }

            return(true);
        }
Exemple #10
0
        protected virtual void WriteVR_Default
        (
            fo.DicomDataset ds,
            fo.DicomElement element,
            JsonWriter writer,
            fo.DicomVR dicomVr
        )
        {
            writer.WritePropertyName(JsonConstants.ValueField);
            writer.WriteStartArray( );

            for (int index = 0; index < element.Count; index++)
            {
                string stringValue = GetTrimmedString(element.Get <string> (index));

                if (_numberBasedVrs.Contains(element.ValueRepresentation.Code))
                {
                    //parse with the greatest type that can handle
                    //need to do that to remove the ' ' around the string
                    if (_decimalBasedVrs.Contains(element.ValueRepresentation.Code))
                    {
                        writer.WriteValue(double.Parse(stringValue, System.Globalization.NumberStyles.Any));
                    }
                    else
                    {
                        writer.WriteValue(long.Parse(stringValue, System.Globalization.NumberStyles.Number));
                    }
                }
                else
                {
                    writer.WriteValue(stringValue);
                }
            }

            writer.WriteEndArray( );
        }
Exemple #11
0
        /// <summary>
        /// Add single DICOM item given by <paramref name="tag"/> and <paramref name="values"/>.
        /// </summary>
        /// <typeparam name="T">Type of added values.</typeparam>
        /// <param name="tag">DICOM tag of the added item.</param>
        /// <param name="values">Values of the added item.</param>
        /// <param name="allowUpdate">True if existing tag can be updated, false if method should throw when trying to add already existing tag.</param>
        /// <returns>The dataset instance.</returns>
        private DicomDataset DoAdd <T>(DicomTag tag, IList <T> values, bool allowUpdate)
        {
            var entry = DicomDictionary.Default[tag];

            if (entry == null)
            {
                throw new DicomDataException(
                          "Tag {0} not found in DICOM dictionary. Only dictionary tags may be added implicitly to the dataset.",
                          tag);
            }

            DicomVR vr = null;

            if (values != null)
            {
                vr = entry.ValueRepresentations.FirstOrDefault(x => x.ValueType == typeof(T));
            }
            if (vr == null)
            {
                vr = entry.ValueRepresentations.First();
            }

            return(DoAdd(vr, tag, values, allowUpdate));
        }
Exemple #12
0
        /// <summary>
        /// Add single DICOM item given by <paramref name="vr"/>, <paramref name="tag"/> and <paramref name="values"/>.
        /// </summary>
        /// <typeparam name="T">Type of added values.</typeparam>
        /// <param name="vr">DICOM vr of the added item. Use when setting a private element.</param>
        /// <param name="tag">DICOM tag of the added item.</param>
        /// <param name="values">Values of the added item.</param>
        /// <param name="allowUpdate">True if existing tag can be updated, false if method should throw when trying to add already existing tag.</param>
        /// <remarks>No validation is performed on the <paramref name="vr"/> matching the element <paramref name="tag"/>
        /// This method is useful when adding a private tag and need to explicitly set the VR of the created element.
        /// </remarks>
        /// <returns>The dataset instance.</returns>
        private DicomDataset DoAdd <T>(DicomVR vr, DicomTag tag, IList <T> values, bool allowUpdate)
        {
            if (vr == DicomVR.AE)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomApplicationEntity(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomApplicationEntity(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.AS)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomAgeString(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomAgeString(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.AT)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomAttributeTag(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(DicomTag))
                {
                    return(DoAdd(new DicomAttributeTag(tag, values.Cast <DicomTag>().ToArray()), allowUpdate));
                }

                IEnumerable <DicomTag> parsedValues;
                if (ParseVrValueFromString(values, tag.DictionaryEntry.ValueMultiplicity, DicomTag.Parse, out parsedValues))
                {
                    return(DoAdd(new DicomAttributeTag(tag, parsedValues.ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.CS)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomCodeString(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomCodeString(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
                if (typeof(T).GetTypeInfo().IsEnum)
                {
                    return(DoAdd(new DicomCodeString(tag, values.Select(x => x.ToString()).ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.DA)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomDate(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(DateTime))
                {
                    return(DoAdd(new DicomDate(tag, values.Cast <DateTime>().ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(DicomDateRange))
                {
                    return
                        (DoAdd(new DicomDate(tag, values.Cast <DicomDateRange>().FirstOrDefault() ?? new DicomDateRange()), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomDate(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.DS)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomDecimalString(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(decimal))
                {
                    return(DoAdd(new DicomDecimalString(tag, values.Cast <decimal>().ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomDecimalString(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.DT)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomDateTime(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(DateTime))
                {
                    return(DoAdd(new DicomDateTime(tag, values.Cast <DateTime>().ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(DicomDateRange))
                {
                    return
                        (DoAdd(
                             new DicomDateTime(
                                 tag,
                                 values.Cast <DicomDateRange>().FirstOrDefault() ?? new DicomDateRange()), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomDateTime(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.FD)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomFloatingPointDouble(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(double))
                {
                    return(DoAdd(new DicomFloatingPointDouble(tag, values.Cast <double>().ToArray()), allowUpdate));
                }

                IEnumerable <double> parsedValues;
                if (ParseVrValueFromString(values, tag.DictionaryEntry.ValueMultiplicity, double.Parse, out parsedValues))
                {
                    return(DoAdd(new DicomFloatingPointDouble(tag, parsedValues.ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.FL)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomFloatingPointSingle(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(float))
                {
                    return(DoAdd(new DicomFloatingPointSingle(tag, values.Cast <float>().ToArray()), allowUpdate));
                }

                IEnumerable <float> parsedValues;
                if (ParseVrValueFromString(values, tag.DictionaryEntry.ValueMultiplicity, float.Parse, out parsedValues))
                {
                    return(DoAdd(new DicomFloatingPointSingle(tag, parsedValues.ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.IS)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomIntegerString(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(int))
                {
                    return(DoAdd(new DicomIntegerString(tag, values.Cast <int>().ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomIntegerString(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.LO)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomLongString(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomLongString(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.LT)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomLongText(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomLongText(tag, values.Cast <string>().First()), allowUpdate));
                }
            }

            if (vr == DicomVR.OB)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomOtherByte(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(byte))
                {
                    return(DoAdd(new DicomOtherByte(tag, values.Cast <byte>().ToArray()), allowUpdate));
                }

                if (typeof(T) == typeof(IByteBuffer) && values.Count == 1)
                {
                    return(DoAdd(new DicomOtherByte(tag, (IByteBuffer)values[0]), allowUpdate));
                }
            }

            if (vr == DicomVR.OD)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomOtherDouble(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(double))
                {
                    return(DoAdd(new DicomOtherDouble(tag, values.Cast <double>().ToArray()), allowUpdate));
                }

                if (typeof(T) == typeof(IByteBuffer) && values.Count == 1)
                {
                    return(DoAdd(new DicomOtherDouble(tag, (IByteBuffer)values[0]), allowUpdate));
                }
            }

            if (vr == DicomVR.OF)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomOtherFloat(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(float))
                {
                    return(DoAdd(new DicomOtherFloat(tag, values.Cast <float>().ToArray()), allowUpdate));
                }

                if (typeof(T) == typeof(IByteBuffer) && values.Count == 1)
                {
                    return(DoAdd(new DicomOtherFloat(tag, (IByteBuffer)values[0]), allowUpdate));
                }
            }

            if (vr == DicomVR.OL)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomOtherLong(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(uint))
                {
                    return(DoAdd(new DicomOtherLong(tag, values.Cast <uint>().ToArray()), allowUpdate));
                }

                if (typeof(T) == typeof(IByteBuffer) && values.Count == 1)
                {
                    return(DoAdd(new DicomOtherLong(tag, (IByteBuffer)values[0]), allowUpdate));
                }
            }

            if (vr == DicomVR.OW)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomOtherWord(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(ushort))
                {
                    return(DoAdd(new DicomOtherWord(tag, values.Cast <ushort>().ToArray()), allowUpdate));
                }

                if (typeof(T) == typeof(IByteBuffer) && values.Count == 1)
                {
                    return(DoAdd(new DicomOtherWord(tag, (IByteBuffer)values[0]), allowUpdate));
                }
            }

            if (vr == DicomVR.PN)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomPersonName(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomPersonName(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.SH)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomShortString(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomShortString(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.SL)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomSignedLong(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(int))
                {
                    return(DoAdd(new DicomSignedLong(tag, values.Cast <int>().ToArray()), allowUpdate));
                }

                IEnumerable <int> parsedValues;
                if (ParseVrValueFromString(values, tag.DictionaryEntry.ValueMultiplicity, int.Parse, out parsedValues))
                {
                    return(DoAdd(new DicomSignedLong(tag, parsedValues.ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.SQ)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomSequence(tag), allowUpdate));
                }
                if (typeof(T) == typeof(DicomContentItem))
                {
                    return(DoAdd(new DicomSequence(tag, values.Cast <DicomContentItem>().Select(x => x.Dataset).ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(DicomDataset) || typeof(T) == typeof(DicomCodeItem) ||
                    typeof(T) == typeof(DicomMeasuredValue) || typeof(T) == typeof(DicomReferencedSOP))
                {
                    return(DoAdd(new DicomSequence(tag, values.Cast <DicomDataset>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.SS)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomSignedShort(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(short))
                {
                    return(DoAdd(new DicomSignedShort(tag, values.Cast <short>().ToArray()), allowUpdate));
                }

                IEnumerable <short> parsedValues;
                if (ParseVrValueFromString(values, tag.DictionaryEntry.ValueMultiplicity, short.Parse, out parsedValues))
                {
                    return(DoAdd(new DicomSignedShort(tag, parsedValues.ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.ST)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomShortText(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomShortText(tag, values.Cast <string>().First()), allowUpdate));
                }
            }

            if (vr == DicomVR.TM)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomTime(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(DateTime))
                {
                    return(DoAdd(new DicomTime(tag, values.Cast <DateTime>().ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(DicomDateRange))
                {
                    return
                        (DoAdd(new DicomTime(tag, values.Cast <DicomDateRange>().FirstOrDefault() ?? new DicomDateRange()), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomTime(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.UC)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomUnlimitedCharacters(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomUnlimitedCharacters(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.UI)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomUniqueIdentifier(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomUniqueIdentifier(tag, values.Cast <string>().ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(DicomUID))
                {
                    return(DoAdd(new DicomUniqueIdentifier(tag, values.Cast <DicomUID>().ToArray()), allowUpdate));
                }
                if (typeof(T) == typeof(DicomTransferSyntax))
                {
                    return(DoAdd(new DicomUniqueIdentifier(tag, values.Cast <DicomTransferSyntax>().ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.UL)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomUnsignedLong(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(uint))
                {
                    return(DoAdd(new DicomUnsignedLong(tag, values.Cast <uint>().ToArray()), allowUpdate));
                }

                IEnumerable <uint> parsedValues;
                if (ParseVrValueFromString(values, tag.DictionaryEntry.ValueMultiplicity, uint.Parse, out parsedValues))
                {
                    return(DoAdd(new DicomUnsignedLong(tag, parsedValues.ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.UN)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomUnknown(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(byte))
                {
                    return(DoAdd(new DicomUnknown(tag, values.Cast <byte>().ToArray()), allowUpdate));
                }

                if (typeof(T) == typeof(IByteBuffer) && values.Count == 1)
                {
                    return(DoAdd(new DicomUnknown(tag, (IByteBuffer)values[0]), allowUpdate));
                }
            }

            if (vr == DicomVR.UR)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomUniversalResource(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomUniversalResource(tag, values.Cast <string>().First()), allowUpdate));
                }
            }

            if (vr == DicomVR.US)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomUnsignedShort(tag, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(ushort))
                {
                    return(DoAdd(new DicomUnsignedShort(tag, values.Cast <ushort>().ToArray()), allowUpdate));
                }

                IEnumerable <ushort> parsedValues;
                if (ParseVrValueFromString(values, tag.DictionaryEntry.ValueMultiplicity, ushort.Parse, out parsedValues))
                {
                    return(DoAdd(new DicomUnsignedShort(tag, parsedValues.ToArray()), allowUpdate));
                }
            }

            if (vr == DicomVR.UT)
            {
                if (values == null)
                {
                    return(DoAdd(new DicomUnlimitedText(tag, DicomEncoding.Default, EmptyBuffer.Value), allowUpdate));
                }
                if (typeof(T) == typeof(string))
                {
                    return(DoAdd(new DicomUnlimitedText(tag, values.Cast <string>().First()), allowUpdate));
                }
            }

            throw new InvalidOperationException(
                      $"Unable to create DICOM element of type {vr.Code} with values of type {typeof(T)}");
        }
Exemple #13
0
 /// <summary>
 /// Add or update a single DICOM item given by <paramref name="vr"/>, <paramref name="tag"/> and <paramref name="values"/>.
 /// </summary>
 /// <typeparam name="T">Type of added values.</typeparam>
 /// <param name="vr">DICOM vr of the added item. Use when setting a private element.</param>
 /// <param name="tag">DICOM tag of the added item.</param>
 /// <param name="values">Values of the added item.</param>
 /// <remarks>No validation is performed on the <paramref name="vr"/> matching the element <paramref name="tag"/>
 /// This method is useful when adding a private tag and need to explicitly set the VR of the created element.
 /// </remarks>
 /// <returns>The dataset instance.</returns>
 public DicomDataset AddOrUpdate <T>(DicomVR vr, DicomTag tag, params T[] values)
 {
     return(DoAdd(vr, tag, values, true));
 }
Exemple #14
0
        protected virtual void WriteDicomAttribute
        (
            fo.DicomDataset ds,
            fo.DicomItem element,
            XmlWriter writer
        )
        {
            //group length element must not be written
            if (null == element || element.Tag.Element == 0x0000)
            {
                return;
            }

            fo.DicomVR dicomVr = element.ValueRepresentation;


            writer.WriteStartElement(Constants.ATTRIBUTE_NAME);

            writer.WriteAttributeString(Constants.ATTRIBUTE_KEYWORD, element.Tag.DictionaryEntry.Keyword);
            writer.WriteAttributeString(Constants.ATTRIBUTE_TAG, element.Tag.ToString("J", null));
            writer.WriteAttributeString(Constants.ATTRIBUTE_VR, element.ValueRepresentation.Code.ToUpper( ));

            if (element.Tag.IsPrivate && null != element.Tag.PrivateCreator)
            {
                writer.WriteAttributeString(Constants.ATTRIBUTE_PRIVATE_CREATOR, element.Tag.PrivateCreator.Creator);
            }

            switch (element.ValueRepresentation.Code)
            {
            case fo.DicomVRCode.SQ:
            {
                WriteVR_SQ((fo.DicomSequence)element, writer);
            }
            break;

            case fo.DicomVRCode.PN:
            {
                WriteVR_PN((fo.DicomElement)element, writer);
            }
            break;

            case fo.DicomVRCode.OB:
            case fo.DicomVRCode.OD:
            case fo.DicomVRCode.OF:
            case fo.DicomVRCode.OW:
            case fo.DicomVRCode.OL:
            case fo.DicomVRCode.UN:
            {
                WriteVR_Binary(element, writer);
            }
            break;

            default:
            {
                WriteVR_Default(ds, (fo.DicomElement)element, writer);
            }
            break;
            }

            writer.WriteEndElement( );
        }
        private void ReadDictionaryXML()
        {
            DicomDictionary dict = _dict;

            XDocument xdoc = XDocument.Load(_stream);

            IEnumerable <XElement> xdicts;

            if (xdoc.Root.Name == "dictionaries")
            {
                xdicts = xdoc.Root.Elements("dictionary");
            }
            else
            {
                XElement xdict = xdoc.Element("dictionary");
                if (xdict == null)
                {
                    throw new DicomDataException("Expected <dictionary> root node in DICOM dictionary.");
                }

                List <XElement> dicts = new List <XElement>();
                dicts.Add(xdict);
                xdicts = dicts;
            }

            foreach (var xdict in xdicts)
            {
                XAttribute creator = xdict.Attribute("creator");
                if (creator != null && !String.IsNullOrEmpty(creator.Value))
                {
                    dict = _dict[_dict.GetPrivateCreator(creator.Value)];
                }
                else
                {
                    dict = _dict;
                }

                foreach (XElement xentry in xdict.Elements("tag"))
                {
                    string name = xentry.Value ?? "Unknown";

                    string keyword = String.Empty;
                    if (xentry.Attribute("keyword") != null)
                    {
                        keyword = xentry.Attribute("keyword").Value;
                    }

                    List <DicomVR> vrs = new List <DicomVR>();
                    XAttribute     xvr = xentry.Attribute("vr");
                    if (xvr != null && !String.IsNullOrEmpty(xvr.Value))
                    {
                        string[] vra = xvr.Value.Split('_', '/', '\\', ',', '|');
                        foreach (string vr in vra)
                        {
                            vrs.Add(DicomVR.Parse(vr));
                        }
                    }
                    else
                    {
                        vrs.Add(DicomVR.NONE);
                    }

                    DicomVM vm = DicomVM.Parse(xentry.Attribute("vm").Value);

                    bool       retired  = false;
                    XAttribute xretired = xentry.Attribute("retired");
                    if (xretired != null && !String.IsNullOrEmpty(xretired.Value) && Boolean.Parse(xretired.Value))
                    {
                        retired = true;
                    }

                    string group   = xentry.Attribute("group").Value;
                    string element = xentry.Attribute("element").Value;
                    if (group.ToLower().Contains("x") || element.ToLower().Contains("x"))
                    {
                        DicomMaskedTag tag = DicomMaskedTag.Parse(group, element);
                        tag.Tag.PrivateCreator = dict.PrivateCreator;
                        dict.Add(new DicomDictionaryEntry(tag, name, keyword, vm, retired, vrs.ToArray()));
                    }
                    else
                    {
                        DicomTag tag = DicomTag.Parse(group + "," + element);
                        tag.PrivateCreator = dict.PrivateCreator;
                        dict.Add(new DicomDictionaryEntry(tag, name, keyword, vm, retired, vrs.ToArray()));
                    }
                }
            }
        }
Exemple #16
0
 /// <summary>
 /// Add single DICOM item given by <paramref name="vr"/>, <paramref name="tag"/> and <paramref name="values"/>.
 /// </summary>
 /// <typeparam name="T">Type of added values.</typeparam>
 /// <param name="vr">DICOM vr of the added item. Use when setting a private element.</param>
 /// <param name="tag">DICOM tag of the added item.</param>
 /// <param name="values">Values of the added item.</param>
 /// <remarks>No validation is performed on the <paramref name="vr"/> matching the element <paramref name="tag"/>
 /// This method is useful when adding a private tag and need to explicitly set the VR of the created element.
 /// </remarks>
 /// <returns>The dataset instance.</returns>
 /// <exception cref="ArgumentException">If tag already exists in dataset.</exception>
 public DicomDataset Add <T>(DicomVR vr, DicomTag tag, params T[] values)
 {
     return(DoAdd(vr, tag, values, false));
 }
Exemple #17
0
		/// <summary>
		/// Try to get VR for given string value.
		/// </summary>
		/// <param name="vr">String representation of VR</param>
		/// <param name="result">VR code</param>
		/// <returns>true if VR was successfully parsed, false otherwise</returns>
		public static bool TryParse(string vr, out DicomVR result) {
			bool valid;
			result = TryParse(vr, out valid);
			return valid;
		}
 public DicomValidationException(string content, DicomVR vr, string message)
     : base(message)
 {
     Content = content;
     VR      = vr;
 }
 public static bool IsBinaryVR(fo.DicomVR dicomVr)
 {
     return(dicomVr == fo.DicomVR.OB || dicomVr == fo.DicomVR.OD ||
            dicomVr == fo.DicomVR.OF || dicomVr == fo.DicomVR.OW ||
            dicomVr == fo.DicomVR.OL || dicomVr == fo.DicomVR.UN);
 }
Exemple #20
0
        public void Parse_OF_ReturnsVRObject()
        {
            var actual = DicomVR.Parse("OF");

            Assert.IsType <DicomVR>(actual);
        }
Exemple #21
0
        public DicomDataset Add <T>(DicomTag tag, params T[] values)
        {
            var entry = DicomDictionary.Default[tag];

            if (entry == null)
            {
                throw new DicomDataException("Tag {0} not found in DICOM dictionary. Only dictionary tags may be added implicitly to the dataset.", tag);
            }

            DicomVR vr = null;

            if (values != null)
            {
                vr = entry.ValueRepresentations.FirstOrDefault(x => x.ValueType == typeof(T));
            }
            if (vr == null)
            {
                vr = entry.ValueRepresentations.First();
            }

            if (vr == DicomVR.AE)
            {
                if (values == null)
                {
                    return(Add(new DicomApplicationEntity(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomApplicationEntity(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.AS)
            {
                if (values == null)
                {
                    return(Add(new DicomAgeString(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomAgeString(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.AT)
            {
                if (values == null)
                {
                    return(Add(new DicomAttributeTag(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(DicomTag))
                {
                    return(Add(new DicomAttributeTag(tag, values.Cast <DicomTag>().ToArray())));
                }
            }

            if (vr == DicomVR.CS)
            {
                if (values == null)
                {
                    return(Add(new DicomCodeString(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomCodeString(tag, values.Cast <string>().ToArray())));
                }
                if (typeof(T).IsEnum)
                {
                    return(Add(new DicomCodeString(tag, values.Select(x => x.ToString()).ToArray())));
                }
            }

            if (vr == DicomVR.DA)
            {
                if (values == null)
                {
                    return(Add(new DicomDate(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(DateTime))
                {
                    return(Add(new DicomDate(tag, values.Cast <DateTime>().ToArray())));
                }
                if (typeof(T) == typeof(DicomDateRange))
                {
                    return(Add(new DicomDate(tag, values.Cast <DicomDateRange>().FirstOrDefault() ?? new DicomDateRange())));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomDate(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.DS)
            {
                if (values == null)
                {
                    return(Add(new DicomDecimalString(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(decimal))
                {
                    return(Add(new DicomDecimalString(tag, values.Cast <decimal>().ToArray())));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomDecimalString(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.DT)
            {
                if (values == null)
                {
                    return(Add(new DicomDateTime(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(DateTime))
                {
                    return(Add(new DicomDateTime(tag, values.Cast <DateTime>().ToArray())));
                }
                if (typeof(T) == typeof(DicomDateRange))
                {
                    return(Add(new DicomDateTime(tag, values.Cast <DicomDateRange>().FirstOrDefault() ?? new DicomDateRange())));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomDateTime(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.FD)
            {
                if (values == null)
                {
                    return(Add(new DicomFloatingPointDouble(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(double))
                {
                    return(Add(new DicomFloatingPointDouble(tag, values.Cast <double>().ToArray())));
                }
            }

            if (vr == DicomVR.FL)
            {
                if (values == null)
                {
                    return(Add(new DicomFloatingPointSingle(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(float))
                {
                    return(Add(new DicomFloatingPointSingle(tag, values.Cast <float>().ToArray())));
                }
            }

            if (vr == DicomVR.IS)
            {
                if (values == null)
                {
                    return(Add(new DicomIntegerString(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(int))
                {
                    return(Add(new DicomIntegerString(tag, values.Cast <int>().ToArray())));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomIntegerString(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.LO)
            {
                if (values == null)
                {
                    return(Add(new DicomLongString(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomLongString(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.LT)
            {
                if (values == null)
                {
                    return(Add(new DicomLongText(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomLongText(tag, values.Cast <string>().First())));
                }
            }

            if (vr == DicomVR.OB)
            {
                if (values == null)
                {
                    return(Add(new DicomOtherByte(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(byte))
                {
                    return(Add(new DicomOtherByte(tag, values.Cast <byte>().ToArray())));
                }
            }

            if (vr == DicomVR.OD)
            {
                if (values == null)
                {
                    return(Add(new DicomOtherDouble(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(double))
                {
                    return(Add(new DicomOtherDouble(tag, values.Cast <double>().ToArray())));
                }
            }

            if (vr == DicomVR.OF)
            {
                if (values == null)
                {
                    return(Add(new DicomOtherFloat(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(float))
                {
                    return(Add(new DicomOtherFloat(tag, values.Cast <float>().ToArray())));
                }
            }

            if (vr == DicomVR.OW)
            {
                if (values == null)
                {
                    return(Add(new DicomOtherWord(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(ushort))
                {
                    return(Add(new DicomOtherWord(tag, values.Cast <ushort>().ToArray())));
                }
            }

            if (vr == DicomVR.PN)
            {
                if (values == null)
                {
                    return(Add(new DicomPersonName(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomPersonName(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.SH)
            {
                if (values == null)
                {
                    return(Add(new DicomShortString(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomShortString(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.SL)
            {
                if (values == null)
                {
                    return(Add(new DicomSignedLong(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(int))
                {
                    return(Add(new DicomSignedLong(tag, values.Cast <int>().ToArray())));
                }
            }

            if (vr == DicomVR.SQ)
            {
                if (values == null)
                {
                    return(Add(new DicomSequence(tag)));
                }
                if (typeof(T) == typeof(DicomContentItem))
                {
                    return(Add(new DicomSequence(tag, values.Cast <DicomContentItem>().Select(x => x.Dataset).ToArray())));
                }
                if (typeof(T) == typeof(DicomDataset) || typeof(T) == typeof(DicomCodeItem) || typeof(T) == typeof(DicomMeasuredValue) || typeof(T) == typeof(DicomReferencedSOP))
                {
                    return(Add(new DicomSequence(tag, values.Cast <DicomDataset>().ToArray())));
                }
            }

            if (vr == DicomVR.SS)
            {
                if (values == null)
                {
                    return(Add(new DicomSignedShort(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(short))
                {
                    return(Add(new DicomSignedShort(tag, values.Cast <short>().ToArray())));
                }
            }

            if (vr == DicomVR.ST)
            {
                if (values == null)
                {
                    return(Add(new DicomShortText(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomShortText(tag, values.Cast <string>().First())));
                }
            }

            if (vr == DicomVR.TM)
            {
                if (values == null)
                {
                    return(Add(new DicomTime(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(DateTime))
                {
                    return(Add(new DicomTime(tag, values.Cast <DateTime>().ToArray())));
                }
                if (typeof(T) == typeof(DicomDateRange))
                {
                    return(Add(new DicomTime(tag, values.Cast <DicomDateRange>().FirstOrDefault() ?? new DicomDateRange())));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomTime(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.UC)
            {
                if (values == null)
                {
                    return(Add(new DicomUnlimitedCharacters(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomUnlimitedCharacters(tag, values.Cast <string>().ToArray())));
                }
            }

            if (vr == DicomVR.UI)
            {
                if (values == null)
                {
                    return(Add(new DicomUniqueIdentifier(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomUniqueIdentifier(tag, values.Cast <string>().ToArray())));
                }
                if (typeof(T) == typeof(DicomUID))
                {
                    return(Add(new DicomUniqueIdentifier(tag, values.Cast <DicomUID>().ToArray())));
                }
                if (typeof(T) == typeof(DicomTransferSyntax))
                {
                    return(Add(new DicomUniqueIdentifier(tag, values.Cast <DicomTransferSyntax>().ToArray())));
                }
            }

            if (vr == DicomVR.UL)
            {
                if (values == null)
                {
                    return(Add(new DicomUnsignedLong(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(uint))
                {
                    return(Add(new DicomUnsignedLong(tag, values.Cast <uint>().ToArray())));
                }
            }

            if (vr == DicomVR.UN)
            {
                if (values == null)
                {
                    return(Add(new DicomUnknown(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(byte))
                {
                    return(Add(new DicomUnknown(tag, values.Cast <byte>().ToArray())));
                }
            }

            if (vr == DicomVR.UR)
            {
                if (values == null)
                {
                    return(Add(new DicomUniversalResource(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomUniversalResource(tag, values.Cast <string>().First())));
                }
            }

            if (vr == DicomVR.US)
            {
                if (values == null)
                {
                    return(Add(new DicomUnsignedShort(tag, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(ushort))
                {
                    return(Add(new DicomUnsignedShort(tag, values.Cast <ushort>().ToArray())));
                }
            }

            if (vr == DicomVR.UT)
            {
                if (values == null)
                {
                    return(Add(new DicomUnlimitedText(tag, DicomEncoding.Default, EmptyBuffer.Value)));
                }
                if (typeof(T) == typeof(string))
                {
                    return(Add(new DicomUnlimitedText(tag, values.Cast <string>().First())));
                }
            }

            throw new InvalidOperationException(String.Format("Unable to create DICOM element of type {0} with values of type {1}", vr.Code, typeof(T).ToString()));
        }
Exemple #22
0
        private void ReadElement
        (
            fo.DicomDataset ds,
            XElement element,
            fo.DicomTag tag,
            fo.DicomVR dicomVr,
            int level
        )
        {
            if (dicomVr == fo.DicomVR.PN)
            {
                string personNameValue = "";

                foreach (var personNameElementValue in element.Elements( ).OrderBy(n => n.Attribute(Constants.ATTRIBUTE_NUMBER)))
                {
                    foreach (var personNameComponent in personNameElementValue.Elements( ))
                    {
                        if (personNameComponent.Name == Utilities.PersonNameComponents.PN_COMP_ALPHABETIC ||
                            personNameComponent.Name == Utilities.PersonNameComponents.PN_COMP_IDEOGRAPHIC ||
                            personNameComponent.Name == Utilities.PersonNameComponents.PN_COMP_PHONETIC)
                        {
                            personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Family);
                            personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Given);
                            personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Midlle);
                            personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Prefix);
                            personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Suffix, true);

                            personNameValue = personNameValue.TrimEnd('^');    // extra cleanup

                            personNameValue += "=";
                        }
                    }

                    personNameValue = personNameValue.TrimEnd('=');

                    personNameValue += "\\";
                }

                personNameValue = personNameValue.TrimEnd('\\');
                ds.AddOrUpdate <string> (dicomVr, tag, personNameValue);
            }
            else if (Utilities.IsBinaryVR(dicomVr))
            {
                var dataElement = element.Elements( ).OfType <XElement> ( ).FirstOrDefault( );

                if (null != dataElement)
                {
                    fo.IO.Buffer.IByteBuffer data;


                    if (dataElement.Name == Constants.ELEMENT_BULKDATA)
                    {
                        string uri = dataElement.Attribute(Constants.ATTRIBUTE_BULKDATAURI).Value;


                        data = new fo.IO.Buffer.BulkDataUriByteBuffer(uri);
                    }
                    else
                    {
                        var base64 = System.Convert.FromBase64String(dataElement.Value);


                        data = new fo.IO.Buffer.MemoryByteBuffer(base64);
                    }

                    if (tag == fo.DicomTag.PixelData && level == 0)
                    {
                        ds.AddOrUpdatePixelData(dicomVr, data, TransferSyntax);
                    }
                    else
                    {
                        ds.AddOrUpdate <fo.IO.Buffer.IByteBuffer> (dicomVr, tag, data);
                    }
                }
            }
            else
            {
                var values = ReadValue(element);

                if (tag == fo.DicomTag.TransferSyntaxUID)
                {
                    TransferSyntax = fo.DicomTransferSyntax.Parse(values.FirstOrDefault( ));
                }

                ds.AddOrUpdate <string> (dicomVr, tag, values.ToArray( ));
            }
        }
Exemple #23
0
        protected virtual void WriteDicomItem
        (
            fo.DicomDataset ds,
            fo.DicomItem element,
            JsonWriter writer
        )
        {
            //group length element must not be written
            if (null == element || element.Tag.Element == 0x0000)
            {
                return;
            }

            fo.DicomVR dicomVr = element.ValueRepresentation;

            writer.WritePropertyName(element.Tag.Group.ToString("X4") + element.Tag.Element.ToString("X4"));

            writer.WriteStartObject( );


            //writer.WritePropertyName ( "temp" );
            //writer.WriteValue ( element.Tag.DictionaryEntry.Keyword );

            writer.WritePropertyName("vr");
            writer.WriteValue(element.ValueRepresentation.Code);


            switch (element.ValueRepresentation.Code)
            {
            case fo.DicomVRCode.SQ:
            {
                WriteVR_SQ((fo.DicomSequence)element, writer);
            }
            break;

            case fo.DicomVRCode.PN:
            {
                WriteVR_PN((fo.DicomElement)element, writer);
            }
            break;

            case fo.DicomVRCode.OB:
            case fo.DicomVRCode.OD:
            case fo.DicomVRCode.OF:
            case fo.DicomVRCode.OW:
            case fo.DicomVRCode.OL:
            case fo.DicomVRCode.UN:
            {
                WriteVR_Binary(element, writer);
            }
            break;

            default:
            {
                WriteVR_Default(ds, (fo.DicomElement)element, writer, dicomVr);
            }
            break;
            }

            writer.WriteEndObject( );
        }