private void Dump()
        {
            if (this.ContextBase is IImageViewerToolContext)
            {
                IImageViewerToolContext context = this.ContextBase as IImageViewerToolContext;
                _desktopWindow = context.DesktopWindow;
                IImageSopProvider image = context.Viewer.SelectedPresentationImage as IImageSopProvider;
                if (image == null)
                {
                    _desktopWindow.ShowMessageBox(SR.MessagePleaseSelectAnImage, MessageBoxActions.Ok);
                    return;
                }

                IDicomMessageSopDataSource dataSource = image.ImageSop.DataSource as IDicomMessageSopDataSource;
                if (dataSource == null || dataSource.SourceMessage == null)
                {
                    _desktopWindow.ShowMessageBox(SR.MessageUnknownDataSource, MessageBoxActions.Ok);
                    return;
                }

                //Fix for Ticket #623 - HH - It turns out that for memory usage optimization the pixel data tag is stripped from the in memory dataset.
                //So while there are probably many better ways to address the missing pixel data tag a small hack was introduced because this entire utility will
                //be completely refactored in the very near future to make use of the methods the pacs uses to parse the tags.
                //Addendum to Comment above - HH 07/27/07 - Turns out that our implementation continues to remove the pixel data for optimization at this time so
                //the workaround is still needed.
                //Addendum to Comment above - JY 09/16/08 - Somewhere along the line, things were changed that made this line redundant - the only reference to
                //it after this point is at +11 lines or so, and all it does is get file.Filename. Therefore, I am commenting this line out.
                //file = new DicomFile(file.Filename);

                if (_component == null)
                {
                    _component = new DicomEditorComponent();
                }
                else
                {
                    _component.Clear();
                }

                _component.Load(dataSource.SourceMessage);
            }
            else if (this.ContextBase is ILocalImageExplorerToolContext)
            {
                ILocalImageExplorerToolContext context = this.ContextBase as ILocalImageExplorerToolContext;
                _desktopWindow = context.DesktopWindow;
                List <string> files = new List <string>();

                if (context.SelectedPaths.Count == 0)
                {
                    return;
                }

                foreach (string rawPath in context.SelectedPaths)
                {
                    if (string.IsNullOrEmpty(rawPath))
                    {
                        continue;
                    }

                    FileProcessor.Process(rawPath, "*.*", files.Add, true);
                }

                if (files.Count == 0)
                {
                    context.DesktopWindow.ShowMessageBox(SR.MessageNoFilesSelected, MessageBoxActions.Ok);
                    return;
                }

                if (_component == null)
                {
                    _component = new DicomEditorComponent();
                }
                else
                {
                    _component.Clear();
                }

                bool userCancelled = false;

                BackgroundTask task = new BackgroundTask(delegate(IBackgroundTaskContext backgroundcontext)
                {
                    int i = 0;

                    foreach (string file in files)
                    {
                        if (backgroundcontext.CancelRequested)
                        {
                            backgroundcontext.Cancel();
                            userCancelled = true;
                            return;
                        }
                        try
                        {
                            _component.Load(file);
                        }
                        catch (DicomException e)
                        {
                            backgroundcontext.Error(e);
                            return;
                        }
                        backgroundcontext.ReportProgress(new BackgroundTaskProgress((int)(((double)(i + 1) / (double)files.Count) * 100.0), SR.MessageDumpProgressBar));
                        i++;
                    }

                    backgroundcontext.Complete(null);
                }, true);

                try
                {
                    ProgressDialog.Show(task, _desktopWindow, true);
                }
                catch (Exception e)
                {
                    ExceptionHandler.Report(e, SR.MessageFailedDump, _desktopWindow);
                    return;
                }

                if (userCancelled == true)
                {
                    return;
                }
            }

            //common to both contexts
            if (_shelf != null)
            {
                _shelf.Activate();
            }
            else
            {
                _shelf = ApplicationComponent.LaunchAsShelf(
                    _desktopWindow,
                    _component,
                    SR.TitleDicomEditor,
                    "Dicom Editor",
                    ShelfDisplayHint.DockRight | ShelfDisplayHint.DockAutoHide);
                _shelf.Closed += OnShelfClosed;
            }

            _component.UpdateComponent();
        }
        public static void CreateSeriesGraphicsForSeg(IPresentationImage presentationImage, Seg seg,
                                                      SegmentationDocument segmentationDocument,
                                                      IDicomMessageSopDataSource dicomMessageSopDataSourceSop)
        {
            Platform.CheckForNullReference(presentationImage, "presentationImage");
            Platform.CheckForNullReference(seg, "seg");
            Platform.CheckForNullReference(segmentationDocument, "segmentationDocument");

            SegmentImageData segImageData = seg.SegmentImageData;

            if (segImageData == null)
            {
                Platform.Log(LogLevel.Error,
                             "Cannot create segmentation graphics when no segmentation imaging data is provided");
                return;
            }

            var imageSopProvider = presentationImage as IImageSopProvider;

            if (imageSopProvider == null)
            {
                Platform.Log(LogLevel.Error,
                             "Failed to populate SegFrameGraphics collection. Image is not an ImageSopProvider");
                return;
            }

            DicomPixelData segmentationPixelData = DicomPixelData.CreateFrom(dicomMessageSopDataSourceSop.SourceMessage);
            var            rawPixelData          =
                (byte[])dicomMessageSopDataSourceSop.SourceMessage.DataSet.GetAttribute(DicomTags.PixelData).Values;
            var pixelDataGetter = new Func <int, byte[]>(frameIndex =>
            {
                if (segImageData.BitsStored == 1)
                {
                    // Do unpacking
                    int frameLength = segImageData.Rows *
                                      segImageData.Columns;
                    var overlayData =
                        new OverlayData(frameIndex * frameLength,
                                        segImageData.Rows,
                                        segImageData.Columns, false,
                                        rawPixelData);
                    return(overlayData.Unpack());
                }
                if (segImageData.BitsStored == 8)
                {
                    return(segmentationPixelData.GetFrame(frameIndex));
                }
                throw new InvalidDataException(
                    "Segmentation objects need to have BitsStored as either 1 or 8");
            });

            // NOTE: SegmentFrameData was already sorted
            foreach (SegmentFrameData segmentFrameData in segImageData.SegmentFrameData)
            {
                IPresentationImage segPresentationImage = null;

                // Get the presentation image if we have an image reference
                string referencedSopInstanceUid   = segmentFrameData.ReferencedSopInstanceUid;
                int    referencedImageFrameNumber = segmentFrameData.ReferencedFrameNumber ?? 1;
                if (!string.IsNullOrEmpty(referencedSopInstanceUid))
                {
                    segPresentationImage =
                        presentationImage.ParentDisplaySet.PresentationImages.OfType <IImageSopProvider>()
                        .FirstOrDefault(curImageSopProvider => curImageSopProvider != null &&
                                        curImageSopProvider.ImageSop.SopInstanceUid ==
                                        referencedSopInstanceUid &&
                                        curImageSopProvider.Frame.FrameNumber ==
                                        referencedImageFrameNumber) as IPresentationImage;
                }

                // Location defaults to 0, 0 unless determined otherwise from image position and image orientation
                var segLocation = new PointF();

                // Get the presentation image from the image position and orientation
                if (segmentFrameData.ImagePositionPatient != null &&
                    segmentFrameData.ImagePositionPatient.Count() > 2 &&
                    segmentFrameData.ImageOrientationPatient != null &&
                    segmentFrameData.ImageOrientationPatient.Count() > 5)
                {
                    var imagePositionPatient = new ImagePositionPatient(
                        segmentFrameData.ImagePositionPatient[0],
                        segmentFrameData.ImagePositionPatient[1],
                        segmentFrameData.ImagePositionPatient[2]);
                    var imageOrientationPatient = new ImageOrientationPatient(
                        segmentFrameData.ImageOrientationPatient[0],
                        segmentFrameData.ImageOrientationPatient[1],
                        segmentFrameData.ImageOrientationPatient[2],
                        segmentFrameData.ImageOrientationPatient[3],
                        segmentFrameData.ImageOrientationPatient[4],
                        segmentFrameData.ImageOrientationPatient[5]);
                    IDisplaySet displaySet = presentationImage.ParentDisplaySet;

                    if (segPresentationImage == null)
                    {
                        segPresentationImage = PresentationImageFromPositionOrientation(
                            imagePositionPatient,
                            imageOrientationPatient,
                            displaySet,
                            segImageData.FrameOfReferenceUid);
                    }

                    var imageSop = segPresentationImage as IImageSopProvider;
                    if (imageSop != null)
                    {
                        Vector3D segImageLocation =
                            imageSop.Frame.ImagePlaneHelper.ConvertToImagePlane(new Vector3D(
                                                                                    (float)imagePositionPatient.X,
                                                                                    (float)imagePositionPatient.Y,
                                                                                    (float)imagePositionPatient.Z));
                        PointF?segPixelLocation =
                            imageSop.Frame.ImagePlaneHelper.ConvertToImage(
                                new PointF(segImageLocation.X, segImageLocation.Y));
                        if (segPixelLocation.HasValue)
                        {
                            segLocation = segPixelLocation.Value;
                        }
                    }
                }

                if (segPresentationImage != null)
                {
                    SegFrameImageGraphic newGraphic = AddSegFrameImageGraphicToPresentationImage(
                        segPresentationImage,
                        segImageData.Rows,
                        segImageData.Columns,
                        segLocation.X,
                        segLocation.Y,
                        seg.Color,
                        referencedImageFrameNumber,
                        seg.Label,
                        seg.Description,
                        pixelDataGetter.Invoke(segmentFrameData.FrameNumber - 1),
                        new SegmentationDocumentReference(segmentationDocument, seg.SegmentationNumber));
                    if (newGraphic != null &&
                        segPresentationImage == segPresentationImage.ParentDisplaySet.ImageBox.TopLeftPresentationImage)
                    {
                        newGraphic.Draw();
                    }
                }
                else
                {
                    Platform.Log(LogLevel.Error, "Failed to find Presentation Image to display a segment on");
                }
            }
        }
        public static void CreateSeriesGraphicsForSeg(IPresentationImage presentationImage, Seg seg,
                                                      SegmentationDocument segmentationDocument,
                                                      IDicomMessageSopDataSource dicomMessageSopDataSourceSop)
        {
            Platform.CheckForNullReference(presentationImage, "presentationImage");
            Platform.CheckForNullReference(seg, "seg");
            Platform.CheckForNullReference(segmentationDocument, "segmentationDocument");

            SegmentImageData segImageData = seg.SegmentImageData;
            if (segImageData == null)
            {
                Platform.Log(LogLevel.Error,
                             "Cannot create segmentation graphics when no segmentation imaging data is provided");
                return;
            }

            var imageSopProvider = presentationImage as IImageSopProvider;
            if (imageSopProvider == null)
            {
                Platform.Log(LogLevel.Error,
                             "Failed to populate SegFrameGraphics collection. Image is not an ImageSopProvider");
                return;
            }

            DicomPixelData segmentationPixelData = DicomPixelData.CreateFrom(dicomMessageSopDataSourceSop.SourceMessage);
            var rawPixelData =
                (byte[]) dicomMessageSopDataSourceSop.SourceMessage.DataSet.GetAttribute(DicomTags.PixelData).Values;
            var pixelDataGetter = new Func<int, byte[]>(frameIndex =>
                                                            {
                                                                if (segImageData.BitsStored == 1)
                                                                {
                                                                    // Do unpacking
                                                                    int frameLength = segImageData.Rows*
                                                                                      segImageData.Columns;
                                                                    var overlayData =
                                                                        new OverlayData(frameIndex*frameLength,
                                                                                        segImageData.Rows,
                                                                                        segImageData.Columns, false,
                                                                                        rawPixelData);
                                                                    return overlayData.Unpack();
                                                                }
                                                                if (segImageData.BitsStored == 8)
                                                                {
                                                                    return segmentationPixelData.GetFrame(frameIndex);
                                                                }
                                                                throw new InvalidDataException(
                                                                    "Segmentation objects need to have BitsStored as either 1 or 8");
                                                            });

            // NOTE: SegmentFrameData was already sorted
            foreach (SegmentFrameData segmentFrameData in segImageData.SegmentFrameData)
            {
                IPresentationImage segPresentationImage = null;

                // Get the presentation image if we have an image reference
                string referencedSopInstanceUid = segmentFrameData.ReferencedSopInstanceUid;
                int referencedImageFrameNumber = segmentFrameData.ReferencedFrameNumber ?? 1;
                if (!string.IsNullOrEmpty(referencedSopInstanceUid))
                {
                    segPresentationImage =
                        presentationImage.ParentDisplaySet.PresentationImages.OfType<IImageSopProvider>()
                            .FirstOrDefault(curImageSopProvider => curImageSopProvider != null &&
                                                                   curImageSopProvider.ImageSop.SopInstanceUid ==
                                                                   referencedSopInstanceUid &&
                                                                   curImageSopProvider.Frame.FrameNumber ==
                                                                   referencedImageFrameNumber) as IPresentationImage;
                }

                // Location defaults to 0, 0 unless determined otherwise from image position and image orientation
                var segLocation = new PointF();

                // Get the presentation image from the image position and orientation
                if (segmentFrameData.ImagePositionPatient != null &&
                    segmentFrameData.ImagePositionPatient.Count() > 2 &&
                    segmentFrameData.ImageOrientationPatient != null &&
                    segmentFrameData.ImageOrientationPatient.Count() > 5)
                {
                    var imagePositionPatient = new ImagePositionPatient(
                        segmentFrameData.ImagePositionPatient[0],
                        segmentFrameData.ImagePositionPatient[1],
                        segmentFrameData.ImagePositionPatient[2]);
                    var imageOrientationPatient = new ImageOrientationPatient(
                        segmentFrameData.ImageOrientationPatient[0],
                        segmentFrameData.ImageOrientationPatient[1],
                        segmentFrameData.ImageOrientationPatient[2],
                        segmentFrameData.ImageOrientationPatient[3],
                        segmentFrameData.ImageOrientationPatient[4],
                        segmentFrameData.ImageOrientationPatient[5]);
                    IDisplaySet displaySet = presentationImage.ParentDisplaySet;

                    if (segPresentationImage == null)
                    {
                        segPresentationImage = PresentationImageFromPositionOrientation(
                            imagePositionPatient,
                            imageOrientationPatient,
                            displaySet,
                            segImageData.FrameOfReferenceUid);
                    }

                    var imageSop = segPresentationImage as IImageSopProvider;
                    if (imageSop != null)
                    {
                        Vector3D segImageLocation =
                            imageSop.Frame.ImagePlaneHelper.ConvertToImagePlane(new Vector3D(
                                                                                    (float) imagePositionPatient.X,
                                                                                    (float) imagePositionPatient.Y,
                                                                                    (float) imagePositionPatient.Z));
                        PointF? segPixelLocation =
                            imageSop.Frame.ImagePlaneHelper.ConvertToImage(
                                new PointF(segImageLocation.X, segImageLocation.Y));
                        if (segPixelLocation.HasValue)
                            segLocation = segPixelLocation.Value;
                    }
                }

                if (segPresentationImage != null)
                {
                    SegFrameImageGraphic newGraphic = AddSegFrameImageGraphicToPresentationImage(
                        segPresentationImage,
                        segImageData.Rows,
                        segImageData.Columns,
                        segLocation.X,
                        segLocation.Y,
                        seg.Color,
                        referencedImageFrameNumber,
                        seg.Label,
                        seg.Description,
                        pixelDataGetter.Invoke(segmentFrameData.FrameNumber - 1),
                        new SegmentationDocumentReference(segmentationDocument, seg.SegmentationNumber));
                    if (newGraphic != null &&
                        segPresentationImage == segPresentationImage.ParentDisplaySet.ImageBox.TopLeftPresentationImage)
                    {
                        newGraphic.Draw();
                    }
                }
                else
                {
                    Platform.Log(LogLevel.Error, "Failed to find Presentation Image to display a segment on");
                }
            }
        }