protected void ProgressMessage(string message, double?percent = null)
{
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage(message, percent);
}
}
public void ProgressObserver_StartAndStopObserving_ArgChecks()
{
// Can't test the overloaded without IProgressVisualizer since using GlobalService to get various services.
// StartObserving (IProgressController, IProgressVisualizer)
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StartObserving(this.testController, (IProgressVisualizer)null));
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StartObserving((IProgressController)null, this.testVisualizer));
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StartObserving((IProgressController)null, (IProgressVisualizer)null));
// StartObserving (IServiceProvider, IProgressEvents,IProgressVisualizer)
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StartObserving((IServiceProvider)null, this.progressEvents, this.testVisualizer));
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StartObserving(this.testServiceProvider, this.progressEvents, null));
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StartObserving(this.testServiceProvider, null, this.testVisualizer));
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StartObserving((IServiceProvider)null, (IProgressEvents)null, (IProgressVisualizer)null));
// StopObserving
Exceptions.Expect <ArgumentNullException>(() => ProgressObserver.StopObserving(null));
// Invalid IProgressController
this.testController.Events.Steps = null;
Exceptions.Expect <InvalidOperationException>(() => ProgressObserver.StartObserving(this.testController, this.testVisualizer));
this.testController.Events = null;
Exceptions.Expect <InvalidOperationException>(() => ProgressObserver.StartObserving(this.testController, this.testVisualizer));
// Invalid IProgressEvents
Exceptions.Expect <InvalidOperationException>(() => ProgressObserver.StartObserving(this.testServiceProvider, this.progressEvents, this.testVisualizer));
}
protected void ProgressEnd(string message)
{
if (ProgressObserver != null)
{
ProgressObserver.ProgressEnd(message);
}
}
protected void ProgressMessage(string format, params object[] args)
{
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage(string.Format(format, args));
}
}
private static ProgressObserver Observe(IProgressController controller, IProgressVisualizer visualizer)
{
ProgressObserver observer = CreateObserver(controller, visualizer, null);
observedControllersMap.Add(controller, observer);
return(observer);
}
protected void ProgressStart(string message, bool indeterminate = false)
{
if (ProgressObserver != null)
{
ProgressObserver.ProgressStart(message, indeterminate);
}
}
/// <summary>
/// Рекурсивное сравнение одноимённых узлов, слияние одинаковых узлов в один (beta)
/// </summary>
public static void MergeDiffNodes(this ObservableCollection <Node> tree
, ProgressObserver progressObserver = null, CancellationToken?token = null)
{
foreach (var projNode in tree)
{
foreach (var repoNode in projNode.Nodes)
{
if (repoNode is RepoNode repoInfoNode &&
repoInfoNode.IsDiffMode &&
repoInfoNode.CurrentBranch != null &&
repoInfoNode.CurrentBranch != repoInfoNode.CurrentDiffBranch)
{
if (progressObserver != null)
{
progressObserver.ProgressData = $"[{repoInfoNode.RepoInfoData.Project.Name}/{repoInfoNode.Name}]";
progressObserver.Status = ProgressObserver.StartedStatus;
}
// ожидается что repoInfoNode.Nodes уже отсортированы по имени
MergeDiffNodes(repoInfoNode.Nodes, node => GetBranchByNode(node).Equals(repoInfoNode.CurrentBranch));
if (progressObserver != null)
{
progressObserver.ProgressData = $"[{repoInfoNode.RepoInfoData.Project.Name}/{repoInfoNode.Name}]";
progressObserver.Status = ProgressObserver.FinishedStatus;
progressObserver.Counter++;
}
}
}
}
}
public ExecutionVerifier(IProgressVisualizer visualizer, ProgressObserver testSubject)
{
visualizer.Should().NotBeNull();
testSubject.Should().NotBeNull();
this.visualizer = visualizer;
this.testSubject = testSubject;
}
public void ProgressObserver_StartObserving_DontConfiguresCancelCommand()
{
// Act
this.testSubject = ProgressObserver.StartObserving(this.testServiceProvider, this.progressEvents, this.testVisualizer);
// Assert
this.testSubject.CancelCommand.Should().BeNull("CancelCommand should not be set");
}
public ExecutionVerifier(IProgressVisualizer visualizer, ProgressObserver testSubject)
{
Assert.IsNotNull(visualizer != null, "IProgressVisualizer is expected");
Assert.IsNotNull(testSubject != null, "ProgressObserver is expected");
this.visualizer = visualizer;
this.testSubject = testSubject;
}
public void ProgressObserver_StartObserving_DontConfiguresCancelCommand()
{
// Execute
this.testSubject = ProgressObserver.StartObserving(this.testServiceProvider, this.progressEvents, this.testVisualizer);
// Verify
Assert.IsNull(this.testSubject.CancelCommand, "CancelCommand should not be set");
}
public void ProgressObserver_StopObserving_Twice()
{
this.testSubject = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
ProgressObserver.StopObserving(this.testSubject);
Assert.IsTrue(this.testSubject.IsDisposed, "Expecting to be disposed");
ProgressObserver.StopObserving(this.testSubject);
Assert.IsTrue(this.testSubject.IsDisposed, "Expecting to remain disposed");
}
public void TestChildScopeNotCompleted()
{
List<double> progress = new List<double>();
ProgressObserver progressObserver = new ProgressObserver(s => progress.Add(s.Progress));
using (ProgressReportScope scope = new ProgressReportScope())
{
scope.Subscribe(progressObserver);
scope.CreateChildScope(0.5);
}
ProgressAssert.AreEqual(new[] { 0.5, 1.0 }, progress);
}
protected virtual async Task TimeConsumingProcessAsync(ProgressObserver <ProgressWithPercentage <string> > progress, OneOfRequest request)
{
foreach (var step in Steps)
{
await progress.Report(step.InvokeAsync().Result, step.ProgressPercentage);
}
//await progress.ThrowException(new Exception("Your pizza has been burnt!!"));
await progress.ReportComplete("Your pizza is ready!");
}
public void ProgressObserver_StartAndStopObserving_OnBackgroundThread()
{
this.threadService.SetCurrentThreadIsUIThread(false);
this.testSubject = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
Assert.AreSame(this.testVisualizer, this.testSubject.Visualizer, "Unexpected visualizer");
Assert.IsNotNull(this.testSubject, "Failed to create observer on a background thread");
Assert.IsFalse(this.testSubject.IsDisposed, "Not expecting to be disposed");
ProgressObserver.StopObserving(this.testSubject);
Assert.AreSame(this.testVisualizer, this.testSubject.Visualizer, "Unexpected visualizer");
Assert.IsTrue(this.testSubject.IsDisposed, "Expecting to be disposed");
}
public void ProgressObserver_StartAndStopObserving_OnForegroundThread()
{
this.threadService.SetCurrentThreadIsUIThread(true);
this.testSubject = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
this.testSubject.Visualizer.Should().Be(this.testVisualizer, "Unexpected visualizer");
this.testSubject.Should().NotBeNull("Failed to create observer on a foreground thread");
this.testSubject.IsDisposed.Should().BeFalse("Not expecting to be disposed");
ProgressObserver.StopObserving(this.testSubject);
this.testSubject.Visualizer.Should().Be(this.testVisualizer, "Unexpected visualizer");
this.testSubject.IsDisposed.Should().BeTrue("Expecting to be disposed");
}
public void TestCleanup()
{
if (this.testSubject != null)
{
((IDisposable)this.testSubject).Dispose();
this.testSubject = null;
}
this.testVisualizer = null;
this.testServiceProvider = null;
this.progressEvents = null;
this.threadService = null;
this.testController = null;
}
public RandomNumberGeneratorViewModel()
{
if (!DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
InitializeData();
}
GeneratorResult = new List <int>();
RunGenerator = new RunGeneratorCommand(this);
Cancel = new CancelCommand(this);
GeneratorProgressObserver = new ProgressObserver();
DataSavingProgressObserver = new ProgressObserver();
}
public void ProgressObserver_StartObserving_StateTransfer()
{
var observer = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
ProgressObserver.StopObserving(observer);
this.CreateTestSubject(observer.State);
Assert.AreNotSame(this.testSubject.State, observer, "Test setup error: should be different");
Assert.AreSame(this.testSubject.State, observer.State, "The state should transfer");
Assert.IsFalse(this.testSubject.IsDisposed, "Not expecting to be disposed");
ProgressObserver.StopObserving(this.testSubject);
Assert.AreSame(this.testVisualizer, this.testSubject.Visualizer, "Unexpected visualizer");
Assert.IsTrue(this.testSubject.IsDisposed, "Expecting to be disposed");
}
public void ProgressObserver_StartObserving_ConfiguresCancelCommand()
{
bool aborted = false;
this.testController.TryAbortAction = () =>
{
aborted = true;
return(true);
};
this.testSubject = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
Assert.IsNotNull(this.testSubject.CancelCommand, "CancelCommand should be set");
this.testSubject.CancelCommand.Execute(null);
Assert.IsTrue(aborted, "TryAbort was configured to be called by the CancelCommand");
}
public void ProgressStepRunner_Observe()
{
// Setup
ConfigurableProgressController controller = new ConfigurableProgressController();
ConfigurableProgressControlHost host = new ConfigurableProgressControlHost();
controller.AddSteps(new ConfigurableProgressStep());// Needs at least one
// Act
using (ProgressObserver observer1 = ProgressStepRunner.Observe(controller, host))
{
// Verify
Assert.IsNotNull(observer1, "Unexpected return value");
Assert.AreSame(observer1, ProgressStepRunner.ObservedControllers[controller]);
host.AssertHasProgressControl();
}
}
/// <summary>
/// Получает последовательность всех солюшенов из репозитория (на указанной ветке)
/// </summary>
public static IEnumerable <Result <CsSolution> > GetAllSolutions(
ICodebaseService codebaseService
, BranchInfo branch
, ProgressObserver progressObserver = null)
{
if (codebaseService == null)
{
throw new ArgumentNullException(nameof(codebaseService));
}
bool isSolutionFileInfo(SourceItemInfo item)
=> item.Type == SourceItemTypes.File && item.Extension?.ToLower() == "sln";
return(codebaseService.FindAllItems(
branch
, null
, isSolutionFileInfo
, items => items.Any(isSolutionFileInfo)
, true
, progressObserver)
.Select(solutionFileInfo =>
{
try
{
var solutionFileContent = codebaseService.GetSourceFileContent(solutionFileInfo);
var solutionFile = CsSolutionFile.Parse(solutionFileContent, solutionFileInfo);
var projectFiles = solutionFile.CsProjectFileInfos
.Select(projectFileInfo => CsProjectFile.Parse(codebaseService, projectFileInfo));
return new Result <CsSolution>
{
IsSuccessful = true,
Data = new CsSolution(solutionFile, projectFiles)
};
}
catch (Exception e)
{
return new Result <CsSolution>
{
IsSuccessful = false,
Tag = solutionFileInfo,
ErrorMessage = e.Message
};
}
}));
}
public void ProgressStepRunner_Observe()
{
// Arrange
ConfigurableProgressController controller = new ConfigurableProgressController();
ConfigurableProgressControlHost host = new ConfigurableProgressControlHost();
controller.AddSteps(new ConfigurableProgressStep());// Needs at least one
// Act
using (ProgressObserver observer1 = ProgressStepRunner.Observe(controller, host))
{
// Assert
observer1.Should().NotBeNull("Unexpected return value");
ProgressStepRunner.ObservedControllers[controller].Should().Be(observer1);
host.ProgressControl.Should().NotBeNull();
}
}
public void ProgressObserver_GroupToExecutionUnits()
{
ProgressObserver.ExecutionGroup[] result;
// Visible Hidden Visible
bool randomIndeterminate = Environment.TickCount % 2 == 0;
var visibleHiddenVisible = CreateRandomSteps(1, true, randomIndeterminate, true)
.Union(CreateRandomSteps(1, false, randomIndeterminate, true))
.Union(CreateRandomSteps(1, true, randomIndeterminate, true)).ToArray();
result = ProgressObserver.GroupToExecutionUnits(visibleHiddenVisible);
Assert.AreEqual(2, result.Length, "Unexpected number of groups");
VerifyExecutionGroup(result[0], visibleHiddenVisible.Take(2));
VerifyExecutionGroup(result[1], new[] { visibleHiddenVisible[2] });
// Hidden Visible Hidden
randomIndeterminate = Environment.TickCount % 2 == 0;
var hiddenVisibleHidden = CreateRandomSteps(1, false, randomIndeterminate, true)
.Union(CreateRandomSteps(1, true, randomIndeterminate, true))
.Union(CreateRandomSteps(1, false, randomIndeterminate, true));
result = ProgressObserver.GroupToExecutionUnits(hiddenVisibleHidden);
Assert.AreEqual(1, result.Length, "Unexpected number of groups");
VerifyExecutionGroup(result[0], hiddenVisibleHidden);
// All visible
randomIndeterminate = Environment.TickCount % 2 == 0;
var allVisible = CreateRandomSteps(3, true, randomIndeterminate, true).ToArray();
result = ProgressObserver.GroupToExecutionUnits(allVisible);
Assert.AreEqual(3, result.Length, "Unexpected number of groups");
VerifyExecutionGroup(result[0], new[] { allVisible[0] });
VerifyExecutionGroup(result[1], new[] { allVisible[1] });
VerifyExecutionGroup(result[2], new[] { allVisible[2] });
// All hidden
randomIndeterminate = Environment.TickCount % 2 == 0;
var allHidden = CreateRandomSteps(3, false, randomIndeterminate, true);
result = ProgressObserver.GroupToExecutionUnits(allHidden);
Assert.AreEqual(0, result.Length, "Unexpected number of groups");
}
public void TestNestedScopes()
{
List<double> progress = new List<double>();
ProgressObserver progressObserver = new ProgressObserver(s => progress.Add(s.Progress));
using (ProgressReportScope scope = new ProgressReportScope())
{
scope.Subscribe(progressObserver);
using (scope.CreateChildScope(0.5))
DumbFunc();
using (ProgressReportScope child = scope.CreateChildScope(0.2))
{
using (child.CreateChildScope(0.5))
DumbFunc();
using (child.CreateChildScope(0.5))
DumbFunc();
}
}
ProgressAssert.AreEqual(new[] { 0.5, 0.6, 0.7, 1.0 }, progress);
}
public void ProgressStepRunner_AbortAll()
{
// Arrange
ConfigurableProgressController controller1 = new ConfigurableProgressController();
controller1.AddSteps(new ConfigurableProgressStep());// Needs at least one
ConfigurableProgressControlHost host1 = new ConfigurableProgressControlHost();
ProgressObserver observer1 = ProgressStepRunner.Observe(controller1, host1);
ConfigurableProgressController controller2 = new ConfigurableProgressController();
controller2.AddSteps(new ConfigurableProgressStep());// Needs at least one
ConfigurableProgressControlHost host2 = new ConfigurableProgressControlHost();
ProgressObserver observer2 = ProgressStepRunner.Observe(controller2, host2);
// Act
ProgressStepRunner.AbortAll();
// Assert
controller1.NumberOfAbortRequests.Should().Be(1);
controller2.NumberOfAbortRequests.Should().Be(1);
}
public void TestNestedScopesWithSteps(int stepsCount, double childScopeSpan, int childScopeStepsCount, double[] expectedProgress)
{
List<double> progress = new List<double>();
ProgressObserver progressObserver = new ProgressObserver(s => progress.Add(s.Progress));
using (ProgressReportScope scope = new ProgressReportScope(stepsCount))
{
scope.Subscribe(progressObserver);
for (int i = 0; i < stepsCount; i++)
{
using (ProgressReportScope childScope = scope.CreateChildScope(childScopeStepsCount, childScopeSpan))
{
for (int j = 0; j < childScopeStepsCount; j++)
{
childScope.Increase();
}
}
scope.Increase();
}
}
ProgressAssert.AreEqual(expectedProgress, progress);
}
public void ProgressStepRunner_ChangeHost()
{
// Arrange
ConfigurableProgressController controller = new ConfigurableProgressController();
controller.AddSteps(new ConfigurableProgressStep());// Needs at least one
ConfigurableProgressControlHost host1 = new ConfigurableProgressControlHost();
ProgressObserver observer = ProgressStepRunner.Observe(controller, host1);
// Act
ConfigurableProgressControlHost host2 = new ConfigurableProgressControlHost();
ProgressStepRunner.ChangeHost(host2);
// Assert
using (var newObserver = ProgressStepRunner.ObservedControllers[controller])
{
newObserver.Should().NotBeNull();
observer.Should().NotBe(newObserver);
newObserver.State.Should().Be(observer.State, "State was not transferred");
host2.ProgressControl.Should().NotBeNull();
}
}
public void ProgressStepRunner_ChangeHost()
{
// Setup
ConfigurableProgressController controller = new ConfigurableProgressController();
controller.AddSteps(new ConfigurableProgressStep());// Needs at least one
ConfigurableProgressControlHost host1 = new ConfigurableProgressControlHost();
ProgressObserver observer = ProgressStepRunner.Observe(controller, host1);
// Act
ConfigurableProgressControlHost host2 = new ConfigurableProgressControlHost();
ProgressStepRunner.ChangeHost(host2);
// Verify
using (var newObserver = ProgressStepRunner.ObservedControllers[controller])
{
Assert.IsNotNull(newObserver);
Assert.AreNotSame(newObserver, observer);
Assert.AreSame(observer.State, newObserver.State, "State was not transferred");
host2.AssertHasProgressControl();
}
}
public Task<FormulaRenderArguments> GenerateFormulaRenderArgumentsAsync(double progressSpan, double initProgress, ProgressObserver progressObserver)
{
return Task.Run(() =>
{
if (progressObserver != null)
ProgressReporter.Subscribe(progressObserver);
using (ProgressReporter.CreateScope(progressSpan, initProgress))
return GenerateFormulaRenderArguments();
});
}
private static void EvaluateFormula(FormulaTree formulaTree, Range[] ranges, Size areaSize, int threadsCount, float[] evaluatedValuesBuffer)
{
Stopwatch evaluationStopwatch = new Stopwatch();
evaluationStopwatch.Start();
if (evaluatedValuesBuffer.Length != areaSize.Square)
throw new ArgumentException("Result buffer size isn't equal to ranges area size.", "evaluatedValuesBuffer");
int xCount = areaSize.Width;
int yCount = areaSize.Height;
if (threadsCount < 1)
threadsCount = 1;
ranges = ranges.Select((r, i) => new Range(r.Start, r.End, i % 2 == 0 ? areaSize.Width : areaSize.Height)).ToArray();
const int progressSteps = 100;
using (ProgressReporter.CreateScope(progressSteps))
{
int steps = 0;
double lastProgress = 0;
double progress = 0;
ProgressObserver progressObserver = new ProgressObserver(p => progress = p.Progress);
Task[] tasks = new Task[threadsCount];
int yStepCount = yCount/threadsCount;
for (int i = 0; i < threadsCount; i++)
{
int li = i;
tasks[i] = Task.Run(() =>
{
FormulaTree ft = li == 0 ? formulaTree : FormulaTreeSerializer.Deserialize(FormulaTreeSerializer.Serialize(formulaTree));
int yStart = li * yStepCount;
ProgressReporter.Subscribe(progressObserver);
ft.EvaluateRangesIn2DProjection(ranges, xCount, yStart, yStepCount,
evaluatedValuesBuffer);
});
}
while (tasks.Any(t => t.Status != TaskStatus.RanToCompletion && t.Status != TaskStatus.Faulted && t.Status != TaskStatus.Canceled))
{
Task.WaitAny(tasks, 100);
double progressCopy = progress;
int inc = (int)((progressCopy - lastProgress) * progressSteps);
if (inc > 0)
{
for (int i = 0; i < inc && steps < progressSteps; i++)
{
ProgressReporter.Increase();
steps++;
}
lastProgress = progress;
}
}
Task.WaitAll();
}
//double x = 1;
//double y = 2;
//double z = 3;
//double w = 4;
//double x1 = -1;
//double y1 = -2;
//double z1 = -3;
//double w1 = -4;
//Stopwatch stopwatch2 = new Stopwatch();
//stopwatch2.Start();
//double[] arr = new double[Ranges[0].Count*Ranges[1].Count];
//for (int i = 0; i < arr.Length; i++)
//{
// arr[i] = Math.Sqrt((Math.Sin(x) * Math.Sin(y) + Math.Sin(z) * Math.Sin(w)) * (Math.Sin(x1) * Math.Sin(y1) + Math.Sin(z1) * Math.Sin(w1)));
// x += 0.1;
// y += 0.1;
// z += 0.1;
// w += 0.1;
// x1 += 0.3;
// y1 += 0.3;
// z1 += 0.3;
// w1 += 0.3;
//}
//stopwatch2.Stop();
evaluationStopwatch.Stop();
}
private async Task DrawImageAsync()
{
_mainWindow.Cursor = Cursors.Wait;
ProgressObserver renderingProgressObserver = new ProgressObserver(
p => _mainWindow.StatusPanel.Dispatcher.Invoke(() => _mainWindow.StatusPanel.RenderingProgress = p.Progress));
WorkflowRenderResult result = await _workflow.RenderFormulaAsync(false, Environment.ProcessorCount, renderingProgressObserver);
result.Bitmap.Update(result.FormulaRenderResult);
_mainWindow.WallpaperImage.Source = (ImageSource)result.Bitmap.PlatformBitmap;
_mainWindow.StatusPanel.RenderedTime = result.ElapsedTime;
_mainWindow.Cursor = Cursors.Arrow;
}
private static ProgressObserver CreateObserver(IProgressController controller, IProgressVisualizer visualizer, ProgressControllerViewModel state)
{
return(ProgressObserver.StartObserving(controller, visualizer, state));
}
public GridLayer RunSpeciesRichness()
{
// First load each of the layers...
IsCancelled = false;
var layers = new List <GridLayer>();
foreach (string filename in LayerFiles)
{
ProgressMessage("Loading environmental layer {0}...", filename);
layers.Add(new GridLayer(filename));
}
// Now for each point set, run the model...
var resultLayers = new List <GridLayer>();
Model.ProgressObserver = this;
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage("Running models...");
}
var first = layers[0];
int setIndex = 0;
foreach (SpeciesRichnessPointSetViewModel pointset in MapPointSets)
{
_currentPointSet = pointset.Model;
var percent = ((double)setIndex / (double)MapPointSets.Count()) * 100.0;
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage("Running model on pointset " + pointset.Name, percent);
}
FireStartPointSet(pointset.Model);
var list = new List <MapPointSet>();
list.Add(pointset.Model);
var modelLayer = Model.RunModel(layers, list);
if (modelLayer != null)
{
if (RetainLayers)
{
pointset.Filename = string.Format("{0}{1}_{2}.grd", TempFileManager.GetTemporaryFolder(), SystemUtils.StripIllegalFilenameChars(pointset.Name), setIndex);
modelLayer.SaveToGRDFile(pointset.Filename);
}
resultLayers.Add(modelLayer);
}
if (IsCancelled)
{
return(null);
}
FireEndPointSet(pointset.Model);
setIndex++;
}
var target = new GridLayer(first.Width, first.Height)
{
DeltaLatitude = first.DeltaLatitude, DeltaLongitude = first.DeltaLongitude, Flags = first.Flags, Latitude0 = first.Latitude0, Longitude0 = first.Longitude0, NoValueMarker = 0
};
target.SetAllCells(0);
foreach (GridLayer result in resultLayers)
{
for (int y = 0; y < target.Height; ++y)
{
var lat = target.Latitude0 + (y * target.DeltaLatitude); // Work out Lat. of this cell.
for (int x = 0; x < target.Width; ++x)
{
var lon = target.Longitude0 + (x * target.DeltaLongitude); // Work out Long. of this cell.
var fVal = result.GetValueAt(lat, lon, result.NoValueMarker);
if (fVal == result.NoValueMarker)
{
target.SetCellValue(x, y, target.NoValueMarker);
}
else
{
if (fVal > CutOff)
{
var currentVal = target.GetCellValue(x, y);
target.SetCellValue(x, y, currentVal + 1);
}
}
}
}
}
return(target);
}
private UnityContainer GetLocalContainer(SearchConnection searchConnection, string connectionString)
{
var container = new UnityContainer();
container.RegisterType<IKnownSerializationTypes, CatalogEntityFactory>("catalog", new ContainerControlledLifetimeManager());
container.RegisterInstance<IConsumerFactory>(new DomainAssemblyScannerConsumerFactory(container));
container.RegisterType<IKnownSerializationTypes, DomainAssemblyScannerConsumerFactory>("scaned", new ContainerControlledLifetimeManager(), new InjectionConstructor(container));
container.RegisterType<IConsumerFactory, DomainAssemblyScannerConsumerFactory>();
container.RegisterType<IEngineProcess, SingleThreadConsumingProcess>();
container.RegisterType<IMessageSerializer, DataContractMessageSerializer>();
container.RegisterType<IQueueWriter, InMemoryQueueWriter>();
container.RegisterType<IQueueReader, InMemoryQueueReader>();
container.RegisterType<IMessageSender, DefaultMessageSender>(new ContainerControlledLifetimeManager());
container.RegisterType<ICatalogEntityFactory, CatalogEntityFactory>(new ContainerControlledLifetimeManager());
container.RegisterType<IReviewEntityFactory, ReviewEntityFactory>(new ContainerControlledLifetimeManager());
container.RegisterType<ICatalogService, CatalogService>();
container.RegisterType<ISearchIndexBuilder, CatalogItemIndexBuilder>("catalogitem");
container.RegisterType<ILogOperationFactory, LogOperationFactory>();
container.RegisterType<ISearchEntityFactory, SearchEntityFactory>(new ContainerControlledLifetimeManager());
container.RegisterType<ISearchIndexController, SearchIndexController>();
container.RegisterType<ICacheRepository, HttpCacheRepository>();
if (string.Equals(searchConnection.Provider, SearchProviders.Lucene.ToString(), StringComparison.OrdinalIgnoreCase))
{
// Lucene Search implementation
container.RegisterType<ISearchProvider, LuceneSearchProvider>();
container.RegisterType<ISearchQueryBuilder, LuceneSearchQueryBuilder>();
}
else
{
container.RegisterType<ISearchProvider, ElasticSearchProvider>();
container.RegisterType<ISearchQueryBuilder, ElasticSearchQueryBuilder>();
}
// register instances here
container.RegisterInstance<ISearchConnection>(searchConnection);
var catalogRepository = new EFCatalogRepository(connectionString);
container.RegisterInstance<ICatalogRepository>(catalogRepository);
container.RegisterType<ICatalogOutlineBuilder, CatalogOutlineBuilder>();
container.RegisterInstance<IPricelistRepository>(catalogRepository);
container.RegisterInstance<IOperationLogRepository>(new OperationLogContext(connectionString));
container.RegisterInstance<IBuildSettingsRepository>(new EFSearchRepository(connectionString));
var reviewRepository = new EFReviewRepository(connectionString);
container.RegisterInstance<IReviewRepository>(reviewRepository);
var indexingProgress = new ProgressRecord(1, "Indexing Progress", "Progress:");
var observer = new ProgressObserver(this, indexingProgress);
container.RegisterInstance<ISystemObserver>(observer);
return container;
}
protected override void RunModelImpl(GridLayer targetLayer, IEnumerable <GridLayer> layers, ModelPointSet points)
{
double fVal, fDestNoVal;
bool bTestFailed;
// Work out ranges for the varying percentile bands across all layers...
if (layers.Count() <= 0)
{
return;
}
List <EnvironmentalLayerRange[]> Range = new List <EnvironmentalLayerRange[]>();
foreach (GridLayer layer in layers)
{
var array = new EnvironmentalLayerRange[4];
array[0] = layer.GetRangeForPoints(points.Points, 0.0);
array[1] = layer.GetRangeForPoints(points.Points, 0.05);
array[2] = layer.GetRangeForPoints(points.Points, 0.1);
array[3] = layer.GetRangeForPoints(points.Points, 0.25);
Range.Add(array);
}
// For each cell for each layer...
var firstLayer = layers.ElementAt(0);
fDestNoVal = firstLayer.NoValueMarker;
targetLayer.SetAllCells(fDestNoVal);
for (int y = 0; y < firstLayer.Height; ++y)
{
for (int x = 0; x < firstLayer.Width; ++x)
{
// First test %0 - %100
bTestFailed = false;
for (int i = 0; i < layers.Count(); ++i)
{
var layer = layers.ElementAt(i);
fVal = layer.GetCellValue(x, y);
if (fVal == layer.NoValueMarker)
{
bTestFailed = true;
break;
}
else
{
if ((fVal < Range[i][0].Min) || (fVal > Range[i][0].Max)) // %0-%100
{
bTestFailed = true;
targetLayer.SetCellValue(x, y, fDestNoVal);
break;
}
}
}
if (!bTestFailed)
{
targetLayer.SetCellValue(x, y, 1);
// Second test %5 - %95
for (int i = 0; i < layers.Count(); ++i)
{
var layer = layers.ElementAt(i);
fVal = layer.GetCellValue(x, y);
if ((fVal < Range[i][1].Min) || (fVal > Range[i][1].Max)) // %5-%95
{
bTestFailed = true;
break;
}
}
if (!bTestFailed)
{
targetLayer.SetCellValue(x, y, 2);
for (int i = 0; i < layers.Count(); ++i)
{
var layer = layers.ElementAt(i);
fVal = layer.GetCellValue(x, y);
if ((fVal < Range[i][2].Min) || (fVal > Range[i][2].Max)) // %10-%90
{
bTestFailed = true;
break;
}
}
if (!bTestFailed)
{
targetLayer.SetCellValue(x, y, 3);
for (int i = 0; i < layers.Count(); ++i)
{
var layer = layers.ElementAt(i);
fVal = layer.GetCellValue(x, y);
if ((fVal < Range[i][3].Min) || (fVal > Range[i][3].Max)) // %25-%75
{
bTestFailed = true;
break;
}
}
if (!bTestFailed)
{
targetLayer.SetCellValue(x, y, 4);
}
}
}
}
}
if ((y % 20) == 0)
{
int percent = (int)(((float)y / (float)targetLayer.Height) * (float)100);
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage("Running BOXCAR Model...", percent);
}
if (IsCancelled)
{
return;
}
}
}
if (ProgressObserver != null)
{
ProgressObserver.ProgressMessage("Running BOXCAR Model...", 100);
}
}
public void TestScopeWithSpanAndInitProgress()
{
List<double> progress = new List<double>();
ProgressObserver progressObserver = new ProgressObserver(s => progress.Add(s.Progress));
const int steps = 3;
using (ProgressReportScope scope = new ProgressReportScope(steps, 0.3, 0.65))
{
scope.Subscribe(progressObserver);
for ( int i = 0; i < steps; i++) scope.Increase();
}
ProgressAssert.AreEqual(new[] { 0.75, 0.85, 0.95 }, progress);
}
public void TestScopeWithSteps(int stepsCount, int stepsPassed, double[] expectedProgress)
{
List<double> progress = new List<double>();
ProgressObserver progressObserver = new ProgressObserver(s => progress.Add(s.Progress));
using (ProgressReportScope scope = new ProgressReportScope(stepsCount))
{
scope.Subscribe(progressObserver);
for (int i = 0; i < stepsPassed; i++)
{
scope.Increase();
}
}
ProgressAssert.AreEqual(expectedProgress, progress);
}
public Task<WorkflowRenderResult> BenchmarkAsync(int threadsCount, ProgressObserver progressObserver)
{
FormulaRenderArguments = FormulaRenderArguments.FromString(
@"-8.52,0.9;0.65,10.42;-7.37,-0.31;-0.89,2.79;0.31,1.9;0.52,6.01;2.29,8.68
-1.93,-2.17,-0.59,0.21;-0.94,-2.78,0.06,0.12;3.9,3.25,-2.59,0.04
Sub Sqrt Sqrt Cos Sub Sub Sub Sum Cos Atan Ln Cos Sub x5 x0 Cos Atan Pow3 Cbrt Sum x5 x5 Sin Cbrt Cbrt Cos Sqrt Mul x5 x0 Cbrt Sub Mul Sub Mul Mul Sum x3 x5 Sum x4 x6 Sum Sub x1 x0 Sin x3 Sub Cbrt Sub x2 x3 Sum Sum x3 x2 Sub x1 x0 Cbrt Mul Sub Cbrt x6 Sub x2 x2 Sub Cbrt x6 Mul x3 x1 Sub Cbrt Sub Sub Sub x3 x2 Sub x4 x0 Atan Pow3 x6 Max Cos Cbrt Mul x6 x1 Sum Cbrt Mul x4 x3 Atan Ln x3 Sub Sub Sin Sum Mul Sum Atan Ln x5 Mul Sum x1 x0 Sin x4 Cbrt Sub Cos x1 Sum x3 x3 Mul Sin Max Mul x2 x0 Sin x0 Sub Sqrt Sum x2 x5 Cbrt Sub x2 x1 Sub Cbrt Sub Sin Sub Cbrt x4 Sub x6 x3 Sub Cbrt Sub x2 x0 Sub Cos x0 Sum x0 x2 Cos Sum Mul Sqrt Sub x6 x0 Sqrt Cos x5 Sub Sqrt Cos x3 Max Cos x1 Mul x2 x2 Sum Sum Cbrt Sub Cos Cbrt Sub x1 x5 Sub Atan Atan Ln x2 Sub Sub x6 x2 Sum x6 x4 Max Sub Sum Sub Sub x1 x6 Sub x5 x2 Cbrt Sub x3 x1 Sum Sum Cos x0 Sub x2 x2 Cos Cos x4 Sin Sqrt Cos Cos x6 Atan Sub Sqrt Sin Sub Cos x1 Sum x6 x0 Sub Sub Cbrt Cos x2 Sum Sub x1 x4 Cos x2 Sum Mul Sum x2 x1 Sum x2 x0 Sub Sum x1 x4 Sum x2 x5 Sub Cbrt Sub Sum Sin Cos Sub Sub Sqrt Max Max Sub x3 x4 Sum x0 x0 Sum Atan Ln x5 Atan Pow3 x4 Mul Sub Sqrt Atan Ln x5 Sub Cbrt x2 Sub x3 x4 Sub Sub Sub x3 x6 Sub x1 x6 Sub Sub x1 x4 Sin x3 Max Cbrt Sqrt Cos Sub x3 x5 Sum Sub Cbrt Sub x4 x1 Sum Cos x6 Sin x5 Sub Atan Atan Pow3 x4 Cbrt Sum x5 x3 Atan Ln Sum Sin Cbrt Cos Cos Sum x4 x3 Cbrt Atan Pow3 Sqrt Sub x4 x2 Cbrt Sub Sum Sub 8.3 Atan Pow3 Sqrt Sub Sum x3 x2 Cos x3 Sum Cos Cbrt Sin Atan Cos x4 Cbrt Sum Cos Sqrt Cos x6 Sub Sub Sum x5 x2 Sum x4 x5 Sum Sub x5 x4 Cbrt x6 Sub Cbrt Cos Sub Sub Cos Sub x6 x0 Sin Cos x0 Sum Mul Sum x0 x4 Cos x6 Sqrt Mul x6 x3 Sub Cbrt Sum Sum Max Sub x6 x6 Cos x1 Sin Mul x6 x4 Sub Sum Sub x4 x5 Sqrt x6 Cos Sum x4 x5 Sin Cbrt Sum Atan Ln x1 Sqrt Sub x3 x4 Sub Cbrt Sqrt Sum Mul Sum Sum Atan Ln Cbrt Cos x3 Max Sum Sub Sum x6 x1 Mul x3 x4 Cbrt Sum x2 x6 Atan Pow3 Mul x4 x2 Mul Sub Sub Cos Sum x4 x2 Sub Cos x4 Sub x0 x3 Cbrt Sqrt Sum x0 x0 Sub Cos Sum Sum x3 x3 Atan Ln x6 Sub Cbrt Sub x1 x1 Sum Sum x3 x2 Cbrt x4 Cbrt Atan Sqrt Mul Cos Sub x3 x6 Sub Sub x1 x5 Sqrt x2 Atan Mul Sum Cos Cbrt Sub Sqrt x4 Atan Ln x4 Sub Mul Sqrt Sub x5 x4 Max Mul x2 x3 Sum x5 x4 Sum Sub Sub x6 x4 Cos x6 Sum Max x5 x6 Sub x3 x1 Cbrt Sub Mul Sub Sqrt x3 Sum x6 x4 Atan Ln x5 Sum Sum Sin x5 Sum x5 x1 Cos Sqrt x6 Max Sum Sin Sub Cos Atan Ln Cbrt Sub Sqrt x2 Cos x2 Sum Sum Sum Atan Ln Mul x1 x0 Sub Sum Atan Ln x3 Cbrt x6 Cbrt Cos x3 Sum Cos Cbrt Sum x6 x0 Sum Cos Sub x4 x1 Sub Sub x6 x5 Cbrt x5 Sqrt Atan Ln Sub Sub x4 x4 Max x5 x5 Sum Sqrt Cbrt Cos Sub Sub Atan Pow3 x4 Sin Cbrt x6 Sub Cos Cbrt x1 Cbrt Sub x6 x0 Sqrt Sub Sum Cbrt Max Sqrt Mul x4 x4 Cbrt Cbrt x1 Sum Sub Cos Sqrt x6 Cbrt Cbrt x6 Sub Mul Sqrt x6 Sub x3 x0 Sum Sub x2 x2 Sub x5 x0 Sqrt Cbrt Sum Sub Sum x5 x1 Max x1 x0 Sin Cos x4 Sum Sub Sum Sum Sin Sum Sub Atan Pow3 x4 Sum Mul x2 x5 Sqrt x1 Sin Sqrt Cos x5 Cbrt Mul Sub Cbrt Cos x4 Mul Sub x6 x1 Sqrt x3 Mul Atan Ln x2 Atan Sub x6 x6 Cos Sin Cos Sum Sub Sub x5 x3 Sum x6 x6 Cbrt Sum x0 x6 Cos Sub Sin Sub Sqrt Sub Sub x4 x3 Sqrt x6 Sub Cos Atan Pow3 x5 Sqrt Cos x4 Sub Sqrt Sub Atan Pow3 x1 Cbrt Sub x4 x6 Sub Sub Sub Sub x0 x6 Atan Ln x0 Sqrt Sqrt x1 Sum Sub Sqrt x5 Sub x6 x1 Cos Atan Ln x4 Cbrt Cbrt Sqrt Sum Sin Sub Sub Atan Pow3 x6 Atan Pow3 x4 Sum Sum x4 x4 Mul x4 x3 Sub Sin Mul Sub x2 x6 Atan Ln x4 Sum Sub Sin x1 Atan Pow3 x6 Sub Atan Ln x4 Sub x2 x6");
return RenderFormulaAsync(false, threadsCount, progressObserver);
}
private void CreateTestSubject(ProgressControllerViewModel state = null)
{
this.testSubject = new ProgressObserver(this.testServiceProvider, this.testVisualizer, this.progressEvents, state);
this.VerifyNonDisposedAndRegistered();
}
public Task<WorkflowRenderResult> RenderFormulaAsync(bool generateNew, int threadsCount, ProgressObserver progressObserver)
{
if (FormulaRenderArguments == null && !generateNew)
throw new InvalidOperationException("FormulaRenderArguments is null.");
return Task.Run(() =>
{
if (progressObserver != null)
ProgressReporter.Subscribe(progressObserver);
return RenderFormula(generateNew, threadsCount);
});
}
private async Task DrawImageAsync(bool generateNew, bool benchmark)
{
int coresCount = Java.Lang.Runtime.GetRuntime().AvailableProcessors();
_coresCountTextView.Text = "available cpu cores: " + coresCount.ToInvariantString();
ProgressDialog progressDialog = CreateProgressDialog(
benchmark ? Resources.GetString(Resource.String.Benchmark) : Resources.GetString(Resource.String.WallpaperWillBeReady),
benchmark ? "" : Resources.GetString(Resource.String.Wait), false);
progressDialog.Max = 100;
progressDialog.Show();
ProgressObserver renderingProgressObserver = new ProgressObserver(
p => RunOnUiThread(() =>
{
progressDialog.Progress = (int) (p.Progress*progressDialog.Max);
}), TimeSpan.FromMilliseconds(100),
() => progressDialog.Progress = progressDialog.Max);
WorkflowRenderResult result = benchmark
? await _workflow.BenchmarkAsync(coresCount, renderingProgressObserver)
: await _workflow.RenderFormulaAsync(generateNew, coresCount, renderingProgressObserver);
result.Bitmap.Update(result.FormulaRenderResult);
_renderTimeTextView.Text = "rendering time: " + result.ElapsedTime;
_imageView.SetImageBitmap((Bitmap)result.Bitmap.PlatformBitmap);
_horizontalScrollView.ScrollTo(_horizontalScrollView.Width / 2, 0);
progressDialog.Dismiss();
if (benchmark)
{
AlertDialog dialog = CreateAlertDialog(result.ElapsedTime.ToString("hh':'mm':'ss"));
dialog.Show();
}
}
