public static bool IsMultiFormatCell(MedViewerControlCell cell)
{
//if (cell.IsEmpty) return false;
//var dataHeader = cell.Image.CurrentPage.ImageHeader.DicomHeader;
//if (dataHeader.ContainsKey("ImageType"))
//{
// var imageType = dataHeader["ImageType"];
// if (imageType == FilmingUtility.MultiFormatCellImageType) return true;
//}
return(false);
}
/// <summary>
/// change a selected cell to layout cell,the selected cell will hold.
/// </summary>
/// <param name="replacedCell">the cell which will be replaced to layout cell</param>
/// <param name="multiFormatLayout">the new layout cell's layout</param>
/// <returns>the new layout cell</returns>
public static MedViewerLayoutCell InsertMultiFormatToCell(MedViewerControlCell replacedCell, FilmLayout multiFormatLayout)
{
try
{
if (multiFormatLayout == null)
{
Logger.LogError("The multiFormatLayout can not be NULL!");
return(null);
}
if (multiFormatLayout.LayoutType != LayoutTypeEnum.StandardLayout)
{
Logger.LogError("MultiFormat Cell don't support defined layout, just standard layout!");
return(null);
}
if (replacedCell == null)
{
Logger.LogError("The cell will be replaced is NULL!");
return(null);
}
var parentLayoutCell = replacedCell.ParentCell as MedViewerLayoutCell;
if (parentLayoutCell != null)
{
var newMultiLayoutCell = new MedViewerLayoutCell
{
Rows = multiFormatLayout.LayoutRowsSize,
Columns = multiFormatLayout.LayoutColumnsSize
};
//NOTE: don't specify the cell index, need the parent child index of this cell.
var replacedCellIndex = parentLayoutCell.Children.ToList().IndexOf(replacedCell);
parentLayoutCell.ReplaceCell(newMultiLayoutCell, replacedCellIndex);
newMultiLayoutCell.AddCell(replacedCell);
parentLayoutCell.Refresh();
return(newMultiLayoutCell);
}
Logger.LogError("The cell will be replaced parent is NULL!");
return(null);
}
catch (Exception ex)
{
Logger.LogError(ex.StackTrace);
throw;
}
}
public static void SetAllActionExceptLeftButton(MedViewerControlCell cell)
{
if (cell == null || cell.Image == null || cell.Image.CurrentPage == null)
{
return;
}
//|| cell.Image.CurrentPage.IsTableOrCurve) return;
SetAction(cell, ActionType.Windowing,
MouseButton.Middle);
SetAction(cell, ActionType.Pan,
MouseButton.XButton1);
SetAction(cell, ActionType.Zoom,
MouseButton.Right);
}
public static void UnselectOtherCellsInViewport(McsfFilmViewport viewport, MedViewerControlCell cell, bool _isGroupLRButtonDown = false)
{
//if (cell.ViewerControl.CellHoldedByAction != null)
//{
// cell.ViewerControl.CellHoldedByAction.ForceEndAction();
//}
var cells = viewport.GetCells();
foreach (var aCell in cells)
{
if (aCell.IsSelected && aCell != cell && !_isGroupLRButtonDown)
{
aCell.IsSelected = false;
}
}
}
public static string StudyIdOfCell(this MedViewerControlCell cell)
{
var temp = string.Empty;
if (cell.Image != null && cell.Image.CurrentPage != null)
{
var dicomHeader = cell.Image.CurrentPage.ImageHeader.DicomHeader;
if (dicomHeader.ContainsKey(ServiceTagName.StudyInstanceUID))
{
temp = dicomHeader[ServiceTagName.StudyInstanceUID];
}
}
return(temp);
}
public static void ColorInverse(this MedViewerControlCell cell)
{
try
{
foreach (var dd in cell.Image.Pages)
{
dd.PState.IsPaletteReversed = !dd.PState.IsPaletteReversed;
}
cell.Refresh();
}
catch (Exception ex)
{
Logger.LogError(ex.Message + ex.StackTrace);
throw;
}
}
public static bool IsShutterSelected(this MedViewerControlCell cell)
{
if (cell.Image != null && cell.Image.CurrentPage != null)
{
var page = cell.Image.CurrentPage;
var o = page.GetOverlay(OverlayType.MRShutter);
if (o == null)
{
return(false);
}
//return o.Graphics.Any(gb => gb.IsSelected);
return(o.SelectedGraphics != null && o.SelectedGraphics.Count > 0);
}
return(false);
}
public static void ZoomCell(MedViewerControlCell cell, double scaleX, double scaleY, bool needRefresh)
{
double scaleXNew = Math.Abs(scaleX / cell.Image.CurrentPage.PState.ScaleX);
double scaleYNew = Math.Abs(scaleY / cell.Image.CurrentPage.PState.ScaleY);
cell.Image.CurrentPage.PState.CanRaiseValueChangedEvent = false;
cell.Image.CurrentPage.PState.ScaleByRenderCenter(scaleXNew, scaleYNew);
cell.Image.CurrentPage.PState.CanRaiseValueChangedEvent = true;
if (needRefresh)
{
cell.Refresh();
}
else
{
cell.Image.CurrentPage.IsDirty = true;
}
}
public static void SetAction(MedViewerControlCell cell, ActionType actionType, MouseButton button = MouseButton.Left)
{
//fix bug 167574 2012/10/29, E-film has no action except windowing
if (cell.Image == null || IsMultiFormatCell(cell) || (IsRoiAction(actionType) && (IsStitchingCell(cell))))
{
cell.SetAction(ActionType.Pointer, button);
return;
}
if (IsRoiAction(actionType) && IsSCCell(cell))
{
cell.SetAction(ActionType.Empty, button);
return;
}
cell.SetAction(actionType, button);
}
private void WindowingCell(MedViewerControlCell cell, WindowLevel winLevel, bool needRefresh)
{
cell.Image.CurrentPage.PState.CanRaiseValueChangedEvent = false;
cell.Image.CurrentPage.PState.WindowLevel = winLevel;
cell.Image.CurrentPage.PState.CanRaiseValueChangedEvent = true;
if (needRefresh)
{
cell.Refresh(CellRefreshType.Image);
if (cell.ActualWidth >= FilmingUtility.FilmingPageSyncBoundary && cell.ActualHeight >= FilmingUtility.FilmingPageSyncBoundary)
{
cell.Refresh(CellRefreshType.ImageText);
}
}
else
{
cell.Image.CurrentPage.IsDirty = true;
}
}
public static void SetSUVTypeForCell(MedViewerControlCell cell, string SUVType)
{
try
{
Logger.LogFuncUp();
if (CellModality(cell) != Modality.PT)
{
return;
}
cell.Image.SetDataUnit(SUVType);
cell.Refresh();
Logger.LogFuncDown();
}
catch (Exception ex)
{
Logger.LogWarning(ex.StackTrace);
}
}
public static McsfFilmViewport ViewportOfCell(MedViewerControlCell cell, FilmingPageControl page)
{
var viewport = ViewportOfCell(cell, page.ViewportList);
if (viewport == null)
{
page.ReBuildViewportList();
viewport = ViewportOfCell(cell, page.ViewportList);
}
//if (viewport == null)
//{
// Logger.LogError(string.Format("Failed to get viewport of cell in page {0}", page.FilmPageTitle));
//}
return(viewport);
}
private static bool IsStitchingCell(MedViewerControlCell cell)
{
if (cell == null)
{
return(false);
}
var image = cell.Image;
if (image == null)
{
return(false);
}
var displayData = image.CurrentPage;
if (displayData == null)
{
return(false);
}
var imageHeader = displayData.ImageHeader;
if (imageHeader == null)
{
return(false);
}
var dataHeader = imageHeader.DicomHeader;
if (dataHeader == null)
{
return(false);
}
//string modality = string.Empty;
var imageType = string.Empty;
//if (dataHeader.ContainsKey("Modality")) modality = dataHeader["Modality"];
if (dataHeader.ContainsKey(ServiceTagName.ImageType))
{
imageType = dataHeader[ServiceTagName.ImageType];
}
if (imageType == FilmingUtility.StitchingImageType)
{
return(true);
}
return(false);
}
public static void FitToWindowByShort(this MedViewerControlCell cell)
{
try
{
if (cell.Image != null && cell.Image.Pages.Any())
{
foreach (var dd in cell.Image.Pages)
{
dd.FitAndFillWindow();
}
cell.Refresh();
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message + ex.StackTrace);
throw;
}
}
public static void UnselectCellInViewport(McsfFilmViewport viewport, MedViewerControlCell cell)
{
if (cell == null)
{
return;
}
if (viewport == null)
{
cell.IsSelected = false;
return;
}
var cells = viewport.GetCells();
cell.IsSelected = false;
if (cells.All(c => !c.IsSelected))
{
viewport.IsSelected = false;
}
}
/// <summary>
/// 设置minicell的状态
/// </summary>
/// <param name="pageList"></param>IEnumerable<FilmingPageControl> pageList
/// <param name="args"></param>
//public static void MakeSingleUseCellSelectStatus(List<MedViewerControlCell> cellList , SingleUseCellSelectedEventArgs args)
//{
// foreach (var cell in cellList)
// {
// var overlayLocalizedImage = cell.Image.CurrentPage.GetOverlay(OverlayType.LocalizedImage) as OverlayLocalizedImage;
// if (null != overlayLocalizedImage)
// {
// pageControl.IsSelected = true;
// viewport.IsSelected = true;
// overlayLocalizedImage.GraphicLocalizedImage.MiniCell.IsSelected = true;
// //shouldBreakFilmingPage = true;
// //break;
// }
// }
//}
#endregion
public static void GetMinMaxInfoFromStartAndEndSelections(
FilmingPageControl startPage, McsfFilmViewport startViewport, MedViewerControlCell startCell,
FilmingPageControl endPage, McsfFilmViewport endViewport, MedViewerControlCell endCell,
out FilmingPageControl minPage, out FilmingPageControl maxPage,
out int minViewportIndex, out int maxViewportIndex,
out int minCellIndex, out int maxCellIndex)
{
minPage = (startPage.FilmPageIndex > endPage.FilmPageIndex) ? endPage : startPage;
maxPage = (minPage == endPage) ? startPage : endPage;
minViewportIndex = (startPage.FilmPageIndex == minPage.FilmPageIndex) ? startViewport.IndexInFilm : endViewport.IndexInFilm;
maxViewportIndex = (startPage.FilmPageIndex == maxPage.FilmPageIndex) ? startViewport.IndexInFilm : endViewport.IndexInFilm;
minCellIndex = (startPage.FilmPageIndex == minPage.FilmPageIndex) ? startCell.CellIndex : endCell.CellIndex;
maxCellIndex = (startPage.FilmPageIndex == maxPage.FilmPageIndex) ? startCell.CellIndex : endCell.CellIndex;
// same page
if (minPage.FilmPageIndex == maxPage.FilmPageIndex)
{
minViewportIndex = Math.Min(startViewport.IndexInFilm, endViewport.IndexInFilm);
maxViewportIndex = Math.Max(startViewport.IndexInFilm, endViewport.IndexInFilm);
// same viewport
if (startViewport.IndexInFilm == endViewport.IndexInFilm)
{
minCellIndex = Math.Min(startCell.CellIndex, endCell.CellIndex);
maxCellIndex = Math.Max(startCell.CellIndex, endCell.CellIndex);
}
else
{
// different viewport
if (minViewportIndex == startViewport.IndexInFilm)
{
minCellIndex = startCell.CellIndex;
maxCellIndex = endCell.CellIndex;
}
else /*(minViewportIndex == endViewport.Index)*/
{
minCellIndex = endCell.CellIndex;
maxCellIndex = startCell.CellIndex;
}
}
}
}
private static bool IsSCCell(MedViewerControlCell cell)
{
if (cell == null)
{
return(false);
}
var image = cell.Image;
if (image == null)
{
return(false);
}
var displayData = image.CurrentPage;
if (displayData == null)
{
return(false);
}
return(displayData.IsSecondCapture);
}
public static void SetEnhancementCell(MedViewerControlCell cell, string enhanceTag, bool needRefresh)
{
if (null != cell &&
null != cell.Image &&
null != cell.Image.CurrentPage &&
(Modality.CT == cell.Image.CurrentPage.Modality || Modality.MG == cell.Image.CurrentPage.Modality))
{
if (!cell.Image.CurrentPage.PState.EnhancePara.Equals(Convert.ToDouble(enhanceTag)))
{
cell.Image.CurrentPage.PState.EnhancePara = Convert.ToDouble(enhanceTag);
if (needRefresh)
{
cell.Refresh();
}
else
{
cell.Image.CurrentPage.IsDirty = true;
}
}
}
}
public void FillTagsFrom(MedViewerControlCell sampleCell)
{
try
{
Logger.LogFuncUp();
this.PatientName = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.PatientName);
this.PatientId = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.PatientID);
this.PatientBirthDate = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.PatientBirthDate);
this.PatientSex = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.PatientSex);
this.PatientsBirthTime = string.Empty;
this.PatientsAge = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.PatientAge);
this.InstitutionName = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.InstitutionName);
this.Manufacturer = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.Manufacturer);
this.StudyInstanceUid = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.StudyInstanceUID);
this.StudyDate = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.StudyDate);
this.StudyTime = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.StudyTime);
this.PatientComments = string.Empty;
this.ReferringPhysiciansName = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.ReferringPhysicianName);
this.PatientsSize = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.PatientSize);
this.PatientsWeight = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.PatientWeight);
this.Occupation = string.Empty;
this.AccessionNumber = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.AccessionNumber);
//this.EFilmModality = Widget.GetTagValueFromCell(sampleCell, "Modality");
//this.EFilmSeriesUid = string.Empty; //todo:生成seriesUID
this.ProtocolName = string.Empty;
this.BodyPartExamined = string.Empty;
this.PatientPosition = string.Empty;
this.AcquisitionNumber = string.Empty;
this.ImagesInAcquisition = string.Empty;
this.ImageComments = Widget.GetTagValueFromCell(sampleCell, ServiceTagName.ImageComments);
this.BurnedInAnnotation = string.Empty;
Logger.LogFuncDown();
}
catch (Exception ex)
{
Logger.LogFuncException(ex.Message + ex.StackTrace);
}
}
public static MedViewerControlCell Clone(this MedViewerControlCell cell)
{
try
{
var duplicatedCell = new MedViewerControlCell();
if (cell.Image != null && cell.Image.Pages != null && cell.Image.Pages.Any())
{
//fix bug 154567 2012-09-19
var filmingCard = FilmingViewerContainee.FilmingViewerWindow as FilmingCard;
if (filmingCard != null)
{
if (dataAccessor == null)
{
dataAccessor = new DataAccessor(filmingCard.FilmingViewerConfiguration); //use filming card 's configuration, //why default configuration not use filming's
}
var sourceDisplayData = cell.Image.Pages.First();
var dd = dataAccessor.CopyImageDataForFilmingF1(sourceDisplayData);
dd.UserSpecialInfo = sourceDisplayData.UserSpecialInfo;
dd.Tag = sourceDisplayData.Tag.DeepClone();
if (null != sourceDisplayData.DicomHeader)
{
dd.DicomHeader = sourceDisplayData.DicomHeader;
}
duplicatedCell.Image.AddPage(dd);
}
}
return(duplicatedCell);
}
catch (Exception ex)
{
Logger.LogError(ex.StackTrace);
throw;
}
}
private static McsfFilmViewport ViewportOfCell(MedViewerControlCell cell, List <McsfFilmViewport> viewportList)
{
if (cell == null)
{
return(null);
}
var layoutCell = cell.ParentCell as MedViewerLayoutCell;
while (layoutCell != null)
{
foreach (var viewport in viewportList)
{
if (viewport.RootLayoutCell == layoutCell)
{
return(viewport);
}
}
layoutCell = layoutCell.ParentCell as MedViewerLayoutCell;
}
return(null);
}
public static void SetAllActions(MedViewerControlCell cell, ActionType action)
{
SetAllActionExceptLeftButton(cell);
SetAction(cell, action);
}
public RefreshRegion(IList <FilmingPageControl> pages, FilmingLayoutCell startLayoutCell, MedViewerControlCell startControlCell, IList <MedViewerControlCell> replaceControlCells)
{
_pages = pages;
_startLayoutCell = startLayoutCell;
_startControlCell = startControlCell;
_replaceControlCells = replaceControlCells;
}
public void AddFilmPage(PageModel pageModel, bool ifPageNo)
{
try
{
Logger.LogFuncUp();
this.FilmTitleViewModel.ResetModel(pageModel.PageTitleInfoModel);
var rootCell = this._filmingViewerControl.LayoutManager.RootCell;
rootCell.RemoveAll();
//rootCell.BorderThickness = -1D;
rootCell.SetBorderThicknessWithoutRefresh(-1D);
this._filmingViewerControl.LayoutManager.SetLayoutByXML(pageModel.Layout, new Func <MedViewerLayoutCell>(() => { return(new MedViewerLayoutCell()
{
BorderThickness = -1D, CellControlMargin = 0
}); }));
this._filmingViewerControl.GraphicContextMenu.GraphicsStatisticItemsMode =
pageModel.PageGraphicOperationModel.GraphicsStatisticItemsMode;
List <MedViewerControlCell> controlCells = new List <MedViewerControlCell>();
foreach (var cellModel in pageModel.CellModels)
{
var cell = new MedViewerControlCell();
controlCells.Add(cell);
var sop = cellModel.Sop as ImageSop;
if (null != sop)
{
var displayData = FilmPageControl.DataAccessorInstance.CreateImageDataForFilming(sop.DicomSource, sop.GetNormalizedPixelData(), cellModel.Ps, cellModel.PtUnit);
cell.Image.AddPage(displayData);
//图元颜色修改
if (pageModel.EFilmModel.IfSaveImageAsGrayScale)
{
var overlayGraphics = displayData.GetOverlay(OverlayType.Graphics) as OverlayGraphics;
if (null != overlayGraphics)
{
foreach (var graphic in overlayGraphics.Graphics)
{
var parent = graphic as IComposed;
if (parent != null)
{
foreach (var obj in parent.Components)
{
var graphicBase = obj as DynamicGraphicBase;
if (graphicBase != null)
{
graphicBase.GeometryProperty.NormalColor = Colors.White; //设置打印图元线颜色
if (!(graphicBase is GraphicText))
{
graphicBase.GeometryProperty.Thickness = 2D; //设置打印图元线宽
}
}
}
}
else
{
var graphicBase = graphic as DynamicGraphicBase;
if (null != graphicBase)
{
graphicBase.GeometryProperty.NormalColor = Colors.White; //设置打印图元线颜色
if (!(graphicBase is GraphicText))
{
graphicBase.GeometryProperty.Thickness = 2D; //设置打印图元线宽
}
}
}
}
}
}
//四角信息配置（出厂and高级应用）
var overlayFilmTxt = displayData.GetOverlay(OverlayType.FilmingText) as OverlayFilmingText;
if (null == overlayFilmTxt)
{
return;
}
overlayFilmTxt.GraphicFilmingImageText.LeftMargin = 0;
overlayFilmTxt.GraphicFilmingImageText.RightMargin = 0;
overlayFilmTxt.GraphicFilmingImageText.BottomMargin = 0;
overlayFilmTxt.GraphicFilmingImageText.TopMargin = 0;
overlayFilmTxt.GraphicFilmingImageText.FontStyle = "Arial";
overlayFilmTxt.GraphicFilmingImageText.ImgTxtMgPostion = cellModel.ImgTxTPosition;
overlayFilmTxt.GraphicFilmingImageText.IsShowOrientation = (cellModel.MgOrientationIsShow == "1"?true:false);
overlayFilmTxt.GraphicFilmingImageText.IsImgTxtShowFromF1 = (cellModel.IsShowImgTxt == "1" ? true : false);
overlayFilmTxt.GraphicFilmingImageText.IsRulerShowFromF1 = (cellModel.IsShowRuler == "1" ? true : false);
if (ImgTxtDisplayState.All == displayData.PState.DisplayMode || ImgTxtDisplayState.Customization == displayData.PState.DisplayMode)
{
string modalities;
mcsf_clr_systemenvironment_config.GetModalityName(out modalities);
if (modalities == "DBT")
{
if (null != overlayFilmTxt.Page &&
null != overlayFilmTxt.Page.Image &&
null != overlayFilmTxt.Page.Image.Cell)
{
var config = overlayFilmTxt.Page.Image.Cell.ViewerControlSetting.Configuration;
config.EntryConfig.ImageTextMap =
Printers.Instance.Modality2FilmingImageTextConfigPath;
}
}
//overlayFilmTxt.ConfigStandardImageText(displayData.ImageHeader.DicomHeader,
// cellModel.ImgTxtFilePathOrContent,
// cellModel.ImgTxtItemPathOrContent);
overlayFilmTxt.GraphicFilmingImageText.GraphicImageText.SerializedContent =
cellModel.ImgTxtFilePathOrContent;
}
else if (ImgTxtDisplayState.FromApplication == displayData.PState.DisplayMode)
{
//ImageTextConfigContent imageTextConfigContent = new ImageTextConfigContent()
// {
// ImageTextFileContent = cellModel.ImgTxtFilePathOrContent,
// //TextItemFileContent = cellModel.ImgTxtItemPathOrContent
// };
//overlayFilmTxt.ConfigApplicationConfigReader(displayData.ImageHeader.DicomHeader, imageTextConfigContent);
overlayFilmTxt.GraphicFilmingImageText.GraphicImageText.SerializedContent =
cellModel.ImgTxtFilePathOrContent;
overlayFilmTxt.GraphicFilmingImageText.GraphicImageText.SerializedDataHeader = cellModel.ImgTxTContent;
}
//定位像参考线
if (!string.IsNullOrEmpty(cellModel.LocalizedImageUid) && null != cellModel.LocalizedImageSop)
{
DisplayData smallDisplayData = DataAccessorInstance.CreateImageData(cellModel.LocalizedImageSop.DicomSource, (cellModel.LocalizedImageSop as ImageSop).GetNormalizedPixelData());
ImgTxtPosEnum pos = ImgTxtPosEnum.Center;
if (!string.IsNullOrEmpty(cellModel.LocalizedImagePSInfo))
{
smallDisplayData.PSXml = cellModel.LocalizedImagePSInfo;
smallDisplayData.DeserializePSInfo();
}
if (!string.IsNullOrEmpty(cellModel.LocalizedImagePosion))
{
Enum.TryParse(cellModel.LocalizedImagePosion, out pos);
overlayFilmTxt.GraphicFilmingImageText.ReferenceLinePos = pos;
overlayFilmTxt.GraphicFilmingImageText.HasReferenceLine = true;
}
DataAccessorInstance.AddOverlayLocalizedImage(displayData, smallDisplayData, pos);
if (pageModel.EFilmModel.IfSaveImageAsGrayScale)
{
var overlayReferenceLine = smallDisplayData.Overlays.FirstOrDefault(n => n is OverlayReferenceLine2Filming) as OverlayReferenceLine2Filming;
if (overlayReferenceLine != null)
{
overlayReferenceLine.LineColor = Colors.White; //设置打印参考线颜色
//overlayReferenceLine.LineThickness = 0.3D; //设置打印参考线线宽
}
}
}
//比例尺
var overlayRuler = displayData.GetOverlay(OverlayType.Ruler) as OverlayRuler;
if (null != overlayRuler)
{
overlayRuler.IsVisible = cellModel.RulerVisible;
overlayRuler.GraphicRuler.MinimalCellSize = 0D;
}
var tagName2Value = new Dictionary <uint, string>();
tagName2Value.Add(ServiceTagName.PatientAge, string.Empty);
tagName2Value.Add(ServiceTagName.PatientID, string.Empty);
tagName2Value.Add(ServiceTagName.PatientName, string.Empty);
tagName2Value.Add(ServiceTagName.PatientSex, string.Empty);
tagName2Value.Add(ServiceTagName.StudyID, string.Empty);
tagName2Value.Add(ServiceTagName.SeriesInstanceUID, string.Empty);
tagName2Value.Add(ServiceTagName.StudyInstanceUID, string.Empty);
tagName2Value.Add(ServiceTagName.Modality, string.Empty);
Widget.GetTagValue(cell, tagName2Value);
cellModel.PatientAge = tagName2Value[ServiceTagName.PatientAge];
cellModel.PatientId = tagName2Value[ServiceTagName.PatientID];
cellModel.PatientsName = tagName2Value[ServiceTagName.PatientName];
cellModel.PatientsSex = tagName2Value[ServiceTagName.PatientSex];
cellModel.StudyId = tagName2Value[ServiceTagName.StudyID];
cellModel.SeriesUid = tagName2Value[ServiceTagName.SeriesInstanceUID];
cellModel.StudyInstanceUid = tagName2Value[ServiceTagName.StudyInstanceUID];
cellModel.Modality = tagName2Value[ServiceTagName.Modality];
}
}
this._filmingViewerControl.AddCells(controlCells);
foreach (var controlCell in controlCells)
{
controlCell.Refresh();
}
//only for PT
this.PageTitle_AddDrugForPT();
var eFilmModel = pageModel.EFilmModel;
if (eFilmModel.IfSaveEFilm)
{
var sampleCell =
controlCells.FirstOrDefault(c => c != null && c.Image != null && c.Image.CurrentPage != null);
if (!eFilmModel.IsMixed)
{
eFilmModel.FillTagsFrom(sampleCell);
string modalities;
mcsf_clr_systemenvironment_config.GetModalityName(out modalities);
eFilmModel.EFilmModality = modalities;
}
}
if (pageModel.EFilmModel.PeerNode.NodeType == PeerNodeType.GENERAL_PRINTER)
{
#region [--纸质打印--]
this.PrintByGeneralPrinter(eFilmModel, ifPageNo);
#endregion
}
else
{
#region [--胶片打印--]
this.GeneralFilms(eFilmModel, ifPageNo);
#endregion
}
ClearViewerControl(_filmingViewerControl);
Logger.LogFuncDown();
}
catch (Exception ex)
{
Logger.LogFuncException(ex.Message + ex.StackTrace);
}
}
private void FillAnnotationToGrid(MedViewerControlCell cell, Grid grid)
{
//////////////////////////////////////////////////////////////////////////
//Assert
Debug.Assert(cell != null);
Debug.Assert(grid != null);
var image = cell.Image;
if (image == null)
{
return;
}
var page = cell.Image.CurrentPage;
if (page == null)
{
return;
}
var overlayText = (OverlayText)page.GetOverlay(OverlayType.Text);
if (overlayText == null)
{
return;
}
var graphicImageText = overlayText.Graphics[0] as GraphicImageText;
if (graphicImageText == null)
{
return;
}
//////////////////////////////////////////////////////////////////////////
//new a 3x3 grid 1:8:1, and add to the cell grid
var r1 = new RowDefinition(); r1.Height = new GridLength(1, GridUnitType.Star);
var r2 = new RowDefinition(); r2.Height = new GridLength(1, GridUnitType.Star);
var r3 = new RowDefinition(); r3.Height = new GridLength(1, GridUnitType.Star);
grid.RowDefinitions.Add(r1);
grid.RowDefinitions.Add(r2);
grid.RowDefinitions.Add(r3);
var c1 = new ColumnDefinition(); c1.Width = new GridLength(1, GridUnitType.Star);
var c2 = new ColumnDefinition(); c2.Width = new GridLength(1, GridUnitType.Star);
var c3 = new ColumnDefinition(); c3.Width = new GridLength(1, GridUnitType.Star);
grid.ColumnDefinitions.Add(c1);
grid.ColumnDefinitions.Add(c2);
grid.ColumnDefinitions.Add(c3);
//////////////////////////////////////////////////////////////////////////
//Traverse four annotation text panel, and fetch texts to fill into the
for (ImgTxtPosEnum pos = 0; pos < ImgTxtPosEnum.Max; pos++)
{
var textPanel = graphicImageText.GetTextItemPanel(pos);
var textGroups = textPanel.Children;
if (textGroups.Count == 0)
{
continue;
}
//new a stackpanel at current pos
var textStack = new StackPanel();
textStack.Orientation = Orientation.Vertical;
textStack.Margin = new Thickness(2, 2, 2, 2);
var viewBox = new Viewbox();
viewBox.Child = textStack;
var point = GetAnnotationPos(pos, viewBox);
Grid.SetColumn(viewBox, (int)point.Y);
Grid.SetRow(viewBox, (int)point.X);
grid.Children.Add(viewBox);
foreach (var item in textGroups)
{
var textGroup = item as GraphicImageText.TextItemGroup;
string textItem = textGroup.TextItemBody.Text;
//add a textBlock with Text = textItem into the stackPanel
var textBlock = new TextBlock()
{
Text = textItem,
FontSize = 5,
FontWeight = FontWeights.Bold,
//Margin = new Thickness(10,0,10,0),
//HorizontalAlignment = System.Windows.HorizontalAlignment.Center,
//VerticalAlignment = System.Windows.VerticalAlignment.Center,
//Opacity = 0.5,
//Foreground = Brushes.White,
//Effect = new DropShadowEffect()
//{
// Color = Colors.Black,
// ShadowDepth = 1
//}
};
textBlock.HorizontalAlignment = textStack.HorizontalAlignment;
textBlock.VerticalAlignment = textStack.VerticalAlignment;
textStack.Children.Add(textBlock);
}
}
//var textControl = graphicImageText.Control;
//grid.Children.Add(null);
}
private void AppendSop(Sop sop, string ps = "")
{
try
{
Logger.LogFuncUp();
//new a cell
var cell = new MedViewerControlCell();
//add display data to cell
var accessor = new DataAccessor(medViewerControl.Configuration); //IViewerConfiguration config = null?
var imgSop = sop as ImageSop;
byte[] pixelData = null;
//string ps = string.Empty;
if (imgSop != null)
{
pixelData = imgSop.GetNormalizedPixelData();
//ps = imgSop.PresentationState;
}
var displayData = accessor.CreateImageDataForFilming(sop.DicomSource, pixelData, ps);
cell.Image.AddPage(displayData);
//add cell to viewcontrol
medViewerControl.LayoutManager.AddControlCell(cell);
//2014-04-15 针对旋转后的图片做适合窗口处理
if (displayData != null && displayData.PState != null)
{
displayData.PState.SetRenderSize((int)medViewerControl.Width, (int)medViewerControl.Height);
displayData.FitWindow();
}
//2014-04-15 针对旋转后的图片做适合窗口处理
//displayData.DeserializePSInfo();
//_viewerControl.OnRaiseImageLoading(displayData);
medViewerControl.Dispatcher.Invoke(new Action(() =>
{
try
{
if (medViewerControl.CellCount > 0)
{
medViewerControl.LayoutManager.Refresh();
}
else
{
cell.Refresh();
}
//OnNewCellAdded
}
catch (Exception exp)
{
Logger.LogError(exp.Message);
}
}));
//cell.DeserializeGraphics();
//_viewerControl.OnRaiseImageLoaded(displayData);
Logger.LogFuncDown();
}
catch (Exception ex)
{
Logger.LogFuncException(ex.Message + ex.StackTrace);
throw;
}
}
public static string GetTagValueFromCell(MedViewerControlCell cell, uint tag)
{
var dicomHeader = cell.Image.CurrentPage.ImageHeader.DicomHeader;
return(dicomHeader.ContainsKey(tag) ? dicomHeader[tag] : string.Empty);
}
public void InitialZoomViewerCell(MedViewerControlCell zoomCell)
{
_zoomViewerCell = zoomCell;
}
/// <summary>
/// Assume that cell is not empty
/// </summary>
/// <param name="cell"></param>
/// <param name="index"></param>
/// <returns></returns>
public static DicomAttributeCollection SaveCellAsDataHeader(MedViewerControlCell cell, int index)
{
try
{
Logger.LogFuncUp();
Debug.Assert(cell != null && cell.Image != null && cell.Image.CurrentPage != null);
var dataHeader = new DicomAttributeCollection();
var displayData = cell.Image.CurrentPage;
var dicomHeader = displayData.ImageHeader.DicomHeader;
var uidManager = McsfDatabaseDicomUIDManagerFactory.Instance().CreateUIDManager();
if (index == 0)
{
SeriesInstanceUid = uidManager.CreateSeriesUID("1", "2", ""); //seriesUID; //
ClearSeries(dicomHeader);
}
//if (displayData.PixelData == null) return null;
var pixelData = displayData.PixelData;
if (pixelData == null)
{
pixelData = new byte[displayData.ImageDataLength];
Marshal.Copy(displayData.ImageDataPtr, pixelData, 0, displayData.ImageDataLength);
}
var element = DicomAttribute.CreateAttribute(Tag.PixelData, VR.OB);
if (!element.SetBytes(0, pixelData))
{
Logger.LogWarning("Failed to Insert NULL image Data to Data header");
}
dataHeader.AddDicomAttribute(element);
FillTags(dicomHeader, dataHeader);
//1. need to fill seriesDescription, from configuration, Default value is 3D-1
FilmingHelper.InsertStringDicomElement(dataHeader, Tag.SeriesDescription, Printers.Instance.NewSeriesDescription);
//2. remove wrong tag
dataHeader.RemoveDicomAttribute(Tag.SmallestImagePixelValue);
dataHeader.RemoveDicomAttribute(Tag.LargestImagePixelValue);
//3. update some tag
dataHeader.RemoveDicomAttribute(Tag.InstanceNumber);
FilmingHelper.InsertStringDicomElement(dataHeader, Tag.InstanceNumber, "" + (index + 1));
dataHeader.RemoveDicomAttribute(Tag.SeriesNumber);
FilmingHelper.InsertStringDicomElement(dataHeader, Tag.SeriesNumber, "" + _seriesNumber);
dataHeader.RemoveDicomAttribute(Tag.SeriesInstanceUid);
FilmingHelper.InsertStringDicomElement(dataHeader, Tag.SeriesInstanceUid, SeriesInstanceUid);
dataHeader.RemoveDicomAttribute(Tag.SOPInstanceUID);
FilmingHelper.InsertStringDicomElement(dataHeader, Tag.SOPInstanceUID, uidManager.CreateImageUID(""));
var ww = FilmingHelper.GetTagValueFrom(dataHeader, ServiceTagName.WindowWidth);
dataHeader.RemoveDicomAttribute(Tag.WindowWidth);
if (dicomHeader.ContainsKey(ServiceTagName.WindowWidth))
{
if (!string.IsNullOrWhiteSpace(ww))
{
FilmingHelper.InsertStringArrayDicomElement(dataHeader, Tag.WindowWidth, dicomHeader[ServiceTagName.WindowWidth]);
}
}
var wc = FilmingHelper.GetTagValueFrom(dataHeader, ServiceTagName.WindowCenter);
dataHeader.RemoveDicomAttribute(Tag.WindowCenter);
if (dicomHeader.ContainsKey(ServiceTagName.WindowCenter))
{
if (!string.IsNullOrWhiteSpace(wc))
{
FilmingHelper.InsertStringArrayDicomElement(dataHeader, Tag.WindowCenter, dicomHeader[ServiceTagName.WindowCenter]);
}
}
if (dicomHeader.ContainsKey(ServiceTagName.ImageType))
{
dataHeader.RemoveDicomAttribute(Tag.ImageType);
FilmingHelper.InsertStringArrayDicomElement(dataHeader, Tag.ImageType, dicomHeader[ServiceTagName.ImageType]);
}
////DICOM File Meta Information
////FillDicomFileMetaInformationTags(dataHeader);
////Patient Module
//FillPatientModuleTags(dataHeader, dicomHeader);
////General Study Module
//FillGeneralStudyModuleTags(dataHeader, dicomHeader);
////Patient Study Module
//FillPatientStudyModuleTags(dataHeader, dicomHeader);
////General Series Module
//FillGeneralSeriesModuleTags(dataHeader, dicomHeader);
////General Equipment Module
//////SC Equipment Module
////FillSCEquipmentModuleTags(dataHeader);
////General Image Module
//FillGeneralImageModuleTags(dataHeader, index, dicomHeader);
//Image Pixel Module
//FilmingHelper.AddConstDICOMAttributes(dataHeader);
//FilmingHelper.InsertUInt16DicomElement(dataHeader, Tag.Columns, (ushort)imageWidth);
//FilmingHelper.InsertUInt16DicomElement(dataHeader, Tag.Rows, (ushort)imageHeight);
////SC Image Module
////FillSCImageModuleTags(dataHeader);
////VOI LUT Module
//FillVoilutMacroTags(dataHeader, dicomHeader);
////SOP Common Module
//FillSopCommonModuleTags(dataHeader, dicomHeader);
Logger.LogFuncDown();
return(dataHeader);
}
catch (Exception ex)
{
Logger.LogFuncException(ex.Message + ex.StackTrace);
return(null);
}
}
