private void Start()
{
rule = Rule.Instance;
model = PlotViewModel.Instance;
controller = Controller.Instance;
this.ObserveEveryValueChanged(_ => controller.CurrentPhase)
.Subscribe(_ => UpdatePath())
.AddTo(this);
model.MovePlots.ObserveReplace()
.Subscribe(_ => UpdatePath())
.AddTo(this);
model.ActionPlots.ObserveReplace()
.Subscribe(_ => UpdatePath())
.AddTo(this);
for (int i = 0; i < rule.CountOfMoment.Value; ++i)
{
GameObject instance = Instantiate(pathPrefab);
instance.transform.SetParent(transform);
pathes.Add(instance);
}
Clear();
}
private void Start()
{
controller = Controller.Instance;
plotModel = PlotViewModel.Instance;
this.ObserveEveryValueChanged(_ => controller.CurrentPhase)
.Subscribe(p => {
CanvasGroup cg = GetComponent <CanvasGroup>();
switch (p)
{
case Phase.MovePlot:
cg.alpha = 1.0f;
cg.blocksRaycasts = true;
UpdateCards();
GetComponentsInChildren <DraggableCard>().ForEach(dc => {
dc.SetAsMovePlot();
});
break;
case Phase.ActionPlot:
UpdateCards();
GetComponentsInChildren <DraggableCard>().ForEach(dc => {
dc.SetAsActionPlot();
});
break;
case Phase.Resolve:
cg.alpha = 0.3f;
cg.blocksRaycasts = false;
break;
}
})
.AddTo(this);
}
public PlotWidget()
{
InitializeComponent();
DataContext = this;
PlotViewModel.CreateXYAxes();
SetupPlotView();
}
public virtual ActionResult RosenbrockFunction(PlotViewModel model)
{
if (!ModelState.IsValid)
{
if (model.Width == 0 && model.Height == 0)
{
ModelState.Clear();
}
model = new PlotViewModel()
{
Width = 400,
Height = 400,
ContoursCount = 10,
ScalePower = 0.2,
InitialX = -0.1,
InitialY = 4.5,
MinDerivCompMaxMagn = 0.1,
MaxIters = 1024,
BasicStep = 0.0005,
MomentumStep = 0.0005,
MomentumStart = 0.6,
MomentumEnd = 0.9,
};
}
Logger.LogInfo <PlotController>("Rosenbrock function plot shown.");
ViewBag.Name = "Rosenbrock function";
ViewBag.ViewAction = MVC.Plot.RosenbrockFunctionPlot();
return(View(Views.Plot, model));
}
public void BindPlotModel(PlotViewModel model)
{
model.MovePlots.ObserveReplace()
.Subscribe(_ => {
CanvasGroup cg = GetComponent <CanvasGroup>();
if (model.MovePlots.Contains(card))
{
cg.alpha = 0.3f;
cg.blocksRaycasts = false;
}
else
{
cg.alpha = 1f;
cg.blocksRaycasts = true;
}
})
.AddTo(this);
model.ActionPlots.ObserveReplace()
.Subscribe(_ => {
CanvasGroup cg = GetComponent <CanvasGroup>();
if (model.ActionPlots.Contains(card))
{
cg.alpha = 0.3f;
cg.blocksRaycasts = false;
}
else
{
cg.alpha = 1f;
cg.blocksRaycasts = true;
}
})
.AddTo(this);
}
public void verify_ExecuteFluenceSolverCommand_returns_correct_values()
{
// WindowViewModel needs to be instantiated for default constructor
var windowViewModel = new WindowViewModel();
var viewModel = windowViewModel.FluenceSolverVM;
viewModel.ForwardSolverTypeOptionVM.SelectedValue = ForwardSolverType.PointSourceSDA;
viewModel.FluenceSolutionDomainTypeOptionVM.SelectedValue = FluenceSolutionDomainType.FluenceOfRhoAndZ;
var result = viewModel.GetMapData();
result.Wait();
// ExecuteForwardSolver default settings
PlotViewModel plotViewModel = windowViewModel.PlotVM;
Assert.AreEqual(plotViewModel.Labels.Count, 0);
Assert.AreEqual(plotViewModel.Title, null);
TextOutputViewModel textOutputViewModel = windowViewModel.TextOutputVM;
double d1 = 0.01;
int i1 = 1;
double g = 0.8;
double n = 1.4;
var s1 = StringLookup.GetLocalizedString("Label_FluenceSolver") +
StringLookup.GetLocalizedString("Label_MuA") + "=" +
d1.ToString(CultureInfo.CurrentCulture) + " " +
StringLookup.GetLocalizedString("Label_MuSPrime") + "=" +
i1.ToString(CultureInfo.CurrentCulture) + " g=" +
g.ToString(CultureInfo.CurrentCulture) + " n=" +
n.ToString(CultureInfo.CurrentCulture) + "; " +
StringLookup.GetLocalizedString("Label_Units") + " = 1/mm\r";
Assert.AreEqual(textOutputViewModel.Text, s1);
}
public MapViewModel GetMapViewModel(string option)
{
PlotViewModel relativeModel = GetRelativeViewModel(option, 0);
List <MapCountryCodeModel> series = new List <MapCountryCodeModel>();
foreach (var itemRelative in relativeModel.Series)
{
PopulationCountry populationCountry = _countryService.GetCountry(itemRelative.name);
if ((populationCountry != null) && (itemRelative.data.Count > 0))
{
var itemMapModel = new MapCountryCodeModel
{
code3 = populationCountry.IsoCode,
value = itemRelative.data[itemRelative.data.Count - 1]
};
series.Add(itemMapModel);
}
}
return(new MapViewModel
{
UpdateTime = relativeModel.UpdateTime,
Data = series
});
}
public void BindMoment(int momentIndex, IPlayer player, PlotViewModel model)
{
this.ObserveEveryValueChanged(_ => controller.CurrentPhase)
.Where(phase => phase == Phase.Resolve)
.Subscribe(_ => {
if (controller.EnemyPlayer.Plots.GetActionPlot(momentIndex) != null)
{
GetComponent <Image>().enabled = true;
cardImage.sprite = controller.EnemyPlayer.Plots.GetActionPlot(momentIndex).Action.CardImage;
cardImage.transform.localRotation = Quaternion.Euler(Vector3.zero);
cardImage.transform.localScale = new Vector3(1f, 1f, 1f);
}
else if (controller.EnemyPlayer.Plots.GetMovePlot(momentIndex) != null)
{
GetComponent <Image>().enabled = false;
cardImage.sprite = arrowSprite;
cardImage.transform.localRotation = Quaternion.Euler(new Vector3(0f, 0f, controller.EnemyPlayer.Plots.GetMovePlot(momentIndex).MoveDirection.ToRotateZ()));
cardImage.transform.localScale = new Vector3(-0.75f, -0.75f, 1f);
}
else
{
GetComponent <Image>().enabled = true;
cardImage.sprite = null;
cardImage.transform.localRotation = Quaternion.Euler(Vector3.zero);
cardImage.transform.localScale = new Vector3(1f, 1f, 1f);
}
})
.AddTo(this);
}
private ActionResult plot(IFunctionWithDerivative f, PlotViewModel model)
{
List <Tuple <Color, List <Vector <double> > > > points = new List <Tuple <Color, List <Vector <double> > > >();
double minDeriv = model.MinDerivCompMaxMagn;
var result = new DenseVector(f.DimensionsCount);
{
result[0] = model.InitialX;
result[1] = model.InitialY;
var ps = new List <Vector <double> >();
points.Add(new Tuple <Color, List <Vector <double> > >(Color.Lime, ps));
var sdImpl = new SteepestDescentBasicOptmizer(model.BasicStep, model.MaxIters);
sdImpl.Optimize(result, f, model.MinDerivCompMaxMagn, (i, pFunc) => ps.Add(pFunc()), CancellationToken.None);
}
{
result[0] = model.InitialX;
result[1] = model.InitialY;
var ps = new List <Vector <double> >();
points.Add(new Tuple <Color, List <Vector <double> > >(Color.Red, ps));
var sdImpl = new SteepestDescentBasicOptmizer(model.MomentumStep,
model.MomentumStart, model.MomentumEnd, model.MaxIters);
sdImpl.Optimize(result, f, model.MinDerivCompMaxMagn, (i, pFunc) => ps.Add(pFunc()), CancellationToken.None);
}
{
result[0] = model.InitialX;
result[1] = model.InitialY;
var ps = new List <Vector <double> >();
points.Add(new Tuple <Color, List <Vector <double> > >(Color.Blue, ps));
var sdImpl = new SteepestDescentAdvancedOptmizer(model.MomentumStep,
model.MomentumStart, model.MomentumEnd, model.MaxIters);
sdImpl.Optimize(result, f, model.MinDerivCompMaxMagn, (i, pFunc) => ps.Add(pFunc()), CancellationToken.None);
}
{
result[0] = model.InitialX;
result[1] = model.InitialY;
var ps = new List <Vector <double> >();
points.Add(new Tuple <Color, List <Vector <double> > >(Color.Magenta, ps));
var sdImpl = new RpropPlusOptmizer(model.BasicStep, 10, 1.2, 0.5, model.MaxIters);
sdImpl.Optimize(result, f, model.MinDerivCompMaxMagn, (i, pFunc) => ps.Add(pFunc()), CancellationToken.None);
}
{
result[0] = model.InitialX;
result[1] = model.InitialY;
var ps = new List <Vector <double> >();
points.Add(new Tuple <Color, List <Vector <double> > >(Color.Cyan, ps));
var sdImpl = new ImprovedRpropMinusOptmizer(model.BasicStep, 10, 1.2, 0.5, model.MaxIters);
sdImpl.Optimize(result, f, model.MinDerivCompMaxMagn, (i, pFunc) => ps.Add(pFunc()), CancellationToken.None);
}
var fp = new FunctionPlotter();
var img = fp.AutoContourPlot(f, points, 0.1f, 0, 1, model.Width, model.Height,
model.ContoursCount, model.ScalePower);
var ms = new MemoryStream();
img.Save(ms, ImageFormat.Png);
ms.Seek(0, SeekOrigin.Begin);
return(File(ms, "image/png"));
}
private void PlotViewModel_KeyDown(object sender, OxyKeyEventArgs e)
{
if (e.Key == OxyKey.R && e.ModifierKeys == OxyModifierKeys.None)
{
AdjustYAxisZoom();
PlotViewModel.InvalidatePlot(false);
}
}
public UserData(PlotViewModel plotViewModel)
{
A = plotViewModel.A;
B = plotViewModel.B;
C = plotViewModel.C;
Step = plotViewModel.Step;
RangeFrom = plotViewModel.RangeFrom;
RangeTo = plotViewModel.RangeTo;
}
public void verify_SetAxesLabelsCommand_returns_correct_values()
{
var viewModel = new PlotViewModel();
viewModel.SetAxesLabels.Execute(null);
// the following validation values were determined by prior running of unit test
Assert.AreEqual(viewModel.CurrentIndependentVariableAxis, IndependentVariableAxis.Rho);
Assert.AreEqual(viewModel.Title, null);
}
private void OnPlot(Tuple <ObservableCollection <int>, ObservableCollection <int> > data)
{
Log.Info("Received plot message");
var plotViewModel = new PlotViewModel(data.Item1, data.Item2);
var orchestraService = GetService <IOrchestraService>();
orchestraService.ShowDocument(plotViewModel);
}
public void BindMoment(int momentIndex, IPlayer player, PlotViewModel model)
{
model.MovePlots.ObserveReplace()
.Subscribe(_ => {
GetComponentsInChildren <ICardBindable>().ForEach(cb => {
cb.BindCard(model.MovePlots[momentIndex]);
});
})
.AddTo(this);
}
public void BindMoment(int momentIndex, IPlayer player, PlotViewModel model)
{
this.ObserveEveryValueChanged(_ => player.Plots.IsActionPenarized(momentIndex))
.Subscribe(penarized => {
cross.SetActive(penarized);
})
.AddTo(this);
cross.SetActive(player.Plots.IsActionPenarized(momentIndex));
}
void Display(PlotViewModel context)
{
var vm = GetViewModel();
if (vm != null)
{
_contexts.Add(context);
vm.LastPlot = context;
}
}
private void Start()
{
controller = Controller.Instance;
plotVM = PlotViewModel.Instance;
GetComponent <LongClickFillButton>().onLongClick.AddListener(() => {
rpcInvoker.InvokeRpcSubmitMovePlot(
controller.MyPlayer == controller.Player1,
plotVM.MovePlots.Select(c => c != null ? c.Id : -1).ToArray());
});
}
public virtual ActionResult RosenbrockFunctionPlot(PlotViewModel model)
{
if (!ModelState.IsValid)
{
return(HttpNotFound());
}
var f = new RosenbrockFunction();
return(plot(f, model));
}
public virtual ActionResult CrazySinCosFunctionPlot(PlotViewModel model)
{
if (!ModelState.IsValid)
{
return(HttpNotFound());
}
var f = new SinCosCrazyFunction();
return(plot(f, model));
}
public ApproximationViewModel()
{
_approximation = new Approximation();
OpenTrainFileClick = new RelayCommand(OpenTrainFile);
OpenTestFileClick = new RelayCommand(OpenTestFile);
OpenInTextEditorClick = new RelayCommand(OpenInTextEditor,
() => _pathToFile != null && _pathToFile.Any());
ApproximateClick = new RelayCommand(AproximateAndPlot);
DoStuffClick = new RelayCommand(ShowPlotFromDataWithoutLearning);
_plotModelViewModel = new PlotViewModel();
_errorPlotModelViewModel = new ErrorPlotViewModel();
GenerateClick = new RelayCommand(Generate);
}
public IActionResult Growth(string option)
{
PlotViewModel model = _covidService.GetGrowthViewModel();
ViewData["Title"] = "Growth";
ViewData["YLabel"] = "Deaths per day";
ViewData["TooltipDecimals"] = 0;
ViewData["YMin"] = 0.1;
ViewData["YType"] = "linear";
ViewData["YTickInterval"] = 100;
ViewData["XLabel"] = "Days from death 10";
return(View("Plot", model));
}
public IActionResult Relative(string option = Covid19DeathsService.NORM_POPULATION)
{
PlotViewModel model = _covidService.GetRelativeViewModel(option, Covid19DeathsService.MIN_DEATHS_MILLION);
ViewData["Title"] = "Relative";
ViewData["YLabel"] = "Deaths / " + option;
ViewData["TooltipDecimals"] = 2;
ViewData["YMin"] = 1;
ViewData["YType"] = "linear";
ViewData["YTickInterval"] = 1;
ViewData["XLabel"] = "Days from 1 death / million";
return(View("Plot", model));
}
public void verify_ClearPlotCommand_returns_correct_values()
{
var viewModel = new PlotViewModel();
viewModel.ClearPlotCommand.Execute(null);
// ClearPlot public settings
Assert.AreEqual(viewModel.Labels.Count, 0);
Assert.AreEqual(viewModel.Title, null);
// UpdatePlotSeries settings
Assert.AreEqual(viewModel.PlotModel.Series.Count, 0);
Assert.AreEqual(viewModel.PlotSeriesCollection.Count, 0);
Assert.IsFalse(viewModel.ShowComplexPlotToggle);
Assert.IsTrue(viewModel.PlotModel.IsLegendVisible);
}
private void Start()
{
rule = Rule.Instance;
controller = Controller.Instance;
model = PlotViewModel.Instance;
this.ObserveEveryValueChanged(_ => controller.CurrentPhase)
.Where(p => p == Phase.Start)
.Subscribe(_ => {
transform.DestroyAllChildren();
for (int i = 0; i < rule.CountOfMoment.Value; ++i)
{
GameObject moment = Instantiate(momentPrefab);
moment.GetComponentsInChildren <IControllerSettable>().ForEach(cs => {
cs.SetController(controller);
});
moment.GetComponentsInChildren <IMomentIndexBindable>().ForEach(mib => {
if (isMyPlayer)
{
mib.BindMoment(i, controller.MyPlayer, model);
}
else
{
mib.BindMoment(i, controller.EnemyPlayer, model);
}
});
moment.transform.SetParent(transform, false);
moment.GetComponent <RectTransform>().SetAsLastSibling();
}
GetComponentsInChildren <Detail>().ForEach(d => {
d.DetailRoot = detailRoot;
});
GetComponentsInChildren <ICardBindable>().ForEach(cb => {
cb.BindCard(null);
});
GetComponentsInChildren <DraggableCard>().ForEach(d => {
d.DraggingArrowPrefab = draggingArrowPrefab;
d.DraggingActionPrefab = draggingActionPrefab;
d.DraggingContainer = draggingContainer;
});
})
.AddTo(this);
}
public void verify_default_constructor_sets_properties_correctly()
{
var viewModel = new PlotViewModel();
Assert.IsTrue(viewModel.XAxisSpacingOptionVm != null);
Assert.IsTrue(viewModel.YAxisSpacingOptionVm != null);
Assert.IsTrue(viewModel.PlotToggleTypeOptionVm != null);
Assert.IsTrue(viewModel.PlotNormalizationTypeOptionVm != null);
Assert.AreEqual("", viewModel.CustomPlotLabel);
Assert.AreEqual(ReflectancePlotType.ForwardSolver, viewModel.PlotType);
Assert.AreEqual("", viewModel.PlotModel.Title);
Assert.AreEqual(viewModel.PlotModel.LegendPlacement, LegendPlacement.Outside);
// todo: Once the popout bug is fixed and we update OxyPlot, replace the above line with this one:
//Assert.AreEqual(viewModel.PlotModel.Legends[0].LegendPlacement, LegendPlacement.Outside);
}
public IActionResult GrowthRelative(string option)
{
PlotViewModel model = _covidService.GetRelativeGrowthViewModel(option,
Covid19DeathsService.MIN_DEATHS_MILLION);
ViewData["Title"] = "Growth relative";
ViewData["YLabel"] = "Deaths per day / million";
ViewData["TooltipDecimals"] = 1;
ViewData["YMin"] = 0;
ViewData["YType"] = "linear";
ViewData["YTickInterval"] = 10;
ViewData["XLabel"] = "Days from death 10";
return(View("Plot", model));
}
private void SetupPlotVerify(Models.IsotopeModel isotope)
{
double halfLife = ElementViewModel.GetHalfLife(isotope);
if (halfLife <= 0)
{
Assert.IsInstanceOfType(mainViewModel.PlotViewModel.Effect,
typeof(BlurEffect));
Assert.AreEqual((halfLife, " ", 10),
(mainViewModel.PlotViewModel.UnitHalfLife, mainViewModel.PlotViewModel.Unit, mainViewModel.PlotViewModel.MaximumTime));
return;
}
Assert.AreEqual((null, PlotViewModel.ConvertToAppropriateUnit(ref halfLife), halfLife, 998),
(mainViewModel.PlotViewModel.Effect, mainViewModel.PlotViewModel.Unit, mainViewModel.PlotViewModel.UnitHalfLife, mainViewModel.PlotViewModel.DataPoints.Count));
}
public IActionResult Growth(string metric, string option)
{
PlotViewModel model = _covidService.GetGrowthViewModel(metric);
ViewData["Metric"] = metric;
ViewData["Method"] = System.Reflection.MethodBase.GetCurrentMethod().Name;
ViewData["Title"] = "Growth";
ViewData["YLabel"] = metric + " per day";
ViewData["TooltipDecimals"] = 0;
ViewData["YMin"] = 0.1;
ViewData["YType"] = "linear";
ViewData["YTickInterval"] = 100;
ViewData["XLabel"] = "Days from 10 " + metric;
return(View("Plot", model));
}
public IActionResult Relative(string metric, string option = ViewModelService.NORM_POPULATION)
{
PlotViewModel model = _covidService.GetRelativeViewModel(metric, option, ViewModelService.MIN_DEATHS_MILLION);
ViewData["Metric"] = metric;
ViewData["Method"] = System.Reflection.MethodBase.GetCurrentMethod().Name;
ViewData["Title"] = "Relative";
ViewData["YLabel"] = metric + " / " + option;
ViewData["TooltipDecimals"] = 2;
ViewData["YMin"] = 1;
ViewData["YType"] = "linear";
ViewData["YTickInterval"] = 1;
ViewData["XLabel"] = $"Days from 1 {metric} / million";
return(View("Plot", model));
}
public IActionResult GrowthRelative(string metric, string option)
{
PlotViewModel model = _covidService.GetRelativeGrowthViewModel(metric, option,
ViewModelService.MIN_DEATHS_MILLION);
ViewData["Metric"] = metric;
ViewData["Method"] = System.Reflection.MethodBase.GetCurrentMethod().Name;
ViewData["Title"] = "Growth relative";
ViewData["YLabel"] = metric + " per day / million";
ViewData["TooltipDecimals"] = 1;
ViewData["YMin"] = 0;
ViewData["YType"] = "linear";
ViewData["YTickInterval"] = 10;
ViewData["XLabel"] = "Days from 10 " + metric;
return(View("Plot", model));
}
