453 lines
20 KiB
C#
453 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
|
|
namespace DTS.Slice.PedestrianAndHeadReports
|
|
{
|
|
/// <summary>
|
|
/// this is the base class for all pedestrian and head reports
|
|
/// it contains all the common items between the reports
|
|
/// </summary>
|
|
public abstract class ReportBase : INotifyPropertyChanged
|
|
{
|
|
/// <summary>
|
|
/// these functions make us WPF/dependency property friendly, and also
|
|
/// adds a convenient way for us to notify consumers when a property has changed
|
|
/// </summary>
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
protected bool SetProperty<T>(ref T storage, T value, String propertyName)
|
|
{
|
|
if (object.Equals(storage, value)) return false;
|
|
|
|
storage = value;
|
|
this.OnPropertyChanged(propertyName);
|
|
return true;
|
|
}
|
|
protected void OnPropertyChanged(string propertyName)
|
|
{
|
|
var eventHandler = this.PropertyChanged;
|
|
if (eventHandler != null)
|
|
{
|
|
eventHandler(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
}
|
|
public void SetField(KnownGraphs graph, string channelId, GraphChannel.Fields field, string value)
|
|
{
|
|
_graphs[graph.ToString()].GetGraphChannel(channelId).SetValue(field, value);
|
|
|
|
DrawGraph(graph);
|
|
if (graph == KnownGraphs.HEAD_Acceleration)
|
|
{
|
|
DrawGraph(KnownGraphs.HEAD_ResultantAcceleration,
|
|
GetGraph(KnownGraphs.HEAD_ResultantAcceleration.ToString()).Chart);
|
|
}
|
|
}
|
|
public void SetField(KnownGraphs graph, ReportGraph.Fields field, string value)
|
|
{
|
|
_graphs[graph.ToString()].SetValue(field, value);
|
|
}
|
|
private Dictionary<string, ReportGraph> _graphs = new Dictionary<string, ReportGraph>();
|
|
protected void AddGraph(ReportGraph graph) { _graphs.Add(graph.Id, graph); graph.PropertyChanged += new PropertyChangedEventHandler(graph_PropertyChanged); }
|
|
protected ReportGraph GetGraph(string id) { return _graphs[id]; }
|
|
public string GetValueTrunc2Places(KnownGraphs graph, string id, GraphChannel.Fields field)
|
|
{
|
|
return _graphs[graph.ToString()].GetValueTrunc2Places(id, field);
|
|
}
|
|
public string GetValue(KnownGraphs graph, string id, GraphChannel.Fields field)
|
|
{
|
|
return _graphs[graph.ToString()].GetValue(id, field);
|
|
}
|
|
protected void graph_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
ReportGraph graph = sender as ReportGraph;
|
|
OnPropertyChanged("Graph-x-"+graph.Id + "-x-" + e.PropertyName);
|
|
}
|
|
public string GetValue(KnownGraphs graph, ReportGraph.Fields field)
|
|
{
|
|
return _graphs[graph.ToString()].GetValue(field);
|
|
}
|
|
public virtual void DrawGraph(KnownGraphs graph, C1.Win.C1Chart.C1Chart chart)
|
|
{
|
|
DrawGraph(graph.ToString(), chart);
|
|
}
|
|
public void DrawGraph(string id, C1.Win.C1Chart.C1Chart chart)
|
|
{
|
|
_graphs[id].Draw(chart);
|
|
}
|
|
protected void DrawGraph(KnownGraphs graph)
|
|
{
|
|
_graphs[graph.ToString()].Draw();
|
|
}
|
|
public double[] GetXPlot(KnownGraphs graph, string id)
|
|
{
|
|
return _graphs[graph.ToString()].GetXPlot(id);
|
|
}
|
|
public double[] GetYPlot(KnownGraphs graph, string id)
|
|
{
|
|
return _graphs[graph.ToString()].GetYPlot(id);
|
|
}
|
|
public enum KnownGraphs
|
|
{
|
|
LWR_LEG_TRL_Acceleration,
|
|
LWR_LEG_TRL_BendingAngle,
|
|
LWR_LEG_TRL_ShearAngle,
|
|
HEAD_ResultantAcceleration,
|
|
HEAD_Acceleration,
|
|
HEAD_StrokeDisplacement,
|
|
ARS_ARS,
|
|
ARS_Acceleration,
|
|
FLEX_TIBIA,
|
|
FLEX_MCL,
|
|
FLEX_ACLPCL,
|
|
FLEX_LCL,
|
|
FLEX_FEMUR,
|
|
UPRLEG_Force,
|
|
UPRLeg_Moment,
|
|
FLEX_CALTibia1,
|
|
FLEX_CALTibia2,
|
|
FLEX_CALTibia3,
|
|
FLEX_CALTibia4,
|
|
FLEX_CALMCL,
|
|
FLEX_CALACL,
|
|
FLEX_CALPCL,
|
|
LWR_LEG_TRL_BendingDisplacement,
|
|
LWR_LEG_TRL_ShearDisplacement
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// we maintain a link to the owning test report
|
|
/// we do this so we can get access to the Test property, which
|
|
/// contains the information on what event we are actually operating on
|
|
/// </summary>
|
|
protected PedestrianAndHeadTest _testParent;
|
|
public ReportBase(PedestrianAndHeadTest parent)
|
|
{
|
|
_testParent = parent;
|
|
//mostly we just want to be notified if our parent changes tests ...
|
|
_testParent.PropertyChanged += new PropertyChangedEventHandler(_testParent_PropertyChanged);
|
|
InitializeProperties();
|
|
InitializeGraphs();
|
|
}
|
|
/// <summary>
|
|
/// this is function gets called whenever the parent pedestrian and head report changes tests.
|
|
/// the default base class does nothing, but our descendants are free to do with it as they please
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected virtual void _testParent_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
switch (e.PropertyName)
|
|
{
|
|
case "Test":
|
|
var enumerator = _graphs.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
enumerator.Current.Value.Clear(_testParent.Test);
|
|
}
|
|
enumerator = _graphs.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
enumerator.Current.Value.SetDefaults(_testParent.Test);
|
|
enumerator.Current.Value.SetCFC(ChannelFilterClass, this);
|
|
}
|
|
if (null != _testParent.Test) { SetValue(PedestrianAndHeadTest.Fields.TestDate.ToString(), _testParent.Test.CreationTime.Ticks.ToString()); }
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// list of all properties for the report
|
|
/// note it's private, so that it forces descendants through the accessor methods where we have more
|
|
/// control
|
|
/// </summary>
|
|
private Dictionary<string, ReportProperty> _properties = new Dictionary<string, ReportProperty>();
|
|
protected virtual void InitializeProperties()
|
|
{
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.TestNumber.ToString(), "試験NO", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.TestDate.ToString(), "試験実施日", null, typeof(DateTime)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.CarName.ToString(), "車名", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.Model.ToString(), "型式", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.TestTemperature.ToString(), "試験温度", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.MeasurementPoint.ToString(), "測定点", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.CollisionSpeed.ToString(), "衝突速度", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.ImpactorId.ToString(), "インパクタID", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.ImpactorType.ToString(), "インパクタ種類", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.ImpactorWeight.ToString(), "インパクタ重量", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.StudyPersonnel.ToString(), "試験担当者", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.And1.ToString(), "予備1", null, typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.And2.ToString(), "予備2", null, typeof(string)));
|
|
|
|
List<string> filters = new List<string>();
|
|
SensorDB.FilterClass.FilterClassType[] filtertypes = Enum.GetValues(typeof(SensorDB.FilterClass.FilterClassType)).Cast<SensorDB.FilterClass.FilterClassType>().ToArray();
|
|
foreach (var ft in filtertypes)
|
|
{
|
|
switch (ft)
|
|
{
|
|
case DTS.SensorDB.FilterClass.FilterClassType.AdHoc: break;
|
|
default: filters.Add((new SensorDB.FilterClass(ft)).ToString()); break;
|
|
}
|
|
}
|
|
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.FrequencyClass.ToString(), "周波数クラス", filters.ToArray(), typeof(string)));
|
|
AddProperty(new ReportProperty(PedestrianAndHeadTest.Fields.TimeUnits.ToString(), "Time", new string[] { "s", "ms" }, typeof(string)));
|
|
SetValue(PedestrianAndHeadTest.Fields.TimeUnits.ToString(), "s");
|
|
}
|
|
protected virtual void InitializeGraphs() { ;}
|
|
/// <summary>
|
|
/// sets a value for a property (and notifies any listeners of the change)
|
|
/// </summary>
|
|
/// <param name="field"></param>
|
|
/// <param name="value"></param>
|
|
public void SetValue(string field, string value)
|
|
{
|
|
if (_properties[field].Value == value) { return; }
|
|
_properties[field].SetValue(value);
|
|
switch (field)
|
|
{
|
|
case "TimeUnits":
|
|
foreach (var g in _graphs) { g.Value.TimeUnits = value; }
|
|
break;
|
|
}
|
|
OnPropertyChanged(field);
|
|
}
|
|
/// <summary>
|
|
/// returns the value for a property
|
|
/// </summary>
|
|
/// <param name="field"></param>
|
|
/// <returns></returns>
|
|
public string GetValue(string field)
|
|
{
|
|
if (!_properties.ContainsKey(field) || string.IsNullOrEmpty(_properties[field].Value)) { return ""; }
|
|
else { return _properties[field].Value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// returns all possible values for a property (or null if the user must manually enter a value)
|
|
/// </summary>
|
|
/// <param name="field"></param>
|
|
/// <returns></returns>
|
|
protected string[] GetPossibleValues(string field) { return _properties[field].GetAvailableValues(); }
|
|
|
|
/// <summary>
|
|
/// sets the possible values for a property
|
|
/// </summary>
|
|
/// <param name="field"></param>
|
|
/// <param name="values"></param>
|
|
protected void SetPossibleValues(string field, string[] values)
|
|
{
|
|
_properties[field].SetAvailableValues(values);
|
|
if (null != values && values.Length == 1)
|
|
{
|
|
_properties[field].SetValue(values[0]);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// adds a new property
|
|
/// this enables descendants to have their own unique properties
|
|
/// </summary>
|
|
/// <param name="p"></param>
|
|
protected void AddProperty(ReportProperty p) { _properties.Add(p.Id, p); }
|
|
|
|
/// <summary>
|
|
/// the known report types, we can make this more generic in the future?
|
|
/// maybe just a name?
|
|
/// </summary>
|
|
public enum ReportTypes
|
|
{
|
|
Head,
|
|
UPRLeg,
|
|
LWRLegTRL,
|
|
LWRLegFlex,
|
|
LWRLegARS
|
|
}
|
|
|
|
public string GetName()
|
|
{
|
|
switch (GetReportType())
|
|
{
|
|
case ReportTypes.Head: return "HEAD";
|
|
case ReportTypes.LWRLegARS: return "LWR LEG(ARS)";
|
|
case ReportTypes.LWRLegFlex: return "LWR LEG(FLEX)";
|
|
case ReportTypes.LWRLegTRL: return "LWR LEG(TRL)";
|
|
case ReportTypes.UPRLeg: return "UPR LEG";
|
|
}
|
|
throw new Exception("uknown report type: " + GetReportType().ToString());
|
|
}
|
|
public abstract ReportTypes GetReportType();
|
|
|
|
/// <summary>
|
|
/// indicates whether this report is currently in use in the
|
|
/// pedestrian and head report (selected to export)
|
|
/// </summary>
|
|
protected bool _bInUse = false;
|
|
public bool InUse
|
|
{
|
|
get { return _bInUse; }
|
|
set { SetProperty(ref _bInUse, value, "InUse"); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// all these properties come directly from the Pedestrian and Head Safety report sample xlsx ..
|
|
/// </summary>
|
|
public string TestNumber
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.TestNumber.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.TestNumber.ToString(), value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// this one is the only one that is a little tricky,
|
|
/// we move to and from longs to avoid globalization issues ...
|
|
/// </summary>
|
|
public DateTime TestDate
|
|
{
|
|
get { return new DateTime(long.Parse(GetValue(PedestrianAndHeadTest.Fields.TestDate.ToString()))); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.TestDate.ToString(), value.Ticks.ToString()); }
|
|
}
|
|
public string CarName
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.CarName.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.CarName.ToString(), value); }
|
|
}
|
|
public string Model
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.Model.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.Model.ToString(), value); }
|
|
}
|
|
public string TestTemperature
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.TestTemperature.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.TestTemperature.ToString(), value); }
|
|
}
|
|
public string MeasurementPoint
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.MeasurementPoint.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.MeasurementPoint.ToString(), value); }
|
|
}
|
|
public string CollisionSpeed
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.CollisionSpeed.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.CollisionSpeed.ToString(), value); }
|
|
}
|
|
public string ImpactorID
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.ImpactorId.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.ImpactorId.ToString(), value); }
|
|
}
|
|
public string ImpactorType
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.ImpactorType.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.ImpactorType.ToString(), value); }
|
|
}
|
|
public string StudyPersonnel
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.StudyPersonnel.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.StudyPersonnel.ToString(), value); }
|
|
}
|
|
public string And1
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.And1.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.And1.ToString(), value); }
|
|
}
|
|
public string And2
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.And2.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.And2.ToString(), value); }
|
|
}
|
|
public string[] GetAvailableTimeUnits() { return _properties[PedestrianAndHeadTest.Fields.TimeUnits.ToString()].GetAvailableValues(); }
|
|
public string TimeUnits
|
|
{
|
|
get { return _properties[PedestrianAndHeadTest.Fields.TimeUnits.ToString()].Value; }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.TimeUnits.ToString(), value); }
|
|
}
|
|
public string ImpactorWeight
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.ImpactorWeight.ToString()); }
|
|
set { SetValue(PedestrianAndHeadTest.Fields.ImpactorWeight.ToString(), value); }
|
|
}
|
|
public virtual string ChannelFilterClass
|
|
{
|
|
get { return GetValue(PedestrianAndHeadTest.Fields.FrequencyClass.ToString()); }
|
|
set
|
|
{
|
|
SetValue(PedestrianAndHeadTest.Fields.FrequencyClass.ToString(), value);
|
|
var e = _graphs.GetEnumerator();
|
|
while (e.MoveNext()) { e.Current.Value.SetCFC(value,this); }
|
|
}
|
|
}
|
|
|
|
public string[] GetImpactorTypes()
|
|
{
|
|
return GetPossibleValues(PedestrianAndHeadTest.Fields.ImpactorType.ToString());
|
|
}
|
|
public string[] GetAvailableFilterTypes()
|
|
{
|
|
return GetPossibleValues(PedestrianAndHeadTest.Fields.FrequencyClass.ToString());
|
|
}
|
|
|
|
public MeasurementUnit GetUnits(KnownGraphs graph)
|
|
{
|
|
return GetGraph(graph.ToString()).GetChannelUnit();
|
|
}
|
|
public void SetUnits(KnownGraphs graph, MeasurementUnit units)
|
|
{
|
|
GetGraph(graph.ToString()).SetChannelUnit(units);
|
|
DrawGraph(graph, GetGraph(graph.ToString()).Chart);
|
|
}
|
|
public MeasurementUnit[] GetAvailableUnits(KnownGraphs graph)
|
|
{
|
|
return GetGraph(graph.ToString()).GetChannelUnits();
|
|
}
|
|
public ReviewTestChannel GetChannel(KnownGraphs graph, string id)
|
|
{
|
|
return GetGraph(graph.ToString()).GetReviewTestChannel(id);
|
|
}
|
|
public void SetChannel(KnownGraphs graph, string id, ReviewTestChannel channel)
|
|
{
|
|
GetGraph(graph.ToString()).SetReviewTestChannel(id, channel);
|
|
GetGraph(graph.ToString()).SetCFC(ChannelFilterClass, this);
|
|
}
|
|
public ReviewTestChannel[] GetAvailableChannels(KnownGraphs graph, string id)
|
|
{
|
|
return GetGraph(graph.ToString()).GetAvailableChannels(id, _testParent.Test);
|
|
}
|
|
|
|
public void ToStringOutput(ref System.Xml.XmlWriter xt)
|
|
{
|
|
xt.WriteStartElement("Report");
|
|
//xt.WriteStartElement("ReportType");
|
|
xt.WriteElementString("ReportType", GetReportType().ToString());
|
|
xt.WriteElementString("InUse", InUse.ToString());
|
|
var e = _properties.GetEnumerator();
|
|
while (e.MoveNext())
|
|
{
|
|
try
|
|
{
|
|
PedestrianAndHeadTest.Fields field = (PedestrianAndHeadTest.Fields)Enum.Parse(typeof(PedestrianAndHeadTest.Fields), e.Current.Value.Id);
|
|
switch (field)
|
|
{
|
|
case PedestrianAndHeadTest.Fields.TestNumber:
|
|
continue;
|
|
case PedestrianAndHeadTest.Fields.TestDate:
|
|
continue;
|
|
case PedestrianAndHeadTest.Fields.TestTemperature:
|
|
continue;
|
|
case PedestrianAndHeadTest.Fields.CollisionSpeed:
|
|
continue;
|
|
}
|
|
}
|
|
catch (System.Exception) { }
|
|
xt.WriteElementString(e.Current.Value.Id, e.Current.Value.Value);
|
|
}
|
|
this.GetReportType();
|
|
xt.WriteEndElement();
|
|
}
|
|
}
|
|
}
|