Ejemplo n.º 1
0
        /// <summary> </summary>
        /// <param name="context"></param>
        protected override void DoWork(CodeActivityContext context)
        {
            string localStatus       = "FAILED";
            string sroDcmInstanceId  = SroUnitId.Get(context);
            int    nSroDcmInstanceId = Convert.ToInt32(sroDcmInstanceId);

            string rpsDcmInstanceId  = RpsUnitId.Get(context);
            int    nRpsDcmInstanceId = Convert.ToInt32(rpsDcmInstanceId);

            IList <string> planningImageSopInstanceUidValues     = new List <string>();
            IList <string> verificationImageSopInstanceUidValues = new List <string>();


            context.GetExtension <CompositionContainer>().SatisfyImportsOnce(this);

            _processSpatialRegistrationObject.ParseXVI5xSpatialRegistration(nSroDcmInstanceId, nRpsDcmInstanceId,
                                                                            ref planningImageSopInstanceUidValues, ref verificationImageSopInstanceUidValues);

            // did we successfully extract the lists of image sop instance uids ?
            if (planningImageSopInstanceUidValues.Count > 0 && verificationImageSopInstanceUidValues.Count > 0)
            {
                localStatus = "SUCCESS";
            }

            PlanningImageSopInstanceValues.Set(context, planningImageSopInstanceUidValues);
            VerificationImageSopInstanceValues.Set(context, verificationImageSopInstanceUidValues);
            ActivityStatus.Set(context, localStatus);
        }
Ejemplo n.º 2
0
        /// <summary> </summary>
        /// <param name="context"></param>
        protected override void DoWork(CodeActivityContext context)
        {
            string                  localStatus                           = "FAILED";
            string                  _dcmInstanceId                        = UnitId.Get(context);
            int                     nDcmInstanceId                        = Convert.ToInt32(_dcmInstanceId);
            IList <string>          sourceFrameOfReferenceUid             = SourceFrameOfReferenceUID.Get(context);
            string                  targetFrameOfReferenceUid             = TargetFrameOfReferenceUID.Get(context);
            IList <IList <double> > transformationMatrix                  = TransformationMatrix.Get(context);
            IList <int>             planningImageIdValues                 = PlanningImageIdValues.Get(context);
            IList <int>             verificationImageIdValues             = VerificationImageIdValues.Get(context);
            IList <string>          planningImageSopInstanceUidValues     = PlanningImageSopInstanceValues.Get(context);
            IList <string>          verificationImageSopInstanceUidValues = VerificationImageSopInstanceValues.Get(context);
            IList <string>          planningFrameOfReferenceUidValues     = PlanningImageFrameOfReferenceUidValues.Get(context);
            string                  spatialRegistrationObjectType         = SpatialRegistrationObjectType.Get(context);
            string                  siteID        = SiteID.Get(context);
            IList <decimal>         dOffsetValues = new List <decimal>(6);
            int                     nOffsetId     = 0;
            int                     nSiteID       = 0;
            int                     nPatientID    = 0;

            if (siteID.Length > 0)
            {
                nSiteID = Convert.ToInt32(siteID);
            }

            context.GetExtension <CompositionContainer>().SatisfyImportsOnce(this);


            bool result =
                _processSpatialRegistrationObject.PrepAndCreateOffsetRecords(
                    nDcmInstanceId,
                    spatialRegistrationObjectType,
                    planningImageIdValues,
                    verificationImageIdValues,
                    planningImageSopInstanceUidValues,
                    verificationImageSopInstanceUidValues,
                    planningFrameOfReferenceUidValues,
                    sourceFrameOfReferenceUid,
                    targetFrameOfReferenceUid,
                    transformationMatrix,
                    nSiteID,
                    ref nPatientID,
                    ref nOffsetId,
                    ref dOffsetValues);

            if (result)
            {
                localStatus = "SUCCESS";
            }
            PatientID.Set(context, nPatientID.ToString());
            OffsetID.Set(context, nOffsetId.ToString());
            SroProcessedResult.Set(context, result);
            OffsetValues.Set(context, dOffsetValues);
            ActivityStatus.Set(context, localStatus);
        }
