private void UpdateImage(DisplayData data)
{
if (data != null)
{
ContentReference cref = null;
if ((data.DisplayType == DisplayType.ContentReference) && (data.Data is ContentReference) &&
(((ContentReference)data.Data).MediaType == MediaPrimitiveType.Image))
{
cref = data.Data as ContentReference;
}
if ((data.DisplayType == DisplayType.MediaMetaData) && (data.Data is MediaMetaData))
{
ContentReference candidate = ((MediaMetaData)data.Data)[Core.System.CurrentDeviceGroup];
if ((candidate != null) && (candidate.MediaType == MediaPrimitiveType.Image))
{
cref = candidate;
}
}
if (cref != null)
{
BitmapSource img = cref.ToBitmap(data.DownloadedData as byte[]);
if (img != null)
{
imageControl.Source = img;
}
}
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
DisplayData.Dispose();
}
}
public void ReadData(string content)
{
string[] lines = content.Split('\n');
int totalMsg = 0;
foreach (string line in lines)
{
ParseData(line);
}
Debug.Log("---------------------------[Final]-----------------------------");
Debug.Log("[活跃用户数量] " + data.contentByUser.Count);
foreach (var value in data.contentByUser)
{
// Debug.Log($"[{value.Key}] : [{value.Value.Count}]");
totalMsg += value.Value.Count;
}
Debug.Log($"[今日总发言数] : [{totalMsg}]");
// Debug.Log($"[Nora.T] : [1314]");
foreach (var value in data.contentByUser)
{
Debug.Log($"[{value.Key}] : [{value.Value.Count}]");
// totalMsg += value.Value.Count;
}
DisplayData temp = new DisplayData();
temp.content = "今日总发言数";
temp.amount = totalMsg.ToString();
displayData.Add(temp);
temp = new DisplayData();
temp.content = "活跃用户数量";
temp.amount = data.contentByUser.Count.ToString();
displayData.Add(temp);
}
public void Init(DisplayData p_displayData)
{
_background.sprite = p_displayData.sprite;
_background.color = p_displayData.color;
_showDuration = p_displayData.showDuration;
EnableTimer(p_displayData.showDuration);
}
/*--- Method: public ------------------------------------------------------------------------------------------------------------------------------------------*/
/// <summary> ディスプレイ情報を返却します。
/// </summary>
/// <param name="pDisplayType"> 取得するディスプレイタイプ </param>
/// <returns> ディスプレイデータ またはNull </returns>
public DisplayData GetDisplayResolution(DisplayType pDisplayType)
{
DisplayData result = null;
switch (pDisplayType)
{
case DisplayType.HD720:
result = new DisplayData(pDisplayType.ToString(), 1280d, 720d, 16d, 9d);
break;
case DisplayType.FHD:
result = new DisplayData(pDisplayType.ToString(), 1920d, 1080d, 16d, 9d);
break;
case DisplayType.WUXGA:
result = new DisplayData(pDisplayType.ToString(), 1920d, 1200d, 8d, 5d);
break;
case DisplayType.QFHD_UHD_4K:
result = new DisplayData(pDisplayType.ToString(), 3840d, 2160d, 16d, 9d);
break;
}
return(result);
}
internal void SetSelectedBundle(AssetBundleState.BundleInfo b)
{
m_data = b == null ? null : new DisplayData(b);
updateDelay = lastUpdateTime = Time.realtimeSinceStartup;
needsReload = true;
Reload();
}
public DisplayData CalculateSLADeadlines_ToDisplayData(IEnumerable <Cleansed_SLA_Report_Details> SLAReportDetails)
{
#region Declarations
DisplayData result = new DisplayData();
Dictionary <string, int> orderTotals = AggregateTotals_ToDictionary(SLAReportDetails);
Dictionary <string, decimal> totalPercentages = CalculatePercentages_ToDictionary(orderTotals);
#endregion
#region Assign results to data model
result.ExpressOrders = orderTotals["Express"];
result.ExpressOrdersSLA = (orderTotals["Express"] - orderTotals["Express Failed"]);
result.ExpressOrdersSLAPct = totalPercentages["Express Pct"];
result.InternationalOrders = orderTotals["International"];
result.InternationalOrdersSLA = (orderTotals["International"] - orderTotals["International Failed"]);
result.InternationalOrdersSLAPct = totalPercentages["International Pct"];
result.StandardOrders = orderTotals["Standard"];
result.StandardOrdersSLA = (orderTotals["Standard"] - orderTotals["Standard Failed"]);
result.StandardOrdersSLAPct = totalPercentages["Standard Pct"];
result.StoreOrders = orderTotals["Store"];
result.StoreOrdersSLA = (orderTotals["Store"] - orderTotals["Store Failed"]);
result.StoreOrdersSLAPct = totalPercentages["Store Pct"];
result.TotalOrders = orderTotals["Total"];
result.TotalOrdersSLA = (orderTotals["Total"] - orderTotals["Total Failed"]);
result.TotalOrdersSLAPct = totalPercentages["Total Pct"];
#endregion
return(result);
}
private void Bind24HrDisplayData_ToForm(MainForm mainForm, IEnumerable <Cleansed_SLA_Report_Details> slaReportDetails)
{
Config_Information configInfo = dataHandler.GetConfigInformation();
DisplayData displayData = dataHandler.BindSLAData_ToDisplayData(slaReportDetails);
List <Label> labels = new List <Label>();
#region Set top labels
mainForm.lbl24HrsTotalSLADtlPct.Text = displayData.TotalOrdersSLAPct.ToString();
mainForm.lbl24HrsExpressSLADtlPct.Text = displayData.ExpressOrdersSLAPct.ToString();
mainForm.lbl24HrsInternationalSLADtlPct.Text = displayData.InternationalOrdersSLAPct.ToString();
mainForm.lbl24HrsStandardSLADtlPct.Text = displayData.StandardOrdersSLAPct.ToString();
mainForm.lbl24HrsStoreSLADtlPct.Text = displayData.StoreOrdersSLAPct.ToString();
mainForm.gbLast24Hrs.Text = "Statistics from cut off point on " + DateTime.Now.AddDays(-1).ToLongDateString();
labels.Add(mainForm.lbl24HrsStandardSLADtlPct);
labels.Add(mainForm.lbl24HrsStoreSLADtlPct);
labels.Add(mainForm.lbl24HrsInternationalSLADtlPct);
labels.Add(mainForm.lbl24HrsTotalSLADtlPct);
AssignColourCodedPct_ToLabels(labels, configInfo.Standard_SLA_Percentage_High, configInfo.Standard_SLA_Percentage_Low);
labels.Clear();
labels.Add(mainForm.lbl24HrsExpressSLADtlPct);
AssignColourCodedPct_ToLabels(labels, configInfo.Express_SLA_Percentage_High, configInfo.Express_SLA_Percentage_Low);
#endregion
}
public string FindSignpostedData(int signpost, BlockBase sourceBlock)
{
string message = null;
BlockBase block = FindBlock((short)signpost, sourceBlock);
if ((block != null) && !String.IsNullOrEmpty(block.FormSubmissionValue))
{
message = block.FormSubmissionValue;
}
if (message == null)
{
DisplayData messageData =
FindSignpostedData(
(short)signpost,
(sourceBlock.Host != null) ? sourceBlock.Host.ID : Core.UI.RootViewID);
if (messageData.DisplayType == DisplayType.String)
{
message = (string)messageData.Data;
}
}
return(message);
}
public WallpaperManagerForm()
{
WallpaperData.WallpaperManagerForm = this; //? this needs to be at the very front for a few other initializers
InitializeComponent();
Application.ApplicationExit += OnApplicationExit;
this.Load += OnLoad;
this.Resize += OnResize;
this.Closing += OnClosing;
DisplayData.Initialize();
InitializeDisplayTabControl();
InitializeImageSelector();
InitializeImageInspector();
WallpaperPathing.Validate(); // ensures that all needed folders exist
WallpaperData.Initialize(false); // loads in all necessary data
OptionsData.Initialize();
InitializeWallpapers();
InitializeTimer();
InitializeKeys();
InitializeNotifyIcon();
}
private void CreateFilterButton(DisplayData data, GameObject buttonPrefab, List <Filter> grouped, int i, bool isMain = false)
{
buttonPrefab.transform.SetParent(data.ItemsGrid.transform, false);
buttonPrefab.GetComponentInChildren <Text>().text = grouped[i].GetString();
if (!grouped[i].IsCategory())
{
var icon = InterfaceHelpers.FindGameObject(buttonPrefab, "Icon");
icon.AddComponent <uGUI_Icon>().sprite = SpriteManager.Get(grouped[i].Types[0]);
}
var buttonToggle = buttonPrefab.GetComponent <Toggle>();
if (isMain)
{
buttonToggle.isOn = true;
}
var mainBTN = buttonPrefab.AddComponent <InterfaceButton>();
mainBTN.ButtonMode = InterfaceButtonMode.Background;
mainBTN.STARTING_COLOR = _startColor;
mainBTN.HOVER_COLOR = _hoverColor;
mainBTN.BtnName = "FilterBTN";
mainBTN.Tag = new FilterTransferData {
Filter = grouped[i], Toggle = buttonToggle
};
mainBTN.OnButtonClick = OnButtonClick;
_trackedButtons.Add(mainBTN);
}
private void SetInitialDisplay()
{
List <List <LevelMoment> > moments = levelData.moments;
for (int j = displayCenter.x; j < displaysAcross; j++)
{
for (int i = displayCenter.y; i < displaysWide; i++)
{
Vector2Int momentIndex = new Vector2Int
{
x = i - displayCenter.y,
y = j - displayCenter.x
};
GameObject display = displays[j][i];
DisplayData data = display.GetComponentInChildren <DisplayData>();
if (momentIndex.x >= moments[0].Count)
{
continue;
}
if (momentIndex.y >= moments.Count)
{
continue;
}
data.builder.SetMoment(moments[momentIndex.y][momentIndex.x]);
//Build initial display
data.builder.BuildDisplay();
}
}
}
private void OnLoadDisplay(DisplayData data)
{
if (_isBeingDestroyed)
{
return;
}
_grid.ClearPage();
var grouped = _mono.Storage.GetItemsWithin();
if (data.EndPosition > grouped.Count)
{
data.EndPosition = grouped.Count;
}
for (int i = data.StartPosition; i < data.EndPosition; i++)
{
GameObject buttonPrefab = Instantiate(data.ItemsPrefab);
if (buttonPrefab == null || data.ItemsGrid == null)
{
if (buttonPrefab != null)
{
QuickLogger.Debug("Destroying Tab", true);
Destroy(buttonPrefab);
}
return;
}
var item = grouped.ElementAt(i);
LoadDisplay(data, item.Key, item.Value);
}
_grid.UpdaterPaginator(grouped.Count);
}
private void UnpackContent()
{
/*
* // set checked state
* m_fChecked = m_oDefinition.m_fCheckable && oContentFldListForBlock.getNumFieldOfType(CFieldList.c_nINT, CNaviAgent.c_fieldidIsChecked) > 0;
*/
// parse server display data
serverDisplayData = DisplayData.Parse(Content);
Core.UI.ReferencedContent.Add(serverDisplayData);
ParentNode.Register(serverDisplayData);
// check if this block should have initial focus
bool initialFocus = Content[NaviAgentFieldID.IsFocused].AsBoolean() ?? false;
// set default state
if (CanFocus && initialFocus)
{
SwitchToState(BlockState.Focused);
}
else
{
SwitchToState(BlockState.Normal);
}
}
private void SearchByUPC()
{
var dList = model.GetDistributorDataByUPC(Search);
if (dList != null && dList.Count > 0)
{
DisplayData dd = new DisplayData();
dd.UPC = Search;
dList.ToList().ForEach(d =>
{
d.Updated = false;
dd.DistData.Add(d);
d.DataUpdated += dd.DataUpdated;
});
var mpList = model.GetMarketDataByUPC(Search);
if (mpList != null && mpList.Count > 0)
{
mpList.ToList().ForEach(m =>
{
m.Updated = false;
dd.MarketplaceData.Add(m);
m.DataUpdated += dd.DataUpdated;
});
}
dd.Updated += () =>
{
updated = true;
CommandManager.InvalidateRequerySuggested();
};
DistributorDataList.Add(dd);
}
}
public void Display_data_contract_has_not_been_broken()
{
var socket = new TextSocket();
var sender = new MessageSender(socket, new SignatureValidator("key", "HMACSHA256"));
var transient = new Dictionary <string, object> {
{ "display_id", "none" }
};
var output = "some result";
var displayData = new DisplayData(
data: new Dictionary <string, object>
{
{ "text/html", output },
{ "text/plain", output }
},
transient: transient);
var header = new Header(messageType: JupyterMessageContentTypes.DisplayData, messageId: Guid.Empty.ToString(),
version: "5.3", username: Constants.USERNAME, session: "test session",
date: DateTime.MinValue.ToString("yyyy-MM-ddTHH:mm:ssZ"));
var replyMessage = new Message(header, content: displayData);
sender.Send(replyMessage);
var encoded = socket.GetEncodedMessage();
this.Assent(encoded, _configuration);
}
private void OnLogEvent(
DiagnosticLogEntryProduced logEvent,
ZeroMQMessage request,
IJupyterMessageSender jupyterMessageSender)
{
var transient = CreateTransient();
var span = _textSpanFormatter.ParseToSpan($"{Ansi.Color.Foreground.DarkGray}{logEvent.Message}{Ansi.Text.AttributesOff}");
var message = span.ToString(OutputMode.Ansi);
var dataMessage = new DisplayData(
transient: transient,
data: new Dictionary <string, object> {
[PlainTextFormatter.MimeType] = message
});
var isSilent = ((ExecuteRequest)request.Content).Silent;
if (!isSilent)
{
// send on io
jupyterMessageSender.Send(dataMessage);
}
}
public HomeController(HostingEnvironment hostingEnvironment, IOptions <WigymTvConfig> config)
{
_hostingEnvironment = hostingEnvironment;
_config = config.Value;
_fileHelper = new FileHelper(_config);
_data = _fileHelper.GetDataFromJson();
}
public NativeMessageBoxBodyBlock(View hostView, Node parentNode, BlockBase parentBlock, BlockDefinition definition, FieldList content, bool isRoot)
: base(hostView, parentNode, parentBlock, definition, content, isRoot)
{
Title = String.Empty;
Message = String.Empty;
if ((Data != null) && (Data.SlotHints != null))
{
// parse server display data
serverDisplayData = DisplayData.Parse(content);
// extract title and message
if ((serverDisplayData.Count > 0) && (Data.SlotHints.Length > 0))
{
ProcessHintDataPair(Data.SlotHints[0], serverDisplayData[0]);
}
if ((serverDisplayData.Count > 1) && (Data.SlotHints.Length > 1))
{
ProcessHintDataPair(Data.SlotHints[1], serverDisplayData[1]);
}
}
if (Title == String.Empty)
{
Title = Core.ApplicationName;
}
if (Message == String.Empty)
{
Message = DefaultMessage;
}
}
private void Add_Items()
{
if (!isColumnCreated)
{
Purchase_data.Columns.Add("Item Number");
Purchase_data.Columns.Add("Item Name");
Purchase_data.Columns.Add("Quantity");
Purchase_data.Columns.Add("Price");
Purchase_data.Columns.Add("Total Price");
isColumnCreated = true;
}
double x, y, z, sum;
x = Convert.ToDouble(iQtytxt.Text);
y = Convert.ToDouble(iPrice);
z = Convert.ToDouble(iPricetxt.Text);
sum = (x * y) + z;
iPricetxt.Text = Math.Round(sum, 2).ToString();
Purchase_data.Rows.Add(iNumbertxt.Text, iName, iQtytxt.Text, iPrice, Math.Round((x * y), 2).ToString());
DisplayData.DataSource = Purchase_data;
DisplayData.AutoResizeColumns();
DisplayData.AutoResizeRows();
iNumbertxt.Text = "";
iQtytxt.Text = "";
}
public Form1()
{
InitializeComponent();
needToSave = false;
disDaemon = new DisplayData();
ChangeFileLoadState(false);
accType_temp[0] = "Creative Arts";
accType_temp[1] = "Performing Arts";
accType_temp[2] = "Banking";
accType_temp[3] = "Common Crafting";
accType_temp[4] = "Magical Crafting";
accType_temp[5] = "Millitary Crafting";
accType_temp[6] = "Exploration";
accType_temp[7] = "Mill/Granary";
accType_temp[8] = "Assassins Guild";
accType_temp[9] = "Crafting Guilds";
accType_temp[10] = "Merchant's Guild";
accType_temp[11] = "Thieves Guild";
accType_temp[12] = "Exotic Imports";
accType_temp[13] = "Ordinary Imports";
accType_temp[14] = "Invention Supplies";
accType_temp[15] = "Protection Supplies";
accType_temp[16] = "Quarry Imports";
accType_temp[17] = "Magical Research";
accType_temp[18] = "Mundane Research";
accType_temp[19] = "Stable";
accType_temp[20] = "Tavern";
accType_temp[21] = "Resurection Funds";
}
private void SendOutputMessageToIOPub(string value)
{
JObject data = new JObject()
{
{ "text/plain", value },
{ "text/html", HttpUtility.HtmlEncode(value) }
};
DisplayData displayData = new DisplayData()
{
Data = data,
};
JObject content = new JObject
{
{ "execution_count", this._executionCount },
{ "data", displayData.Data },
{ "metadata", displayData.MetaData }
};
Message outputMessage = MessageBuilder.CreateMessage(MessageTypeValues.DisplayData, content, _message.Header);
this._logger.Info(string.Format("Sending message to IOPub {0}", JsonSerializer.Serialize(outputMessage)));
this._messageSender.Send(outputMessage, _ioPub);
}
// Use this for initialization
void Start()
{
level = 1;
if (mode == 0)
{
TimeRequiredForAction = 3.0f;
attentionThreshold = 40;
}
if (mode == 1)
{
attentionThreshold = 50;
TimeRequiredForAction = 2.0f;
}
numOfTargetDestroyed = 0;
totalTimeGazed = 0.0f;
timeGazedOnFloor = 0.0f;
cannonIcon.color = defaultColor;
laserIcon.color = defaultColor;
tpIcon.color = defaultColor;
camT = Camera.main.transform;
cannonballs = new List <GameObject>();
audioS = GetComponent <AudioSource>();
attentionScript = GetComponent <DisplayData>();
lastFrameFloorGazed = false;
currentFrameFloorGazed = false;
cameraDefaultPosition = transformForTP.position;
}
private static void Options(DisplayData _display)
{
if (_display.DisplayOptions == DisplayOptionType.START)
{
_display.ShowEssentials = true;
_display.ShowStatus = false;
_display.ShowMissions = false;
_display.ShowBehaviour = false;
_display.ShowInteractionSettings = false;
_display.ShowEnvironmentSettings = false;
}
else if (_display.DisplayOptions == DisplayOptionType.BASIC)
{
_display.ShowEssentials = true;
_display.ShowStatus = true;
_display.ShowMissions = true;
_display.ShowBehaviour = false;
_display.ShowInteractionSettings = false;
_display.ShowEnvironmentSettings = false;
}
else if (_display.DisplayOptions == DisplayOptionType.FULL)
{
_display.ShowEssentials = true;
_display.ShowStatus = true;
_display.ShowMissions = true;
_display.ShowBehaviour = true;
_display.ShowInteractionSettings = true;
_display.ShowEnvironmentSettings = true;
}
}
internal void AddDisplay(DisplayData data)
{
var transform = data.Transform?.ToMatrix() ?? Matrix.Identity;
switch (data.Type)
{
case "Armature":
// TODO defaultActions.
Displays.Add(new DisplayTransform(Armature.Creator.GetArmature(data.Name),
transform));
break;
case "image":
Displays.Add(new DisplayTransform(new DbImage(data.Name, Armature.Texturer),
transform));
break;
case "mesh":
Displays.Add(new DisplayTransform(new DbMesh(data, Armature.Texturer, Armature.GraphicsDevice),
transform));
break;
default:
throw new ArgumentException(nameof(data));
}
}
private void RebuildColumn(int columnIndex, int momentIndex)
{
for (int j = 0; j < displaysAcross; j++)
{
GameObject display = displays[j][columnIndex];
DisplayData data = display.GetComponentInChildren <DisplayData>();
//unbuild current display
data.builder.UnbuildDisplay();
if ((momentIndex < 0) || (levelData.moments[0].Count <= momentIndex))
{
continue;
}
int k = centerIndex.y - displayCenter.y + j;
if ((k < 0) || (levelData.moments.Count <= k))
{
continue;
}
data.builder.SetMoment(levelData.GetMoment(k, momentIndex));
data.builder.BuildDisplay();
}
}
private void UpdateUi(DisplayData measuredData)
{
label1.Visible = false;
lblSign.Text = measuredData.Sign;
lblMainDisplay.Text = measuredData.MainDisplayValue;
lblSign2nd.Text = measuredData.Sign2Nd;
lblDisplay2nd.Text = measuredData.SecondDisplayValue;
lblUnitMain.Text = measuredData.Unit;
lblUnit2nd.Text = measuredData.SecondDisplayValue == "" ? "" : measuredData.Unit1;
lblSelect.Text = measuredData.Select;
lblBarSign.Text = measuredData.Sign;
if (measuredData.ShowBar)
{
progressBar1.Visible = true;
progressBar1.Value = Math.Min(measuredData.BarValue, 21);
}
else
{
progressBar1.Visible = false;
}
lblAuto.Text = measuredData.Auto;
lblHold.Text = measuredData.Hold;
lblRel.Text = measuredData.Rel;
lblMax.Text = measuredData.MinMax;
}
private void OnDisplayEvent(DisplayEventBase displayEvent,
ZeroMQMessage request,
IJupyterMessageSender jupyterMessageSender)
{
if (displayEvent is ReturnValueProduced && displayEvent.Value is DisplayedValue)
{
return;
}
var transient = CreateTransient(displayEvent.ValueId);
var formattedValues = displayEvent
.FormattedValues
.ToDictionary(k => k.MimeType, v => PreserveJson(v.MimeType, v.Value));
var value = displayEvent.Value;
PubSubMessage dataMessage;
switch (displayEvent)
{
case DisplayedValueProduced _:
dataMessage = new DisplayData(
transient: transient,
data: formattedValues);
break;
case DisplayedValueUpdated _:
dataMessage = new UpdateDisplayData(
transient: transient,
data: formattedValues);
break;
case ReturnValueProduced _:
dataMessage = new ExecuteResult(
_executionCount,
transient: transient,
data: formattedValues);
break;
case StandardOutputValueProduced _:
dataMessage = Stream.StdOut(GetPlainTextValueOrDefault(formattedValues, value?.ToString() ?? string.Empty));
break;
case StandardErrorValueProduced _:
case ErrorProduced _:
dataMessage = Stream.StdErr(GetPlainTextValueOrDefault(formattedValues, value?.ToString() ?? string.Empty));
break;
default:
throw new ArgumentException("Unsupported event type", nameof(displayEvent));
}
var isSilent = ((ExecuteRequest)request.Content).Silent;
if (!isSilent)
{
// send on io
jupyterMessageSender.Send(dataMessage);
}
}
static void Main(string[] args)
{
//Input data as message.
InputText inputAction = new InputText();
var items = inputAction.InputString();
//Create data from input string.
DataBusiness createBusiness = new DataBusiness();
var data = createBusiness.CreateData(items);
//Display data.
DisplayData displayData = new DisplayData();
displayData.Display(data);
//Input action to see remaining data as input string.
var inputString = inputAction.InputActionsString();
//Caculate data remaining.
var dataRemaining = createBusiness.RemainingData(inputString, data);
//Display data remaining.
displayData.Display(dataRemaining);
Console.WriteLine("Press any key to exits");
Console.ReadKey();
}
public IEnumerable <DisplayData> getDisplayData(List <APIData> apidatas)
{
DisplayData display = new DisplayData();
//List<APIData> apidata = new List<APIData>();
//apidata.Add(new APIData()
//{
// imageData = GetImageAsByteArray(@"C:\Users\Bhargavi\Desktop\birds\sample.jpg"),
// imageText = "Hi This is sample text"
//});
//apidata.Add(new APIData()
//{
// imageData = GetImageAsByteArray(@"C:\Users\Bhargavi\Desktop\birds\sample.jpg"),
// imageText = "Hi This is sample text"
//});
//apidata.Add(new APIData()
//{
// imageData = GetImageAsByteArray(@"C:\Users\Bhargavi\Desktop\birds\sample.jpg"),
// imageText = "Hi This is sample text"
//});
display.listApiData = apidatas;
List <DisplayData> displayDatas = new List <DisplayData>();
displayDatas.Add(display);
return(displayDatas);
}
public void TestDisplayRefresh()
{
if (testDisplayModeComboBox.SelectedIndex < 0)
{
}
else if (!RegularExpression.DoubleCheck(minYAxisTestDisplayTextBox.Text))
{
MessageBox.Show("Min Y Axis value is worng. Check Please.");
minYAxisTestDisplayTextBox.Text = "0.0";
minYAxisTestDisplayTextBox.Focus();
minYAxisTestDisplayTextBox.SelectAll();
}
else if (!RegularExpression.DoubleCheck(maxYAxisTestDisplayTextBox.Text))
{
MessageBox.Show("Max Y Axis value is worng. Check Please.");
maxYAxisTestDisplayTextBox.Text = "1.0";
maxYAxisTestDisplayTextBox.Focus();
maxYAxisTestDisplayTextBox.SelectAll();
}
else if (double.Parse(minYAxisTestDisplayTextBox.Text) < 0)
{
MessageBox.Show("Min Y Axis value must be 0 or bigger. Check Please.");
minYAxisTestDisplayTextBox.Text = "0.0";
maxYAxisTestDisplayTextBox.Focus();
maxYAxisTestDisplayTextBox.SelectAll();
}
else if (double.Parse(maxYAxisTestDisplayTextBox.Text) <= 0)
{
MessageBox.Show("Max Y Axis value must be bigger than 0. Check Please.");
maxYAxisTestDisplayTextBox.Text = "1.0";
maxYAxisTestDisplayTextBox.Focus();
maxYAxisTestDisplayTextBox.SelectAll();
}
else if (double.Parse(maxYAxisTestDisplayTextBox.Text) <= double.Parse(minYAxisTestDisplayTextBox.Text))
{
MessageBox.Show("Max Y Axis value must be bigger than min Y Axis value. Check Please.");
minYAxisTestDisplayTextBox.Text = "0.0";
maxYAxisTestDisplayTextBox.Text = "1.0";
maxYAxisTestDisplayTextBox.Focus();
maxYAxisTestDisplayTextBox.SelectAll();
}
else if (!useTimeStampCheckBox.Checked)
{
int maxXAxis = 0;
foreach (LearningSetup processSetup in learningSetupList) maxXAxis += processSetup.TrainingEpoch;
testDisplayChart.ChartAreas[0].Area3DStyle.Enable3D = false;
testDisplayChart.ChartAreas[0].AxisX.Minimum = 0;
testDisplayChart.ChartAreas[0].AxisX.Maximum = maxXAxis;
testDisplayChart.ChartAreas[0].AxisY.Minimum = double.Parse(minYAxisTestDisplayTextBox.Text);
testDisplayChart.ChartAreas[0].AxisY.Maximum = double.Parse(maxYAxisTestDisplayTextBox.Text);
List<DisplayData> displayDataList = new List<DisplayData>();
try
{
switch (testDisplayModeComboBox.SelectedIndex)
{
case 0:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch)
{
displayData.InsertValue(testData.MeanSquredError);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.InsertValue(testData.MeanSquredError);
displayDataList.Add(newDisplayData);
}
}
break;
case 1:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch)
{
displayData.InsertValue(testData.MeanSemanticStress);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.InsertValue(testData.MeanSemanticStress);
displayDataList.Add(newDisplayData);
}
}
break;
case 2:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch)
{
displayData.InsertValue(testData.MeanCrossEntropy);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.InsertValue(testData.MeanCrossEntropy);
displayDataList.Add(newDisplayData);
}
}
break;
case 3:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch)
{
if (testData.Correctness) displayData.InsertValue(1);
else displayData.InsertValue(0);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
if (testData.Correctness) newDisplayData.InsertValue(1);
else newDisplayData.InsertValue(0);
displayDataList.Add(newDisplayData);
}
}
break;
case 4:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch)
{
if (testData.MeanActiveUnitActivation == testData.MeanActiveUnitActivation)
{
displayData.InsertValue(testData.MeanActiveUnitActivation);
isExist = true;
}
break;
}
}
if (!isExist)
{
if (testData.MeanActiveUnitActivation == testData.MeanActiveUnitActivation)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.InsertValue(testData.MeanActiveUnitActivation);
displayDataList.Add(newDisplayData);
}
}
}
break;
case 5:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch)
{
if (testData.MeanInactiveUnitActivation == testData.MeanInactiveUnitActivation)
{
displayData.InsertValue(testData.MeanInactiveUnitActivation);
isExist = true;
}
break;
}
}
if (!isExist)
{
if (testData.MeanInactiveUnitActivation == testData.MeanInactiveUnitActivation)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.InsertValue(testData.MeanInactiveUnitActivation);
displayDataList.Add(newDisplayData);
}
}
}
break;
}
testDisplayChart.Series.Clear();
testDisplayChart.Legends.Clear();
Series dataSeries = new Series();
dataSeries.ChartType = SeriesChartType.Line;
testDisplayChart.Series.Add(dataSeries);
foreach (DisplayData displayData in displayDataList)
{
DataPoint dataPoint = new DataPoint();
dataPoint.SetValueXY(displayData.Epoch, displayData.Value);
dataSeries.Points.Add(dataPoint);
}
}
catch
{
}
}
else if (useTimeStampCheckBox.Checked)
{
int maxXAxis = 0;
foreach (TestData testData in simulator.TestDataList) if (testData.TimeStamp > maxXAxis) maxXAxis = testData.TimeStamp;
testDisplayChart.ChartAreas[0].Area3DStyle.Enable3D = true;
testDisplayChart.ChartAreas[0].Area3DStyle.PointDepth = 50;
testDisplayChart.ChartAreas[0].AxisX.Minimum = 0;
testDisplayChart.ChartAreas[0].AxisX.Maximum = maxXAxis;
testDisplayChart.ChartAreas[0].AxisY.Minimum = double.Parse(minYAxisTestDisplayTextBox.Text);
testDisplayChart.ChartAreas[0].AxisY.Maximum = double.Parse(maxYAxisTestDisplayTextBox.Text);
List<DisplayData> displayDataList = new List<DisplayData>();
try
{
switch (testDisplayModeComboBox.SelectedIndex)
{
case 0:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch && testData.TimeStamp == displayData.TimeStamp)
{
displayData.InsertValue(testData.MeanSquredError);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.TimeStamp = testData.TimeStamp;
newDisplayData.InsertValue(testData.MeanSquredError);
displayDataList.Add(newDisplayData);
}
}
break;
case 1:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch && testData.TimeStamp == displayData.TimeStamp)
{
displayData.InsertValue(testData.MeanSemanticStress);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.TimeStamp = testData.TimeStamp;
newDisplayData.InsertValue(testData.MeanSemanticStress);
displayDataList.Add(newDisplayData);
}
}
break;
case 2:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch && testData.TimeStamp == displayData.TimeStamp)
{
displayData.InsertValue(testData.MeanCrossEntropy);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.TimeStamp = testData.TimeStamp;
newDisplayData.InsertValue(testData.MeanCrossEntropy);
displayDataList.Add(newDisplayData);
}
}
break;
case 3:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch && testData.TimeStamp == displayData.TimeStamp)
{
if (testData.Correctness) displayData.InsertValue(1);
else displayData.InsertValue(0);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.TimeStamp = testData.TimeStamp;
if (testData.Correctness) newDisplayData.InsertValue(1);
else newDisplayData.InsertValue(0);
displayDataList.Add(newDisplayData);
}
}
break;
case 4:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch && testData.TimeStamp == displayData.TimeStamp)
{
if (testData.MeanInactiveUnitActivation == testData.MeanInactiveUnitActivation)
{
displayData.InsertValue(testData.MeanActiveUnitActivation);
isExist = true;
}
break;
}
}
if (!isExist)
{
if (testData.MeanInactiveUnitActivation == testData.MeanInactiveUnitActivation)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.TimeStamp = testData.TimeStamp;
newDisplayData.InsertValue(testData.MeanActiveUnitActivation);
displayDataList.Add(newDisplayData);
}
}
}
break;
case 5:
foreach (TestData testData in simulator.TestDataList)
{
bool isExist = false;
foreach (DisplayData displayData in displayDataList)
{
if (testData.Epoch == displayData.Epoch && testData.TimeStamp == displayData.TimeStamp)
{
displayData.InsertValue(testData.MeanInactiveUnitActivation);
isExist = true;
break;
}
}
if (!isExist)
{
DisplayData newDisplayData = new DisplayData();
newDisplayData.Epoch = testData.Epoch;
newDisplayData.TimeStamp = testData.TimeStamp;
newDisplayData.InsertValue(testData.MeanInactiveUnitActivation);
displayDataList.Add(newDisplayData);
}
}
break;
}
testDisplayChart.Series.Clear();
testDisplayChart.Legends.Clear();
testDisplayChart.Legends.Add(new Legend());
testDisplayChart.Legends[0].Name = "";
Dictionary<int, Series> dataSeriesDictionary = new Dictionary<int, Series>();
foreach (DisplayData displayData in displayDataList)
{
if (!dataSeriesDictionary.ContainsKey(displayData.Epoch))
{
Series newSeries = new Series();
newSeries.ChartType = SeriesChartType.Line;
newSeries.Name = "Epoch" + displayData.Epoch.ToString();
testDisplayChart.Series.Add(newSeries);
dataSeriesDictionary[displayData.Epoch] = newSeries;
LegendItem newLegendItem = new LegendItem();
newLegendItem.ImageStyle = LegendImageStyle.Line;
//newLegendItem.Name = "Epoch" + displayData.Epoch.ToString();
newLegendItem.SeriesName = displayData.Epoch.ToString();
testDisplayChart.Legends[0].CustomItems.Add(newLegendItem);
}
DataPoint dataPoint = new DataPoint();
dataPoint.SetValueXY(displayData.TimeStamp, displayData.Value);
dataSeriesDictionary[displayData.Epoch].Points.Add(dataPoint);
}
}
catch
{
}
}
}
