예제 #1
0
        public override IList <SupportedSop> GetSupportedSopClasses()
        {
            if (_list == null)
            {
                _list = new List <SupportedSop>();

                var storageAbstractSyntaxList = new List <SopClass>();

                storageAbstractSyntaxList.Add(SopClass.MrImageStorage);
                storageAbstractSyntaxList.Add(SopClass.CtImageStorage);
                storageAbstractSyntaxList.Add(SopClass.SecondaryCaptureImageStorage);
                // Add SupportedSopCless here

                foreach (var abstractSyntax in storageAbstractSyntaxList)
                {
                    var supportedSop = new SupportedSop {
                        SopClass = abstractSyntax
                    };
                    supportedSop.AddSyntax(TransferSyntax.ExplicitVrLittleEndian);
                    supportedSop.AddSyntax(TransferSyntax.ImplicitVrLittleEndian);
                    _list.Add(supportedSop);
                }
            }

            return(_list);
        }
예제 #2
0
        private static IEnumerable <SupportedSop> GetSupportedSops()
        {
            var extendedConfiguration = LocalDicomServer.GetExtendedConfiguration();

            foreach (SopClass sopClass in GetSopClasses(extendedConfiguration.ImageStorageSopClassUids))
            {
                var supportedSop = new SupportedSop
                {
                    SopClass = sopClass
                };

                supportedSop.AddSyntax(TransferSyntax.ExplicitVrLittleEndian);
                supportedSop.AddSyntax(TransferSyntax.ImplicitVrLittleEndian);

                foreach (TransferSyntax transferSyntax in GetTransferSyntaxes(extendedConfiguration.StorageTransferSyntaxUids))
                {
                    if (transferSyntax.DicomUid.UID != TransferSyntax.ExplicitVrLittleEndianUid &&
                        transferSyntax.DicomUid.UID != TransferSyntax.ImplicitVrLittleEndianUid)
                    {
                        supportedSop.AddSyntax(transferSyntax);
                    }
                }

                yield return(supportedSop);
            }
        }
예제 #3
0
        public IList <SupportedSop> GetStroageSupportedSopClasses()
        {
            var list = new List <SupportedSop>();

            var storageAbstractSyntaxList = new List <SopClass>();

            using (var ctx = new PacsContext())
            {
                storageAbstractSyntaxList.AddRange(
                    ctx.SupportedSopClasses.ToList().Select(
                        sopClass => SopClass.GetSopClass(sopClass.SopClassUid)));
            }

            foreach (var abstractSyntax in storageAbstractSyntaxList)
            {
                var supportedSop = new SupportedSop {
                    SopClass = abstractSyntax
                };
                supportedSop.AddSyntax(TransferSyntax.ExplicitVrLittleEndian);
                supportedSop.AddSyntax(TransferSyntax.ImplicitVrLittleEndian);
                list.Add(supportedSop);
            }

            return(list);
        }
예제 #4
0
        /// <summary>
        /// Load a list of preferred SOP Classes and Transfer Syntaxes for a Device.
        /// </summary>
        /// <param name="read">A read context to read from the database.</param>
        public void LoadPreferredSyntaxes(IPersistenceContext read)
        {
            var select = read.GetBroker <IDevicePreferredTransferSyntaxEntityBroker>();

            // Setup the select parameters.
            var criteria = new DevicePreferredTransferSyntaxSelectCriteria();

            criteria.DeviceKey.EqualTo(_remoteDevice.GetKey());

            IList <DevicePreferredTransferSyntax> list = select.Find(criteria);

            // Translate the list returned into the database into a list that is supported by the Storage SCU Component
            var sopList = new List <SupportedSop>();

            foreach (DevicePreferredTransferSyntax preferred in list)
            {
                var sop = new SupportedSop
                {
                    SopClass = SopClass.GetSopClass(preferred.GetServerSopClass().SopClassUid)
                };
                sop.AddSyntax(TransferSyntax.GetTransferSyntax(preferred.GetServerTransferSyntax().Uid));

                sopList.Add(sop);
            }

            SetPreferredSyntaxList(sopList);
        }
        /// <summary>
        /// Load a list of preferred SOP Classes and Transfer Syntaxes for a Device.
        /// </summary>
        /// <param name="request">A read context to read from the database.</param>
        public void LoadPreferredSyntaxes(DicomSendRequest request)
        {
            _sendRequest = request;

            // TODO (CR Jun 2012): Just set it since it's not an event?

            // Add a delegate to do the actual selection of the contexts;
            PresentationContextSelectionDelegate += SelectPresentationContext;

            var dic = new Dictionary <SopClass, SupportedSop>();

            foreach (var storageInstance in StorageInstanceList)
            {
                // skip if failed in LoadStorageInstanceInfo, ie file not found
                if (storageInstance.SendStatus == DicomStatuses.ProcessingFailure)
                {
                    continue;
                }

                storageInstance.LoadInfo();
                SupportedSop sop;
                if (!dic.TryGetValue(storageInstance.SopClass, out sop))
                {
                    sop = new SupportedSop
                    {
                        SopClass = storageInstance.SopClass
                    };

                    if (request.CompressionType == CompressionType.JpegLossless)
                    {
                        sop.AddSyntax(TransferSyntax.JpegLosslessNonHierarchicalFirstOrderPredictionProcess14SelectionValue1);
                    }
                    else if (request.CompressionType == CompressionType.Rle)
                    {
                        sop.AddSyntax(TransferSyntax.RleLossless);
                    }
                    else if (request.CompressionType == CompressionType.J2KLossy)
                    {
                        sop.AddSyntax(TransferSyntax.Jpeg2000ImageCompression);
                    }
                    else if (request.CompressionType == CompressionType.J2KLossless)
                    {
                        sop.AddSyntax(TransferSyntax.Jpeg2000ImageCompressionLosslessOnly);
                    }
                    else if (request.CompressionType == CompressionType.JpegLossy)
                    {
                        sop.AddSyntax(TransferSyntax.JpegBaselineProcess1);
                        sop.AddSyntax(TransferSyntax.JpegExtendedProcess24);
                    }
                    dic.Add(storageInstance.SopClass, sop);
                }
            }

            SetPreferredSyntaxList(dic.Values);
        }