Ejemplo n.º 3
0
        /// <summary> </summary>
        /// <param name="context"></param>
        protected override void DoWork(CodeActivityContext context)
        {
            string                  localStatus                           = "FAILED";
            string                  _dcmInstanceId                        = UnitId.Get(context);
            int                     nDcmInstanceId                        = Convert.ToInt32(_dcmInstanceId);
            IList <string>          sourceFrameOfReferenceUid             = new List <string>();
            string                  targetFrameOfReferenceUid             = "";
            IList <IList <double> > transformationMatrix                  = new List <IList <double> >();
            IList <string>          transformationComment                 = new List <string>();
            IList <int>             planningImageIdValues                 = new List <int>();
            IList <string>          planningImageSopInstanceUidValues     = new List <string>();
            IList <string>          planningFrameOfReferenceUidValues     = new List <string>();
            IList <string>          verificationImageSopInstanceUidValues = new List <string>();
            string                  spatialRegistrationType               = SpatialRegistrationObjectType.Get(context);
            IList <string>          _structureSetIds                      = StructureSetIds.Get(context);
            IList <string>          structureSetIds;

            if (spatialRegistrationType == "3D" && _structureSetIds != null && _structureSetIds.Count > 0)
            {
                structureSetIds = _structureSetIds;
            }
            else
            {
                structureSetIds = new List <string>();
            }
            byte nRegistrationType = 0;

            context.GetExtension <CompositionContainer>().SatisfyImportsOnce(this);

            _processSpatialRegistrationObject.ParseTreatmentDeliverySpatialRegistration(nDcmInstanceId, spatialRegistrationType, structureSetIds, ref sourceFrameOfReferenceUid, ref targetFrameOfReferenceUid, ref transformationMatrix, ref transformationComment, ref planningImageSopInstanceUidValues, ref planningImageIdValues, ref planningFrameOfReferenceUidValues, ref verificationImageSopInstanceUidValues, ref nRegistrationType);

            if (sourceFrameOfReferenceUid != null && sourceFrameOfReferenceUid.Count > 0)
            {
                localStatus = "SUCCESS";
            }

            SourceFrameOfReferenceUID.Set(context, sourceFrameOfReferenceUid);
            TargetFrameOfReferenceUID.Set(context, targetFrameOfReferenceUid);
            TransformationMatrix.Set(context, transformationMatrix);
            TransformationMatrixComment.Set(context, transformationComment);
            PlanningImageSopInstanceValues.Set(context, planningImageSopInstanceUidValues);
            PlanningImageIdValues.Set(context, planningImageIdValues);
            PlanningImageFrameOfReferenceUidValues.Set(context, planningFrameOfReferenceUidValues);
            VerificationImageSopInstanceValues.Set(context, verificationImageSopInstanceUidValues);
            RegistrationType.Set(context, nRegistrationType);
            ActivityStatus.Set(context, localStatus);
        }
