Beispiel #1
0
        public MainForm()
        {
            InitializeComponent();
            FormClosing += MainForm_FormClosing;
            cfind        = new CFind
            {
                ImplementationClass       = ConstDefineValues.CONFIGURATION_IMPLEMENTATIONCLASS,
                ProtocolVersion           = ConstDefineValues.CONFIGURATION_PROTOCOLVERSION,
                ImplementationVersionName = ConstDefineValues.CONFIGURATION_IMPLEMENTATIONVERSIONNAME
            };
            cfind.Status       += cfind_Status;
            cfind.FindComplete += cfind_FindComplete;
            cfind.MoveComplete += cfind_MoveComplete;

            server = new DicomServer
            {
                AETitle = "LEAD_SERVER",
                Address = IPAddress.Parse(Convert.ToString("192.168.3.29")),
                Port    = 104,
                Timeout = 30,
                IpType  = DicomNetIpTypeFlags.Ipv4
            };
            DoCreateDicomDirectory();
            Application.Exit();
        }
Beispiel #2
0
        public IEnumerable <CFindStudyIOD> GetStudyUids(string patientId)
        {
            var query     = CFind.CreateStudyQuery(patientId);
            var studyUids = _scu.GetResponse(query, _scp) // Studies
                            .Where(r => r.Status == (ushort)Status.PENDING)
                            .Where(r => r.HasData);

            return(studyUids.Select(r => r.GetIOD <CFindStudyIOD>()));
        }
Beispiel #3
0
        public IEnumerable <CFindStudyIOD> FindStudies(string patientId)
        {
            ushort msgId     = 1;
            var    query     = CFind.CreateStudyQuery(patientId);
            var    studyUids = _scu.GetResponses <CFindResponse, CFindRequest>(query, _scp, ref msgId) // Studies
                               .Where(r => r.Status == (ushort)Status.PENDING)
                               .Where(r => r.HasData);

            return(studyUids.Select(r => r.GetIOD <CFindStudyIOD>()));
        }
Beispiel #4
0
        public IEnumerable <CFindPatientIOD> FindPatient(string patientId = "", string patientName = "", System.DateTime?dob = null)
        {
            ushort msgId            = 1;
            var    query            = CFind.CreatePatientQuery(patientId, patientName, dob);
            var    patientResponses = _scu.GetResponses <CFindResponse, CFindRequest>(query, _scp, ref msgId); // Studies
            var    responses        = patientResponses.Where(r => r.HasData)
                                      .Select(r => new CFindPatientIOD(new DICOMObject(r.Data.Elements)));

            return(responses);
        }
Beispiel #5
0
        public IEnumerable <T> Find <T>(T iodQuery) where T : CFindInstanceIOD
        {
            var    results   = new List <T>();
            ushort msgId     = 1;
            var    req       = CFind.CreateQuery(iodQuery);
            var    responses = _scu.GetResponses <CFindResponse, CFindRequest>(req, _scp, ref msgId)
                               .Where(r => r.Status == (ushort)Status.PENDING)
                               .Where(r => r.HasData)
                               .Select(r => r.GetIOD <T>())
                               .ToList();

            results.AddRange(responses);
            return(results);
        }
Beispiel #6
0
        public void ReadWriteDIMSETest()
        {
            using (var stream = new MemoryStream())
            {
                //Generate a DIMSE
                var dimse    = CFind.CreateStudyQuery("123456");
                var pContext = new PresentationContext()
                {
                    AbstractSyntax   = AbstractSyntax.STUDY_FIND,
                    TransferSyntaxes = new List <string>()
                    {
                        TransferSyntaxHelper.IMPLICIT_VR_LITTLE_ENDIAN
                    }
                };

                PDataMessenger.WriteDimseToStream(dimse, stream, pContext);

                //Wrap stream in buffer to get to network stream
                using (var bs = new BufferedStream(stream))
                {
                    bs.Position = 0;
                    var net = new NetworkBinaryReader(bs);

                    var           pdata = PDataProcessor.ReadPDataTFs(net);
                    var           dcm   = PDataProcessor.GetCommandObject(pdata);
                    AbstractDIMSE dimseRead;
                    var           success = DIMSEReader.TryReadDIMSE(dcm, out dimseRead);

                    Assert.AreEqual(dimse.Elements.Count, dimseRead.Elements.Count);

                    for (int i = 0; i < dimse.Elements.Count; i++)
                    {
                        var el1 = dimse.Elements[i];
                        var el2 = dimseRead.Elements[i];
                        Assert.AreEqual(el1.Tag, el2.Tag);
                        Assert.AreEqual(el1.DData, el2.DData);
                    }

                    //Make sure this DIMSE was written with data
                    Assert.IsTrue(dimse.HasData);

                    //REad the data
                    var dataPds = PDataProcessor.ReadPDataTFs(net);
                    var data    = PDataProcessor.GetDataObject(dataPds, TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN);

                    DICOMAssert.AreEqual(data, dimse.Data);
                }
            }
        }
