Files
wg_cpso/CPSO/Annotations/AnnotationContainer.cs

367 lines
16 KiB
C#
Raw Normal View History

2026-03-25 18:20:24 +08:00
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;
}
}
}