Ejemplo n.º 4
0
        /// <summary> </summary>
        /// <param name="context"></param>
        protected override void DoWork(CodeActivityContext context)
        {
            string          localStatus = "FAILED";
            bool            status      = SroProcessedResult.Get(context);
            string          patientId   = PatientID.Get(context);
            string          siteId      = SiteID.Get(context);
            IList <string>  referencedImageSopInstanceValues   = PlanningImageSopInstanceValues.Get(context);
            IList <string>  verificationImageSopInstanceValues = VerificationImageSopInstanceValues.Get(context);
            IList <decimal> offsetValues = OffsetValues.Get(context);

            context.GetExtension <CompositionContainer>().SatisfyImportsOnce(this);

            bool result = _processSpatialRegistrationObject.SendSroProcessedMessage(status, Convert.ToInt32(patientId), Convert.ToInt32(siteId), referencedImageSopInstanceValues, verificationImageSopInstanceValues, offsetValues);

            if (result)
            {
                localStatus = "SUCCESS";
            }
            ActivityStatus.Set(context, localStatus);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="context"></param>
        /// <param name="bookmark"></param>
        /// <param name="obj"></param>
        protected override void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, string obj)
        {
            var method = System.Reflection.MethodBase.GetCurrentMethod().Name;

            Debug.Assert(bookmark.Name == BookmarkName);

            context.GetExtension <CompositionContainer>().SatisfyImportsOnce(this);
            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Enter: Finished Processing UnitId: [{1}], Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), bookmark.Name));
            var registrationType = SpatialRegistrationObjectType.Get(context);

            if (registrationType.Equals("2D"))
            {
                IList <int> imageIds = new List <int>();
                _processSpatialRegistrationObject.GetReferencedImageIds(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
                foreach (int image_id in imageIds)
                {
                    _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Found Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), image_id.ToString()));
                }
                if (imageIds.Count == 0)
                {
                    _logger.Log(EventSeverity.Error, method, string.Format("[{0}] Processing UnitId: [{1}], Image Id list was not set correctly", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context)));
                    ActivityStatus.Set(context, "FAILED");
                }
                else
                {
                    ActivityStatus.Set(context, "SUCCESS");
                }
                VerificationImageIds.Set(context, imageIds);
                OutUnitId.Set(context, UnitId.Get(context));
                ActivityStatus.Set(context, "SUCCESS");
            }
            else if (registrationType.Equals("3D"))
            {
                IList <int> imageIds = new List <int>();
                _processSpatialRegistrationObject.GetReferencedImageIdsFromSOPInstanceUIDs(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
                foreach (int image_id in imageIds)
                {
                    _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Found Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), image_id.ToString()));
                }
                if (imageIds.Count == 0)
                {
                    _logger.Log(EventSeverity.Error, method, string.Format("[{0}] Processing UnitId: [{1}], Image Id list was not set correctly", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context)));
                    ActivityStatus.Set(context, "FAILED");
                }
                else
                {
                    ActivityStatus.Set(context, "SUCCESS");
                }
                VerificationImageIds.Set(context, imageIds);
                OutUnitId.Set(context, UnitId.Get(context));
            }
            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Finished Processing UnitId: [{1}], Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), bookmark.Name));
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="context"></param>
        /// <param name="pCancelBookmarkCreation"></param>
        protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
        {
            var method = System.Reflection.MethodBase.GetCurrentMethod().Name;

            pCancelBookmarkCreation = false;
            _logger.Log(EventSeverity.Debug, method,
                        string.Format("[{0}] Enter: Processing UnitId: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
                                      Thread.CurrentThread.ManagedThreadId,
                                      UnitId.Get(context), BookmarkName, _processSpatialRegistrationObject.ConstructedBy));

            var registrationType        = SpatialRegistrationObjectType.Get(context);
            var planningSopInstanceUids = PlanningImageSopInstanceValues.Get(context);

            switch (registrationType)
            {
            case "2D":
                var ref2DImageInfo = _processSpatialRegistrationObject.GetReferenced2DImageInfo(Int32.Parse(UnitId.Get(context)), planningSopInstanceUids);
                foreach (var tuple in ref2DImageInfo)
                {
                    foreach (string refSopInstanceUid in tuple.Item2)
                    {
                        _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Looking for IMG with SOP Instance: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), refSopInstanceUid));
                    }

                    var         metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForReferencedImageData(tuple.Item1, tuple.Item2);
                    IList <int> imageIds = new List <int>();

                    //
                    // If the dataset we are planning to wait is already available
                    // skip the bookmark creation and proceed to next activity.
                    //
                    if (_waitSetDataWrapper.IsDataAvailable(metadata))
                    {
                        pCancelBookmarkCreation = true;
                        _processSpatialRegistrationObject.GetReferencedImageIds(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
                        if (imageIds.Count > 0)
                        {
                            foreach (int image_id in imageIds)
                            {
                                _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Found Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), image_id.ToString()));
                            }
                        }
                        if (imageIds.Count == 0)
                        {
                            _logger.Log(EventSeverity.Error, method, string.Format("[{0}] Processing UnitId: [{1}], Image Id list was not set correctly", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context)));
                            ActivityStatus.Set(context, "FAILED");
                        }
                        else
                        {
                            ActivityStatus.Set(context, "SUCCESS");
                        }
                        VerificationImageIds.Set(context, imageIds);
                        OutUnitId.Set(context, UnitId.Get(context));
                    }
                    else
                    {
                        // Perform manual processing to see which images are currently available
                        // This needs to handle 1-N cases
                        _processSpatialRegistrationObject.GetReferencedImageIds(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
                        // based on that result set, set the bookmark if we are still missing some data
                        if (imageIds.Count < VerificationImageSopInstanceValues.Get(context).Count)
                        {
                            BookmarkMetadata.Set(context, metadata.ToString());
                            _waitSetDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
                                                                    metadata,
                                                                    _waitHandlersRepository.Get("WorkQueueElement"));
                        }
                    }
                }
                break;

            case "3D":
                var ref3DImageInfo = _processSpatialRegistrationObject.GetReferenced3DImageInfo(Int32.Parse(UnitId.Get(context)), planningSopInstanceUids);
                int i = 0;
                foreach (var tuple in ref3DImageInfo)
                {
                    if (tuple.Item2.Count == 0)
                    {
                        continue;
                    }

                    foreach (string refSopInstanceUid in tuple.Item3)
                    {
                        _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Looking for DCM SOP Instance: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), refSopInstanceUid));
                    }

                    string verForUid = string.Empty;
                    if (!base._useQueryNotificationFor3DWorkflows)
                    {
                        verForUid = _processSpatialRegistrationObject.GetReferencedFrameOfReferenceInfo(Int32.Parse(UnitId.Get(context)));
                    }
                    var metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForReferencedDicomData(tuple.Item1, tuple.Item2[i], verForUid, tuple.Item3);
                    //
                    // If the dataset we are planning to wait is already available
                    // skip the bookmark creation and proceed to next activity.
                    //
                    if (_waitSetDataWrapper.IsDataAvailable(metadata))
                    {
                        pCancelBookmarkCreation = true;
                        IList <int> imageIds = new List <int>();
                        _processSpatialRegistrationObject.GetReferencedImageIdsFromSOPInstanceUIDs(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
                        foreach (int image_id in imageIds)
                        {
                            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Found Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), image_id.ToString()));
                        }
                        if (imageIds.Count == 0)
                        {
                            _logger.Log(EventSeverity.Error, method, string.Format("[{0}] Processing UnitId: [{1}], Image Id list was not set correctly", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context)));
                            ActivityStatus.Set(context, "FAILED");
                        }
                        else
                        {
                            ActivityStatus.Set(context, "SUCCESS");
                        }
                        VerificationImageIds.Set(context, imageIds);
                        OutUnitId.Set(context, UnitId.Get(context));

                        //if (!base._useQueryNotificationFor3DWorkflows)
                        //{
                        //    if (!String.IsNullOrEmpty(metadata.DataMonitoringEventId))
                        //    {
                        //        WaitEventManager.TryRemoveEvent(metadata.DataMonitoringEventId);
                        //    }
                        //}
                    }
                    else
                    {
                        BookmarkMetadata.Set(context, metadata.ToString());
                        if (base._useQueryNotificationFor3DWorkflows)
                        {
                            _waitSetDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
                                                                    metadata, _waitHandlersRepository.Get("WorkQueueElement"));
                        }
                        else
                        {
                            _waitSetDataWrapper.InitiateWaitForDataEvent(context.WorkflowInstanceId, BookmarkName,
                                                                         metadata, _waitHandlersRepository.Get("WorkQueueElement"));
                        }
                    }
                    i++;
                }
                break;
            }

            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing UnitId: [{1}], Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), BookmarkName));
        }