Beispiel #7
0
        public IEnumerable <CFindSeriesIOD> GetSeriesUids(IEnumerable <CFindStudyIOD> studies)
        {
            List <CFindSeriesIOD> results = new List <CFindSeriesIOD>();

            foreach (var study in studies)
            {
                var req        = CFind.CreateSeriesQuery(study.StudyInstanceUID);
                var seriesUids = _scu.GetResponse(req, _scp)
                                 .Where(r => r.Status == (ushort)Status.PENDING)
                                 .Where(r => r.HasData)
                                 .Select(r => r.GetIOD <CFindSeriesIOD>());
                results.AddRange(seriesUids);
            }
            return(results);
        }
Beispiel #8
0
        public IEnumerable <T> GetImageUids <T>(IEnumerable <CFindSeriesIOD> series) where T : CFindImageIOD
        {
            List <T> results = new List <T>();

            foreach (var ser in series)
            {
                var req        = CFind.CreateImageQuery(ser.SeriesInstanceUID);
                var imagesUids = _scu.GetResponse(req, _scp)
                                 .Where(r => r.Status == (ushort)Status.PENDING)
                                 .Where(r => r.HasData)
                                 .Select(r => r.GetIOD <T>())
                                 .ToList();
                results.AddRange(imagesUids);
            }
            return(results);
        }
Beispiel #9
0
        public IEnumerable <CFindImageIOD> FindImages(IEnumerable <CFindSeriesIOD> series)
        {
            var    results = new List <CFindImageIOD>();
            ushort msgId   = 1;

            foreach (var ser in series)
            {
                var req        = CFind.CreateImageQuery(ser.SeriesInstanceUID);
                var imagesUids = _scu.GetResponses <CFindResponse, CFindRequest>(req, _scp, ref msgId)
                                 .Where(r => r.Status == (ushort)Status.PENDING)
                                 .Where(r => r.HasData)
                                 .Select(r => r.GetIOD <CFindImageIOD>())
                                 .ToList();
                results.AddRange(imagesUids);
            }
            return(results);
        }
Beispiel #10
0
        public IEnumerable <CFindSeriesIOD> FindSeries(IEnumerable <CFindStudyIOD> studies)
        {
            var    results = new List <CFindSeriesIOD>();
            ushort msgId   = 1;

            foreach (var study in studies)
            {
                var req        = CFind.CreateSeriesQuery(study.StudyInstanceUID);
                var seriesUids = _scu.GetResponses <CFindResponse, CFindRequest>(req, _scp, ref msgId)
                                 .Where(r => r.Status == (ushort)Status.PENDING)
                                 .Where(r => r.HasData)
                                 .Select(r => r.GetIOD <CFindSeriesIOD>()).ToList();
                seriesUids.ForEach(s => s.PatientId = study.PatientId);
                results.AddRange(seriesUids);
            }
            return(results);
        }
Beispiel #11
0
        public IEnumerable <CFindSeriesIOD> FindSeries(IEnumerable <CFindStudyIOD> studies)
        {
            var    results = new List <CFindSeriesIOD>();
            ushort msgId   = 1;

            foreach (var study in studies)
            {
                Tryer.Try(() =>
                {
                    var req        = CFind.CreateSeriesQuery(study.StudyInstanceUID);
                    var seriesUids = _scu.GetResponses <CFindResponse, CFindRequest>(req, _scp, ref msgId)
                                     .Where(r => r.Status == (ushort)Status.PENDING)
                                     .Where(r => r.HasData)
                                     .Select(r => new CFindSeriesIOD(new DICOMObject(r.Data.Elements)));
                    results.AddRange(seriesUids);
                }, $"Adding study {study.StudyInstanceUID}...");
            }
            return(results);
        }
Beispiel #12
0
        public void GetChunksTest()
        {
            //Generate a DIMSE
            var dimse    = CFind.CreateStudyQuery("123456");
            var pContext = new PresentationContext()
            {
                AbstractSyntax   = AbstractSyntax.STUDY_FIND,
                TransferSyntaxes = new List <string>()
                {
                    TransferSyntaxHelper.IMPLICIT_VR_LITTLE_ENDIAN
                }
            };

            var bytes  = PDataMessenger.GetChunks(dimse.Data, 16534, pContext);
            var bytes1 = bytes[0];
            var dcm    = DICOMObject.Read(bytes1);

            DICOMAssert.AreEqual(dcm, dimse.Data);
        }
Beispiel #13
0
        public IEnumerable <T> FindImages <T>(IEnumerable <CFindSeriesIOD> series) where T : CFindInstanceIOD
        {
            var    results = new List <T>();
            ushort msgId   = 1;

            foreach (var ser in series)
            {
                Tryer.Try(() =>
                {
                    var req        = CFind.CreateImageQuery(ser);
                    var imagesUids = _scu.GetResponses <CFindResponse, CFindRequest>(req, _scp, ref msgId)
                                     .Where(r => r.Status == (ushort)Status.PENDING)
                                     .Where(r => r.HasData)
                                     .Select(r => r.GetIOD <T>())
                                     .ToList();
                    results.AddRange(imagesUids);
                }, $"Adding series {ser.Modality} : {ser.SeriesInstanceUID}");
            }
            return(results);
        }