private static void Execute(IImageBox imageBox, object unexplodeMemento) { MemorableUndoableCommand memorableCommand = new MemorableUndoableCommand(imageBox); memorableCommand.BeginState = imageBox.CreateMemento(); IDisplaySet displaySet = imageBox.DisplaySet; IPresentationImage selectedImage; if (imageBox.SelectedTile != null) selectedImage = imageBox.SelectedTile.PresentationImage; else selectedImage = imageBox.TopLeftPresentationImage; imageBox.SetMemento(unexplodeMemento); //TODO (architecture): this wouldn't be necessary if we had a SetImageBoxGrid(imageBox[,]). //This stuff with mementos is actually a hacky workaround. bool locked = imageBox.DisplaySetLocked; imageBox.DisplaySetLocked = false; imageBox.DisplaySet = displaySet; imageBox.DisplaySetLocked = locked; if (selectedImage != null) imageBox.TopLeftPresentationImage = selectedImage; imageBox.Draw(); imageBox.SelectDefaultTile(); memorableCommand.EndState = imageBox.CreateMemento(); DrawableUndoableCommand historyCommand = new DrawableUndoableCommand(imageBox); historyCommand.Name = SR.CommandExplodeTile; historyCommand.Enqueue(memorableCommand); imageBox.ParentPhysicalWorkspace.ImageViewer.CommandHistory.AddCommand(historyCommand); }
public UnexplodeTileCommand(IImageBox imageBox, object unexplodeMemento, NotifyRemoveUnexplodedTileCommand remove) { _imageBox = imageBox; _unexplodeMemento = unexplodeMemento; _remove = remove; _listObserver = new ListObserver<ITile>(imageBox.Tiles, OnTilesChanged); }
public CrossHair(IImageBox imageBox, SpatialLocatorTool spatialLocatorTool) { ImageBox = imageBox; _spatialLocatorTool = spatialLocatorTool; _crosshairGraphic = new CrosshairGraphic(); _crosshairGraphic.Drawing += OnGraphicDrawing; }
public ImageBoxFrameSelectionStrategy(IImageBox imageBox, int window, NotifyChangedDelegate notifyChanged) { _notifyChanged = notifyChanged; _imageBox = imageBox; _imageBox.Drawing += OnImageBoxDrawing; _window = window; _frames = new Queue<Frame>(); Refresh(true); }
private void CreateObjects() { _viewer = new ImageViewerComponent(); _imageBox = new ImageBox(); _tile1 = new Tile(); _tile2 = new Tile(); _imageSet = new ImageSet(); _displaySet = new DisplaySet(); _image1 = new TestPresentationImage(); _image2 = new TestPresentationImage(); }
public TestTree() { _viewer = new ImageViewerComponent(); _imageBox1 = new ImageBox(); _imageBox2 = new ImageBox(); _tile1 = new Tile(); _tile2 = new Tile(); _tile3 = new Tile(); _tile4 = new Tile(); _imageSet1 = new ImageSet(); _displaySet1 = new DisplaySet(); _displaySet2 = new DisplaySet(); _image1 = new TestPresentationImage(); _image2 = new TestPresentationImage(); _image3 = new TestPresentationImage(); _image4 = new TestPresentationImage(); _viewer.PhysicalWorkspace.ImageBoxes.Add(_imageBox1); _viewer.PhysicalWorkspace.ImageBoxes.Add(_imageBox2); _imageBox1.Tiles.Add(_tile1); _imageBox1.Tiles.Add(_tile2); _imageBox2.Tiles.Add(_tile3); _imageBox2.Tiles.Add(_tile4); _viewer.LogicalWorkspace.ImageSets.Add(_imageSet1); _imageSet1.DisplaySets.Add(_displaySet1); _imageSet1.DisplaySets.Add(_displaySet2); _displaySet1.PresentationImages.Add(_image1); _displaySet1.PresentationImages.Add(_image2); _displaySet2.PresentationImages.Add(_image3); _displaySet2.PresentationImages.Add(_image4); _imageBox1.DisplaySet = _displaySet1; _imageBox2.DisplaySet = _displaySet2; }
internal static void AssignDisplaySetToImageBox(IImageBox imageBox, IDisplaySet displaySet) { MemorableUndoableCommand memorableCommand = new MemorableUndoableCommand(imageBox); memorableCommand.BeginState = imageBox.CreateMemento(); // always create a 'fresh copy' to show in the image box. We never want to show // the 'originals' (e.g. the ones in IImageSet.DisplaySets) because we want them // to remain clean and unaltered - consider them to be templates for what actually // gets shown. imageBox.DisplaySet = displaySet.CreateFreshCopy(); imageBox.Draw(); //this.ImageViewer.SelectedImageBox[0, 0].Select(); memorableCommand.EndState = imageBox.CreateMemento(); DrawableUndoableCommand historyCommand = new DrawableUndoableCommand(imageBox); historyCommand.Enqueue(memorableCommand); imageBox.ImageViewer.CommandHistory.AddCommand(historyCommand); }
private IAction[] CreateDisplaySetActions(IActionFactoryContext context) { List <IAction> actions = new List <IAction>(); IImageBox imageBox = context.ImageViewer.SelectedImageBox; if (imageBox != null && !imageBox.DisplaySetLocked) { foreach (IDisplaySet displaySet in context.ImageSet.DisplaySets) { IDisplaySet theDisplaySet = displaySet; MenuAction action = CreateMenuAction(context, displaySet.Name, () => AssignDisplaySetToImageBox(context.ImageViewer, theDisplaySet)); action.Checked = context.ImageViewer.SelectedImageBox != null && context.ImageViewer.SelectedImageBox.DisplaySet != null && context.ImageViewer.SelectedImageBox.DisplaySet.Uid == theDisplaySet.Uid; actions.Add(action); } } return(actions.ToArray()); }
private bool CanUnexplodeImageBox(IImageBox imageBox) { if (imageBox == null) return false; IPhysicalWorkspace workspace = imageBox.ParentPhysicalWorkspace; if (workspace == null) return false; if (imageBox.DisplaySet == null) { CancelExplodeMode(); return false; } return true; }
private void ExplodeImageBox() { IImageBox imageBox = ImageViewer.SelectedImageBox; if (!CanExplodeImageBox(imageBox)) return; IPhysicalWorkspace workspace = imageBox.ParentPhysicalWorkspace; MemorableUndoableCommand memorableCommand = new MemorableUndoableCommand(workspace); memorableCommand.BeginState = workspace.CreateMemento(); _imageBoxesObserver.SuppressChangedEvent = true; //set this here so checked will be correct. _unexplodeMemento = memorableCommand.BeginState; _oldImageBox = imageBox; IDisplaySet displaySet = _oldImageBox.DisplaySet; IPresentationImage selectedImage = _oldImageBox.SelectedTile.PresentationImage; object imageBoxMemento = _oldImageBox.CreateMemento(); workspace.SetImageBoxGrid(1, 1); IImageBox newImageBox = workspace.ImageBoxes[0]; newImageBox.SetMemento(imageBoxMemento); //TODO (architecture): this wouldn't be necessary if we had a SetImageBoxGrid(imageBox[,]). //This stuff with mementos is actually a hacky workaround. bool locked = newImageBox.DisplaySetLocked; newImageBox.DisplaySetLocked = false; newImageBox.DisplaySet = displaySet; newImageBox.TopLeftPresentationImage = selectedImage; newImageBox.DisplaySetLocked = locked; _imageBoxesObserver.SuppressChangedEvent = false; workspace.Draw(); workspace.SelectDefaultImageBox(); memorableCommand.EndState = workspace.CreateMemento(); DrawableUndoableCommand historyCommand = new DrawableUndoableCommand(workspace); historyCommand.Name = SR.CommandSurveyExplode; historyCommand.Enqueue(memorableCommand); base.ImageViewer.CommandHistory.AddCommand(historyCommand); OnCheckedChanged(); UpdateEnabled(); }
private void ExplodeSelectedTile(IImageBox imageBox) { MemorableUndoableCommand memorableCommand = new MemorableUndoableCommand(imageBox); memorableCommand.BeginState = imageBox.CreateMemento(); //set this here so checked will be correct. object unexplodeMemento = memorableCommand.BeginState; _unexplodeCommands[imageBox] = new UnexplodeTileCommand(imageBox, unexplodeMemento, RemoveUnexplodeCommand); IDisplaySet displaySet = imageBox.DisplaySet; IPresentationImage selectedImage = imageBox.SelectedTile.PresentationImage; imageBox.SetTileGrid(1, 1); //TODO (architecture): this wouldn't be necessary if we had a SetImageBoxGrid(imageBox[,]). //This stuff with mementos is actually a hacky workaround. bool locked = imageBox.DisplaySetLocked; imageBox.DisplaySetLocked = false; imageBox.DisplaySet = displaySet; imageBox.DisplaySetLocked = locked; imageBox.TopLeftPresentationImage = selectedImage; memorableCommand.EndState = imageBox.CreateMemento(); DrawableUndoableCommand historyCommand = new DrawableUndoableCommand(imageBox); historyCommand.Name = SR.CommandExplodeTile; historyCommand.Enqueue(memorableCommand); imageBox.ParentPhysicalWorkspace.ImageViewer.CommandHistory.AddCommand(historyCommand); imageBox.Draw(); imageBox.SelectDefaultTile(); }
private IEnumerable<IImageBox> GetTargetImageBoxes(IImageBox referenceImageBox) { foreach (IImageBox imageBox in this.Context.Viewer.PhysicalWorkspace.ImageBoxes) { if (imageBox != referenceImageBox && imageBox.DisplaySet != null && imageBox.DisplaySet.PresentationImages.Count > 1) yield return imageBox; } }
// Note: this algorithm is not bulletproof, but will always work when the workspace is completely visible // on any combination of monitors. More specifically, where it starts to fail is when the center of the (default positioned) // image box falls off of all of the screens. In those rare/extreme cases, we don't try to do any optimization // and use the simple rectangle calculation. private bool OptimizeImageBoxGrid() { Rectangle usableWorkspaceArea = GetUsableArea(); if (usableWorkspaceArea.IsEmpty || usableWorkspaceArea.Width < 20 || usableWorkspaceArea.Height < 20) { return(false); } float rectangleWidth = usableWorkspaceArea.Width / (float)_columns; float rectangleHeight = usableWorkspaceArea.Height / (float)_rows; var imageBoxesSet = new List <IImageBox>(); foreach (Screen screen in Screen.AllScreens) { int firstRow = -1; int lastRow = -1; int firstColumn = -1; int lastColumn = -1; //Find the first and last row/column defining a sub-grid that will be kept on this screen. //We use the center of each image box in the non-optimized case to determine what screen //a particular image box should be on. for (int row = 0; row < _rows; ++row) { for (int column = 0; column < _columns; ++column) { int rectangleCentreX = usableWorkspaceArea.Left + (int)(rectangleWidth * (column + 0.5F)); int rectangleCentreY = usableWorkspaceArea.Top + (int)(rectangleHeight * (row + 0.5F)); if (screen.Bounds.Contains(rectangleCentreX, rectangleCentreY)) { if (firstRow < 0) { firstRow = row; } lastRow = row; if (firstColumn < 0) { firstColumn = column; } lastColumn = column; } } } Rectangle workspaceArea = ScreenRectangle; Rectangle screenUsableArea = Rectangle.Intersect(workspaceArea, screen.WorkingArea); //Subdivide the occupied screen area into a grid based on the start/end row/column determined above. if (!screenUsableArea.IsEmpty && firstRow >= 0 && firstColumn >= 0) { RectangleF normalizedScreenUsableArea = RectangleUtilities.CalculateNormalizedSubRectangle(workspaceArea, screenUsableArea); int screenRows = lastRow - firstRow + 1; int screenColumns = lastColumn - firstColumn + 1; float adjustedWidth = normalizedScreenUsableArea.Width / screenColumns; float adjustedHeight = normalizedScreenUsableArea.Height / screenRows; for (int screenRow = 0; screenRow < screenRows; ++screenRow) { for (int screenColumn = 0; screenColumn < screenColumns; ++screenColumn) { IImageBox imageBox = this[firstRow + screenRow, firstColumn + screenColumn]; //same one was already set; fail. if (imageBoxesSet.Contains(imageBox)) { return(false); } imageBoxesSet.Add(imageBox); float x = normalizedScreenUsableArea.Left + screenColumn * adjustedWidth; float y = normalizedScreenUsableArea.Top + screenRow * adjustedHeight; imageBox.NormalizedRectangle = new RectangleF(x, y, adjustedWidth, adjustedHeight); } } } } //Success only if every image box's rectangle was set exactly once. return(imageBoxesSet.Count == ImageBoxes.Count); }
private static bool CanExplodeTiles(IImageBox imageBox) { return imageBox.Tiles.Count > 1 && !imageBox.ParentPhysicalWorkspace.Locked; }
private bool CaptureEndState() { if (_memorableCommand == null || _currentImageBox == null) { _currentImageBox = null; return false; } bool commandAdded = false; // If nothing's changed then just return if (_initialPresentationImageIndex != _currentImageBox.SelectedTile.PresentationImageIndex) { // Capture state after stack _memorableCommand.EndState = _currentImageBox.CreateMemento(); if (!_memorableCommand.EndState.Equals(_memorableCommand.BeginState)) { var historyCommand = new DrawableUndoableCommand(_currentImageBox) {Name = SR.CommandStack}; historyCommand.Enqueue(_memorableCommand); Context.Viewer.CommandHistory.AddCommand(historyCommand); commandAdded = true; } } _memorableCommand = null; _currentImageBox = null; return commandAdded; }
internal ImageBoxSelectedEventArgs( IImageBox selectedImageBox) { Platform.CheckForNullReference(selectedImageBox, "selectedImageBox"); _selectedImageBox = selectedImageBox; }
private static IEnumerable<DicomImagePlane> GetAllImagePlanes(IImageBox imageBox) { if (imageBox.DisplaySet != null) { for (int index = imageBox.DisplaySet.PresentationImages.Count - 1; index >= 0; --index) { DicomImagePlane targetPlane = DicomImagePlane.FromImage(imageBox.DisplaySet.PresentationImages[index]); if (targetPlane != null) yield return targetPlane; } } }
/// <summary> /// Checks whether the specified series is loaded into the current ImageViewer. /// If not loaded, the method will load the series into the currently selected ImageBox. /// </summary> /// <param name="seriesInstanceUid">Series Instance UID to validate</param> /// <param name="imagePositionPatient">Image Position Patient from an image in the series</param> /// <param name="imageOrientationPatient">Image Orientation Patient from an image in the series</param> /// <param name="frameOfReferenceUid">Frame of Reference UID of the given series</param> /// <returns><value>true</value> is series now loaded, or <value>false</value> if no matching /// series could be found or loaded</returns> /// <remarks>Either <paramref name="seriesInstanceUid"/> or <paramref name="imagePositionPatient"/> and /// <paramref name="imageOrientationPatient"/> must be not null</remarks> private bool EnsureSeriesIsLoaded(string seriesInstanceUid, double[] imagePositionPatient, double[] imageOrientationPatient, string frameOfReferenceUid) { if (string.IsNullOrEmpty(seriesInstanceUid) && (imagePositionPatient == null || imageOrientationPatient == null)) { return(false); } bool isLoaded = false; foreach (IImageBox imageBox in ImageViewer.PhysicalWorkspace.ImageBoxes.Where( imageBox => imageBox != null && imageBox.DisplaySet != null && imageBox.DisplaySet.PresentationImages != null)) { if (string.IsNullOrEmpty(seriesInstanceUid)) { IPresentationImage segPresentationImage = SegmentationGraphicsHelpers. PresentationImageFromPositionOrientation( imagePositionPatient, imageOrientationPatient, imageBox.DisplaySet, frameOfReferenceUid); if (segPresentationImage != null) { isLoaded = true; break; } } else { IImageSopProvider imageSopProvider = imageBox.DisplaySet.PresentationImages.OfType <IImageSopProvider>().FirstOrDefault(); if (imageSopProvider != null && imageSopProvider.Frame.SeriesInstanceUid == seriesInstanceUid) { isLoaded = true; break; } } } if (!isLoaded) { IImageBox targetImageBox = ImageViewer.PhysicalWorkspace.SelectedImageBox ?? (ImageViewer.PhysicalWorkspace.ImageBoxes.Count > 0 ? ImageViewer.PhysicalWorkspace.ImageBoxes[0] : null); if (targetImageBox == null) { Platform.Log(LogLevel.Error, "Failed to find an ImageBox in which to load segmentation's series."); } else { foreach (IImageSet imageSet in ImageViewer.LogicalWorkspace.ImageSets.Where( imageSet => imageSet != null && imageSet.DisplaySets != null)) { foreach (IDisplaySet displaySet in imageSet.DisplaySets.Where( displaySet => displaySet != null && displaySet.PresentationImages != null)) { if (string.IsNullOrEmpty(seriesInstanceUid)) { IPresentationImage segPresentationImage = SegmentationGraphicsHelpers. PresentationImageFromPositionOrientation( imagePositionPatient, imageOrientationPatient, displaySet, frameOfReferenceUid); if (segPresentationImage != null) { IDisplaySet targetDisplaySet = displaySet.CreateFreshCopy(); targetImageBox.DisplaySet = targetDisplaySet; // TODO - verify whether any of the Selected properties need re-setting isLoaded = true; break; } } else { IImageSopProvider imageSopProvider = displaySet.PresentationImages.OfType <IImageSopProvider>().FirstOrDefault(); if (imageSopProvider != null && imageSopProvider.Frame.SeriesInstanceUid == seriesInstanceUid) { IDisplaySet targetDisplaySet = displaySet.CreateFreshCopy(); targetImageBox.DisplaySet = targetDisplaySet; // TODO - verify whether any of the Selected properties need re-setting isLoaded = true; break; } } } if (isLoaded) { break; } } } } return(isLoaded); }
internal ImageBoxDrawingEventArgs(IImageBox imageBox) { Platform.CheckForNullReference(imageBox, "imageBox"); _imageBox = imageBox; }
public void SetTileLayout(IImageBox imageBox) { _setTileLayout(imageBox); }
private static bool CanExplodeTiles(IImageBox imageBox) { return(imageBox.Tiles.Count > 1 && !imageBox.ParentPhysicalWorkspace.Locked); }
private void CancelExplodeMode() { _unexplodeMemento = null; _oldImageBox = null; OnCheckedChanged(); }
private void CaptureBeginState(IImageBox imageBox) { _memorableCommand = new MemorableUndoableCommand(imageBox) {BeginState = imageBox.CreateMemento()}; // Capture state before stack _currentImageBox = imageBox; _initialPresentationImageIndex = imageBox.SelectedTile.PresentationImageIndex; }
protected virtual void OnSliceSetChanged() { _sliceImageBox = null; EventsHelper.Fire(this.SliceSetChanged, this, EventArgs.Empty); }
private static void AdvanceImage(int increment, IImageBox selectedImageBox) { int prevTopLeftPresentationImageIndex = selectedImageBox.TopLeftPresentationImageIndex; selectedImageBox.TopLeftPresentationImageIndex += increment; if (selectedImageBox.TopLeftPresentationImageIndex != prevTopLeftPresentationImageIndex) selectedImageBox.Draw(); }
private CrossHair GetCrosshair(IImageBox imageBox) { CrossHair crossHair = _crosshairs.Find( delegate(CrossHair test) { return test.ImageBox == imageBox; }); if (crossHair == null) { crossHair = new CrossHair(imageBox, this); _crosshairs.Add(crossHair); } return crossHair; }
public void ShowImageWithAnnotation(string aimUid) { if (_activeViewer == null) { return; } // Find Annotation aim_dotnet.Annotation annotationToShow = null; foreach (aim_dotnet.Annotation annotation in AvailableAnnotations) { if (annotation.UniqueIdentifier == aimUid) { annotationToShow = annotation; break; } } if (annotationToShow == null) { _activeViewer.DesktopWindow.ShowMessageBox("Could not locate annotation (UID = " + aimUid + ").", MessageBoxActions.Ok); return; } aim_dotnet.ImageStudy studyToOpen = AimStudyFromAnnotation(annotationToShow); if (studyToOpen == null) { _activeViewer.DesktopWindow.ShowMessageBox("Error reading image information (annotation UID = " + aimUid + ").", MessageBoxActions.Ok); return; } // Search displayed images first foreach (IImageBox imageBox in _activeViewer.PhysicalWorkspace.ImageBoxes) { if (imageBox.DisplaySet == null || imageBox.DisplaySet.PresentationImages == null || imageBox.DisplaySet.PresentationImages.Count == 0) { continue; } IImageSopProvider imageSopProvider = imageBox.DisplaySet.PresentationImages[0] as IImageSopProvider; if (imageSopProvider == null) { continue; } if (imageSopProvider.ImageSop.StudyInstanceUid == studyToOpen.InstanceUID && imageSopProvider.ImageSop.SeriesInstanceUid == studyToOpen.Series.InstanceUID) { foreach (IPresentationImage presentationImage in imageBox.DisplaySet.PresentationImages) { imageSopProvider = presentationImage as IImageSopProvider; if (imageSopProvider == null) { continue; } if (imageSopProvider.ImageSop.SopInstanceUid == studyToOpen.Series.ImageCollection[0].SopInstanceUID) { try { imageBox.TopLeftPresentationImage = presentationImage; imageBox.Tiles[0].Select(); this.SelectAimGraphic(presentationImage, aimUid); imageBox.Draw(); return; } catch (Exception ex) { ExceptionHandler.Report(ex, _desktopWindow); } } } } } // Search other available images foreach (IImageSet imageSet in _activeViewer.LogicalWorkspace.ImageSets) { foreach (IDisplaySet displaySet in imageSet.DisplaySets) { if (displaySet.PresentationImages.Count > 0) { IImageSopProvider imageSopProvider = displaySet.PresentationImages[0] as IImageSopProvider; if (imageSopProvider == null) { continue; } if (imageSopProvider.ImageSop.StudyInstanceUid == studyToOpen.InstanceUID && imageSopProvider.ImageSop.SeriesInstanceUid == studyToOpen.Series.InstanceUID) { foreach (IPresentationImage presentationImage in displaySet.PresentationImages) { imageSopProvider = presentationImage as IImageSopProvider; if (imageSopProvider == null) { continue; } if (imageSopProvider.ImageSop.SopInstanceUid == studyToOpen.Series.ImageCollection[0].SopInstanceUID) { try { IImageBox targetImageBox = _activeViewer.PhysicalWorkspace.SelectedImageBox ?? (_activeViewer.PhysicalWorkspace.ImageBoxes.Count > 0 ? _activeViewer.PhysicalWorkspace.ImageBoxes[0] : null); if (targetImageBox == null) { _activeViewer.DesktopWindow.ShowMessageBox("Failed to find available display", MessageBoxActions.Ok); Platform.Log(LogLevel.Error, "Failed to locate a target ImageBox to display requested annotation (aimUID=" + aimUid + ")."); return; } IDisplaySet targetDisplaySet = displaySet.CreateFreshCopy(); IPresentationImage targetPresentationImage = FindRequiredImage(targetDisplaySet.PresentationImages, studyToOpen.InstanceUID, studyToOpen.Series.InstanceUID, studyToOpen.Series.ImageCollection[0].SopInstanceUID); if (targetPresentationImage == null) { _activeViewer.DesktopWindow.ShowMessageBox("Failed to find required image", MessageBoxActions.Ok); Platform.Log(LogLevel.Error, "Failed to locate a target ImageBox to display requested annotation (aimUID=" + aimUid + ")."); return; } targetImageBox.DisplaySet = targetDisplaySet; targetImageBox.TopLeftPresentationImage = targetPresentationImage; targetImageBox.Tiles[0].Select(); this.SelectAimGraphic(targetPresentationImage, aimUid); targetImageBox.Draw(); return; } catch (Exception ex) { ExceptionHandler.Report(ex, _desktopWindow); } } } } } } } }
private static void UnselectCurrentGraphics(IImageBox imageBox) { if (imageBox == null) return; if (imageBox.TopLeftPresentationImage != null) { imageBox.TopLeftPresentationImage.SelectedGraphic = null; imageBox.Draw(); } }
public void AdvanceDisplaySet(int direction) { if (!Enabled) { return; } IDisplaySet sourceDisplaySet = GetSourceDisplaySet(); if (sourceDisplaySet == null) { return; } IImageBox imageBox = base.Context.Viewer.SelectedImageBox; IImageSet parentImageSet = sourceDisplaySet.ParentImageSet; int sourceDisplaySetIndex = parentImageSet.DisplaySets.IndexOf(sourceDisplaySet); sourceDisplaySetIndex += direction; try { if (sourceDisplaySetIndex < 0) { #if SUINING ImageSop sop = ((IImageSopProvider)imageBox.TopLeftPresentationImage).ImageSop; if (sop.Modality == "DX" || sop.Modality == "CR") { return; } #endif if (base.Context.Viewer.LogicalWorkspace.ImageSets.Count >= 2) { int tempNum = 0; foreach (IImageSet set in base.Context.Viewer.LogicalWorkspace.ImageSets) { if (set.Equals(parentImageSet)) { tempNum++; break; } tempNum++; } if (tempNum >= base.Context.Viewer.LogicalWorkspace.ImageSets.Count) { tempNum = 0; } parentImageSet = base.Context.Viewer.LogicalWorkspace.ImageSets[tempNum]; sourceDisplaySetIndex = 0; } else { sourceDisplaySetIndex = parentImageSet.DisplaySets.Count - 1; } } else if (sourceDisplaySetIndex >= parentImageSet.DisplaySets.Count) { #if SUINING ImageSop sop = ((IImageSopProvider)imageBox.TopLeftPresentationImage).ImageSop; if (sop.Modality == "DX" || sop.Modality == "CR" || sop.Modality == "RF") { return; } #endif if (base.Context.Viewer.LogicalWorkspace.ImageSets.Count >= 2) { int tempNum = 0; foreach (IImageSet set in base.Context.Viewer.LogicalWorkspace.ImageSets) { if (set.Equals(parentImageSet)) { tempNum++; break; } tempNum++; } if (tempNum >= base.Context.Viewer.LogicalWorkspace.ImageSets.Count) { tempNum = 0; } parentImageSet = base.Context.Viewer.LogicalWorkspace.ImageSets[tempNum]; sourceDisplaySetIndex = 0; } else { sourceDisplaySetIndex = 0; } } //MemorableUndoableCommand memorableCommand = new MemorableUndoableCommand(imageBox); //memorableCommand.BeginState = imageBox.CreateMemento(); imageBox.DisplaySet = parentImageSet.DisplaySets[sourceDisplaySetIndex].CreateFreshCopy(); if (direction < 0) { imageBox.TopLeftPresentationImageIndex = imageBox.DisplaySet.PresentationImages.Count - 1; } thumbileChanged(imageBox.DisplaySet); imageBox.Draw(); } catch (Exception ex) { } //memorableCommand.EndState = imageBox.CreateMemento(); //DrawableUndoableCommand historyCommand = new DrawableUndoableCommand(imageBox); //historyCommand.Enqueue(memorableCommand); //base.Context.Viewer.CommandHistory.AddCommand(historyCommand); }
private void RemoveUnexplodeCommand(IImageBox imageBox) { if (_unexplodeCommands.ContainsKey(imageBox)) { _unexplodeCommands[imageBox].Dispose(); _unexplodeCommands.Remove(imageBox); } }
public void ShowImageWithAnnotation(string aimUid) { if (_activeViewer == null) { return; } // Find Annotation IAimAnnotationInstance annotationToShow = AvailableAnnotations.FirstOrDefault(annotation => annotation.UniqueIdentifier == aimUid); if (annotationToShow == null) { _activeViewer.DesktopWindow.ShowMessageBox("Could not locate annotation (UID = " + aimUid + ").", MessageBoxActions.Ok); return; } string studyInstanceUid; string seriesInstanceUid; string sopInstanceUid = null; int frameNumber = 1; if (annotationToShow is IAimImageAnnotationInstace) { var imageAnnotationToShow = (IAimImageAnnotationInstace)annotationToShow; studyInstanceUid = imageAnnotationToShow.ImageStudyUid; seriesInstanceUid = imageAnnotationToShow.ImageSeriesUid; sopInstanceUid = imageAnnotationToShow.FirstImageSopInstanceUid; frameNumber = imageAnnotationToShow.FirstFrameNumber; } else { studyInstanceUid = annotationToShow.ParentAimDocument.StudyInstanceUid; seriesInstanceUid = annotationToShow.ParentAimDocument.SeriesInstanceUid; } if (studyInstanceUid == null || seriesInstanceUid == null) { _activeViewer.DesktopWindow.ShowMessageBox("Error reading image information (annotation UID = " + aimUid + ").", MessageBoxActions.Ok); return; } // Search displayed images first foreach (IImageBox imageBox in _activeViewer.PhysicalWorkspace.ImageBoxes) { if (imageBox.DisplaySet == null || imageBox.DisplaySet.PresentationImages == null || imageBox.DisplaySet.PresentationImages.Count == 0) { continue; } IImageSopProvider imageSopProvider = imageBox.DisplaySet.PresentationImages[0] as IImageSopProvider; if (imageSopProvider == null) { continue; } if (imageSopProvider.ImageSop.StudyInstanceUid == studyInstanceUid && imageSopProvider.ImageSop.SeriesInstanceUid == seriesInstanceUid) { foreach (IPresentationImage presentationImage in imageBox.DisplaySet.PresentationImages) { imageSopProvider = presentationImage as IImageSopProvider; if (imageSopProvider == null) { continue; } // Note: will select the first image if there is no SOP Instance UID if (sopInstanceUid == null || (imageSopProvider.ImageSop.SopInstanceUid == sopInstanceUid && imageSopProvider.Frame.FrameNumber == frameNumber)) { try { // Unselect selected in a different image box if (!imageBox.Selected) { UnselectCurrentGraphics(_activeViewer.PhysicalWorkspace.SelectedImageBox); } imageBox.TopLeftPresentationImage = presentationImage; imageBox.Tiles[0].Select(); SelectAimGraphic(presentationImage, aimUid); imageBox.Draw(); return; } catch (Exception ex) { ExceptionHandler.Report(ex, _desktopWindow); } } } } } // Search other available images foreach (IImageSet imageSet in _activeViewer.LogicalWorkspace.ImageSets) { foreach (IDisplaySet displaySet in imageSet.DisplaySets) { if (displaySet.PresentationImages.Count > 0) { IImageSopProvider imageSopProvider = displaySet.PresentationImages[0] as IImageSopProvider; if (imageSopProvider == null) { continue; } if (imageSopProvider.ImageSop.StudyInstanceUid == studyInstanceUid && imageSopProvider.ImageSop.SeriesInstanceUid == seriesInstanceUid) { foreach (IPresentationImage presentationImage in displaySet.PresentationImages) { imageSopProvider = presentationImage as IImageSopProvider; if (imageSopProvider == null) { continue; } // Note: will select the first image if there is no SOP Instance UID if (sopInstanceUid == null || (imageSopProvider.ImageSop.SopInstanceUid == sopInstanceUid && imageSopProvider.Frame.FrameNumber == frameNumber)) { try { IImageBox targetImageBox = _activeViewer.PhysicalWorkspace.SelectedImageBox ?? (_activeViewer.PhysicalWorkspace.ImageBoxes.Count > 0 ? _activeViewer.PhysicalWorkspace.ImageBoxes[0] : null); if (targetImageBox == null) { _activeViewer.DesktopWindow.ShowMessageBox("Failed to find available display", MessageBoxActions.Ok); Platform.Log(LogLevel.Error, "Failed to locate a target ImageBox to display requested annotation (aimUID=" + aimUid + ")."); return; } IDisplaySet targetDisplaySet = displaySet.CreateFreshCopy(); IPresentationImage targetPresentationImage = FindRequiredImage(targetDisplaySet.PresentationImages, studyInstanceUid, seriesInstanceUid, sopInstanceUid, frameNumber); if (targetPresentationImage == null) { _activeViewer.DesktopWindow.ShowMessageBox("Failed to find required image", MessageBoxActions.Ok); Platform.Log(LogLevel.Error, "Failed to locate a target ImageBox to display requested annotation (aimUID=" + aimUid + ")."); return; } // Unselect selected in a different image box if (!targetImageBox.Selected) { UnselectCurrentGraphics(_activeViewer.PhysicalWorkspace.SelectedImageBox); } targetImageBox.DisplaySet = targetDisplaySet; targetImageBox.TopLeftPresentationImage = targetPresentationImage; targetImageBox.Tiles[0].Select(); SelectAimGraphic(targetPresentationImage, aimUid); targetImageBox.Draw(); return; } catch (Exception ex) { ExceptionHandler.Report(ex, _desktopWindow); } } } } } } } }
private IEnumerable<DicomImagePlane> GetTargetImagePlanes(IImageBox imageBox) { for (int i = imageBox.DisplaySet.PresentationImages.Count - 1; i >= 0; --i) { DicomImagePlane targetImagePlane = DicomImagePlane.FromImage(imageBox.DisplaySet.PresentationImages[i]); if (targetImagePlane != null && _referencePlane.IsInSameFrameOfReference(targetImagePlane)) yield return targetImagePlane; } }
private void SynchronizeImageBox(IImageBox referenceImageBox, IImageBox targetImageBox) { if (referenceImageBox.TopLeftPresentationImage == null) return; if (targetImageBox.TopLeftPresentationImage == null) return; DicomImagePlane referenceImagePlane = DicomImagePlane.FromImage(referenceImageBox.TopLeftPresentationImage); if (referenceImagePlane == null) return; IEnumerable<DicomImagePlane> targetImagePlanes = GetAllImagePlanes(targetImageBox); DicomImagePlane targetImagePlane = GetClosestParallelImagePlane(referenceImagePlane, targetImagePlanes); if (targetImagePlane == null) return; int lastIndex = targetImageBox.TopLeftPresentationImageIndex; targetImageBox.TopLeftPresentationImage = targetImagePlane.SourceImage; if (lastIndex != targetImageBox.TopLeftPresentationImageIndex) { if (!_imageBoxesToDraw.Contains(targetImageBox)) _imageBoxesToDraw.Add(targetImageBox); } }
private bool IsReferenceImageBox(IImageBox imageBox) { return(imageBox == _referencePlane.SourceImage.ParentDisplaySet.ImageBox); }
private bool IsReferenceImageBox(IImageBox imageBox) { return imageBox == _referencePlane.SourceImage.ParentDisplaySet.ImageBox; }
//private static void AdvanceImage(int increment, IImageBox selectedImageBox) private void AdvanceImage(int increment, IImageBox selectedImageBox) { if (increment > 0) { GlobalData.direct = 1; } else { GlobalData.direct = -1; } int prevTopLeftPresentationImageIndex = selectedImageBox.TopLeftPresentationImageIndex; selectedImageBox.TopLeftPresentationImageIndex += increment; if (selectedImageBox.TopLeftPresentationImageIndex != prevTopLeftPresentationImageIndex) { selectedImageBox.Draw(); } else { ImageViewerComponent view = this.ImageViewer as ImageViewerComponent; ActionModelNode node = view.ToolbarModel; ActionModelNode tempNode = null; IAction [] action = null; foreach (ActionModelNode tempnode in node.ChildNodes) { if (tempnode.PathSegment.ResourceKey == "ToolbarSynchronizeStacking") { tempNode = tempnode; break; } } if (tempNode != null) { action = tempNode.GetActionsInOrder(); } if ((action != null) && (action.Count() > 0)) { ButtonAction ac = action[0] as ButtonAction; if (ac.Checked == true) { return; } } if (selectedImageBox.TopLeftPresentationImage == null) { return; } #if SUINING ImageSop sop = ((IImageSopProvider)selectedImageBox.TopLeftPresentationImage).ImageSop; if (sop.Modality == "CT" || sop.Modality == "MR") { return; } #endif if (increment > 0) { AdvanceDisplaySet(1); } else { AdvanceDisplaySet(-1); } } }
private static bool CanExplodeImageBox(IImageBox imageBox) { if (imageBox == null) return false; if (imageBox.ParentPhysicalWorkspace == null) return false; if (imageBox.DisplaySet == null || imageBox.SelectedTile == null || imageBox.SelectedTile.PresentationImage == null) return false; return true; }