367 lines
16 KiB
C#
367 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using CaeGlobals;
|
|
using CaeMesh;
|
|
|
|
namespace CPSO
|
|
{
|
|
[Serializable]
|
|
public class AnnotationContainer
|
|
{
|
|
// Variables
|
|
private bool _suppressed; // used only for min/max annotations
|
|
public static string MeasureAnnotationName = "Measure_Annotation";
|
|
public static string MinAnnotationName = "Min_Annotation"; // there is a copy of this in vtkControl.Globals
|
|
public static string MaxAnnotationName = "Max_Annotation"; // there is a copy of this in vtkControl.Globals
|
|
//
|
|
private Dictionary<string, AnnotationBase> _geometryAnnotations;
|
|
private Dictionary<string, AnnotationBase> _modelAnnotations;
|
|
private Dictionary<string, Dictionary<string, AnnotationBase>> _allResultsAnnotations;
|
|
|
|
// Properties
|
|
public string CurrentResultName { get { return AnnotationBase.Controller.AllResults.GetCurrentResultName(); } }
|
|
|
|
|
|
// Constructors
|
|
public AnnotationContainer(Controller controller)
|
|
{
|
|
AnnotationBase.Controller = controller;
|
|
//
|
|
_suppressed = false;
|
|
//
|
|
_geometryAnnotations = new Dictionary<string, AnnotationBase>();
|
|
_modelAnnotations = new Dictionary<string, AnnotationBase>();
|
|
_allResultsAnnotations = new Dictionary<string, Dictionary<string, AnnotationBase>>();
|
|
}
|
|
public AnnotationContainer(AnnotationContainer annotationContainer, Controller controller)
|
|
{
|
|
AnnotationBase.Controller = controller;
|
|
//
|
|
_suppressed = false;
|
|
//
|
|
if (annotationContainer == null) // compatibility v1.3.1
|
|
{
|
|
_geometryAnnotations = new Dictionary<string, AnnotationBase>();
|
|
_modelAnnotations = new Dictionary<string, AnnotationBase>();
|
|
_allResultsAnnotations = new Dictionary<string, Dictionary<string, AnnotationBase>>();
|
|
}
|
|
else
|
|
{
|
|
_geometryAnnotations = annotationContainer._geometryAnnotations;
|
|
_modelAnnotations = annotationContainer._modelAnnotations;
|
|
_allResultsAnnotations = annotationContainer._allResultsAnnotations;
|
|
if (_allResultsAnnotations == null)
|
|
_allResultsAnnotations = new Dictionary<string, Dictionary<string, AnnotationBase>>(); // compatibility v1.3.4
|
|
}
|
|
}
|
|
|
|
|
|
// Methods
|
|
public static bool IsAnnotationNameReserved(string name)
|
|
{
|
|
if (name == MeasureAnnotationName || name == MinAnnotationName || name == MaxAnnotationName) return true;
|
|
else return false;
|
|
}
|
|
public string GetFreeAnnotationName()
|
|
{
|
|
string prefix = "";
|
|
if (AnnotationBase.Controller.CurrentView == ViewGeometryModelResults.Geometry) prefix = "G_";
|
|
else if (AnnotationBase.Controller.CurrentView == ViewGeometryModelResults.Model) prefix = "M_";
|
|
else if (AnnotationBase.Controller.CurrentView == ViewGeometryModelResults.Results) prefix = "R_";
|
|
else throw new NotSupportedException();
|
|
//
|
|
return GetCurrentAnnotations().GetNextNumberedKey(prefix + "Annotation");
|
|
}
|
|
public string[] GetCurrentAnnotationNames()
|
|
{
|
|
return GetCurrentAnnotations().Keys.ToArray();
|
|
}
|
|
public string[] GetAllAnnotationNames()
|
|
{
|
|
List<string> allNames = new List<string>();
|
|
allNames.AddRange(_geometryAnnotations.Keys);
|
|
allNames.AddRange(_modelAnnotations.Keys);
|
|
foreach (var entry in _allResultsAnnotations) allNames.AddRange(entry.Value.Keys);
|
|
return allNames.ToArray();
|
|
}
|
|
//
|
|
public void AddAnnotation(AnnotationBase annotation)
|
|
{
|
|
GetCurrentAnnotations().Add(annotation.Name, annotation);
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
//
|
|
DrawAnnotations();
|
|
}
|
|
public void AddNodeAnnotation(int nodeId)
|
|
{
|
|
AddAnnotation(new NodeAnnotation(GetFreeAnnotationName(), nodeId));
|
|
}
|
|
public void AddElementAnnotation(int elementId)
|
|
{
|
|
AddAnnotation(new ElementAnnotation(GetFreeAnnotationName(), elementId));
|
|
}
|
|
public void AddEdgeAnnotation(int geometryId)
|
|
{
|
|
AddAnnotation(new EdgeAnnotation(GetFreeAnnotationName(), geometryId));
|
|
}
|
|
public void AddSurfaceAnnotation(int geometryId)
|
|
{
|
|
AddAnnotation(new SurfaceAnnotation(GetFreeAnnotationName(), geometryId));
|
|
}
|
|
public void AddPartAnnotation(string partName)
|
|
{
|
|
AddAnnotation(new PartAnnotation(GetFreeAnnotationName(), partName));
|
|
}
|
|
public void AddMeasureAnnotation(string text, double[] anchor)
|
|
{
|
|
AddAnnotation(new TextAnnotation(MeasureAnnotationName, text, anchor));
|
|
}
|
|
//
|
|
public AnnotationBase GetCurrentAnnotation(string name)
|
|
{
|
|
if (GetCurrentAnnotations().TryGetValue(name, out AnnotationBase annotation)) return annotation;
|
|
else return null;
|
|
}
|
|
public Dictionary<string, AnnotationBase> GetCurrentAnnotations()
|
|
{
|
|
Dictionary<string, AnnotationBase> annotations =
|
|
GetAnnotations(AnnotationBase.Controller.CurrentView, CurrentResultName);
|
|
if (annotations != null) return annotations;
|
|
else return new Dictionary<string, AnnotationBase> { };
|
|
}
|
|
public Dictionary<string, AnnotationBase> GetAnnotations(ViewGeometryModelResults view, string resultName)
|
|
{
|
|
if (view == ViewGeometryModelResults.Geometry) return _geometryAnnotations;
|
|
else if (view == ViewGeometryModelResults.Model) return _modelAnnotations;
|
|
else if (view == ViewGeometryModelResults.Results)
|
|
{
|
|
if (resultName != null)
|
|
{
|
|
if (!_allResultsAnnotations.ContainsKey(resultName))
|
|
_allResultsAnnotations.Add(resultName, new Dictionary<string, AnnotationBase>());
|
|
return _allResultsAnnotations[resultName];
|
|
}
|
|
else return null;
|
|
}
|
|
else throw new NotSupportedException();
|
|
}
|
|
//
|
|
public string GetAnnotationText(string data)
|
|
{
|
|
int itemId;
|
|
string text;
|
|
AnnotationBase annotation;
|
|
//
|
|
int.TryParse(data, out itemId);
|
|
//
|
|
if (AnnotationBase.Controller.SelectBy == vtkSelectBy.QueryNode)
|
|
{
|
|
annotation = new NodeAnnotation("tmp", itemId);
|
|
}
|
|
else if (AnnotationBase.Controller.SelectBy == vtkSelectBy.QueryElement)
|
|
{
|
|
annotation = new ElementAnnotation("tmp", itemId);
|
|
}
|
|
else if (AnnotationBase.Controller.SelectBy == vtkSelectBy.QueryEdge)
|
|
{
|
|
annotation = new EdgeAnnotation("tmp", itemId);
|
|
}
|
|
else if (AnnotationBase.Controller.SelectBy == vtkSelectBy.QuerySurface)
|
|
{
|
|
annotation = new SurfaceAnnotation("tmp", itemId);
|
|
}
|
|
else if (AnnotationBase.Controller.SelectBy == vtkSelectBy.QueryPart)
|
|
{
|
|
annotation = new PartAnnotation("tmp", data);
|
|
}
|
|
else throw new NotSupportedException();
|
|
//
|
|
annotation.GetAnnotationData(out text, out double[] coor);
|
|
//
|
|
return text;
|
|
}
|
|
//
|
|
public void ResetAnnotation(string annotationName)
|
|
{
|
|
AnnotationBase annotation = GetCurrentAnnotation(annotationName);
|
|
if (annotation != null)
|
|
{
|
|
annotation.OverriddenText = null;
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
//
|
|
DrawAnnotations();
|
|
}
|
|
}
|
|
public void SuppressCurrentAnnotations()
|
|
{
|
|
_suppressed = true;
|
|
//
|
|
RemoveCurrentMeasureAnnotation(); // measure annotations cannot be suppressed
|
|
//
|
|
foreach (var entry in GetCurrentAnnotations()) entry.Value.Visible = false;
|
|
//
|
|
DrawAnnotations();
|
|
}
|
|
public void ResumeCurrentAnnotations()
|
|
{
|
|
_suppressed = false;
|
|
//
|
|
foreach (var entry in GetCurrentAnnotations()) entry.Value.Visible = true;
|
|
//
|
|
DrawAnnotations();
|
|
}
|
|
// Draw
|
|
public void DrawAnnotations(bool minMaxOnly = false)
|
|
{
|
|
string text;
|
|
double[] arrowCoor;
|
|
//
|
|
bool drawBackground = AnnotationBase.Controller.Settings.Annotations.BackgroundType == AnnotationBackgroundType.White;
|
|
bool drawBorder = AnnotationBase.Controller.Settings.Annotations.DrawBorder;
|
|
string numberFormat = AnnotationBase.Controller.Settings.Annotations.GetNumberFormat();
|
|
//
|
|
if (!minMaxOnly)
|
|
{
|
|
AnnotationBase annotation;
|
|
List<string> invalidAnnotationNames = new List<string>();
|
|
foreach (var entry in GetCurrentAnnotations())
|
|
{
|
|
try // some annotation might become unvalid
|
|
{
|
|
annotation = entry.Value;
|
|
// First get the annotation data to determine if the annotation is valid
|
|
annotation.GetAnnotationData(out text, out arrowCoor);
|
|
AnnotationBase.Controller.Form.AddArrowWidget(entry.Value.Name, text, numberFormat, arrowCoor,
|
|
drawBackground, drawBorder,
|
|
annotation.IsAnnotationVisible());
|
|
|
|
}
|
|
catch
|
|
{
|
|
invalidAnnotationNames.Add(entry.Key);
|
|
}
|
|
}
|
|
// Remove invalid annotations
|
|
if (invalidAnnotationNames.Count > 0)
|
|
{
|
|
RemoveCurrentArrowAnnotations(invalidAnnotationNames.ToArray());
|
|
AnnotationBase.Controller.Form.RemoveArrowWidgets(invalidAnnotationNames.ToArray());
|
|
}
|
|
}
|
|
// Min/Max annotations
|
|
if (AnnotationBase.Controller.CurrentView == ViewGeometryModelResults.Results)
|
|
{
|
|
bool showMin = AnnotationBase.Controller.Settings.Post.ShowMinValueLocation && !_suppressed;
|
|
bool showMax = AnnotationBase.Controller.Settings.Post.ShowMaxValueLocation && !_suppressed;
|
|
//
|
|
AnnotationBase.Controller.Form.AddArrowWidget(MinAnnotationName, "", numberFormat, new double[3],
|
|
drawBackground, drawBorder, showMin);
|
|
AnnotationBase.Controller.Form.AddArrowWidget(MaxAnnotationName, "", numberFormat, new double[3],
|
|
drawBackground, drawBorder, showMax);
|
|
}
|
|
}
|
|
// Remove
|
|
public void RemoveCurrentArrowAnnotation(string annotationName)
|
|
{
|
|
AnnotationBase.Controller.Form.RemoveArrowWidgets(new string[] { annotationName });
|
|
RemoveCurrentArrowAnnotations(new string[] { annotationName });
|
|
}
|
|
public void RemoveCurrentMeasureAnnotation()
|
|
{
|
|
RemoveCurrentArrowAnnotation(MeasureAnnotationName);
|
|
}
|
|
public void RemoveCurrentArrowAnnotations(string[] annotationNames)
|
|
{
|
|
var annotations = GetCurrentAnnotations();
|
|
if (annotations != null)
|
|
{
|
|
foreach (var annotationName in annotationNames) annotations.Remove(annotationName);
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
}
|
|
}
|
|
public void RemoveCurrentArrowAnnotationsByParts(BasePart[] parts, ViewGeometryModelResults view)
|
|
{
|
|
FeMesh mesh;
|
|
if (view == ViewGeometryModelResults.Geometry) mesh = AnnotationBase.Controller.Model.Geometry;
|
|
else if (view == ViewGeometryModelResults.Model) mesh = AnnotationBase.Controller.Model.Mesh;
|
|
else if (view == ViewGeometryModelResults.Results) mesh = AnnotationBase.Controller.CurrentResult.Mesh;
|
|
else throw new NotSupportedException();
|
|
//
|
|
Dictionary<string, AnnotationBase> annotations;
|
|
HashSet<int> partIds = new HashSet<int>();
|
|
if (mesh != null)
|
|
{
|
|
foreach (var part in parts) partIds.Add(part.PartId);
|
|
//
|
|
annotations = GetAnnotations(view, CurrentResultName);
|
|
List<AnnotationBase> annotationsToRemove = new List<AnnotationBase>();
|
|
foreach (var entry in annotations)
|
|
{
|
|
foreach (var partId in entry.Value.PartIds)
|
|
{
|
|
if (partIds.Contains(partId)) annotationsToRemove.Add(entry.Value);
|
|
}
|
|
}
|
|
// Remove
|
|
foreach (var annotation in annotationsToRemove) annotations.Remove(annotation.Name);
|
|
//
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
}
|
|
}
|
|
public void RemoveCurrentArrowAnnotationsByParts(string[] partNames, ViewGeometryModelResults view)
|
|
{
|
|
FeMesh mesh;
|
|
if (view == ViewGeometryModelResults.Geometry) mesh = AnnotationBase.Controller.Model.Geometry;
|
|
else if (view == ViewGeometryModelResults.Model) mesh = AnnotationBase.Controller.Model.Mesh;
|
|
else if (view == ViewGeometryModelResults.Results) mesh = AnnotationBase.Controller.CurrentResult.Mesh;
|
|
else throw new NotSupportedException();
|
|
//
|
|
BasePart part;
|
|
List<BasePart> parts = new List<BasePart>();
|
|
foreach (var name in partNames)
|
|
{
|
|
if (mesh.Parts.TryGetValue(name, out part)) parts.Add(part);
|
|
}
|
|
//
|
|
RemoveCurrentArrowAnnotationsByParts(parts.ToArray(), view);
|
|
}
|
|
public void RemoveCurrentArrowAnnotations()
|
|
{
|
|
var annotations = GetCurrentAnnotations();
|
|
AnnotationBase.Controller.Form.RemoveArrowWidgets(annotations.Keys.ToArray());
|
|
annotations.Clear();
|
|
//
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
}
|
|
public void RemoveCurrentResultArrowAnnotations()
|
|
{
|
|
Dictionary<string, AnnotationBase> resultAnnotations;
|
|
if (_allResultsAnnotations.TryGetValue(CurrentResultName, out resultAnnotations))
|
|
{
|
|
AnnotationBase.Controller.Form.RemoveArrowWidgets(resultAnnotations.Keys.ToArray());
|
|
//
|
|
_allResultsAnnotations.Remove(CurrentResultName);
|
|
//
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
}
|
|
}
|
|
public void RemoveAllResultArrowAnnotations()
|
|
{
|
|
_allResultsAnnotations.Clear();
|
|
//
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
}
|
|
public void RemoveAllArrowAnnotations()
|
|
{
|
|
_geometryAnnotations.Clear();
|
|
_modelAnnotations.Clear();
|
|
_allResultsAnnotations.Clear();
|
|
//
|
|
AnnotationBase.Controller.ModelChanged = true;
|
|
}
|
|
}
|
|
}
|