/// <summary>
/// Create a system given the system view. This is used to restore the System for each Session
/// </summary>
/// <param name="systemView"></param>
public System(SystemView systemView)
{
World = new World(systemView.Map);
Dictionary <Camera, double> camerasOrientation = new Dictionary <Camera, double>();
foreach (CameraProperties cameraProp in systemView.Cameras)
{
//Correct the offset due to the addition of the walls in the system view
Camera camera = new AngularCamera(cameraProp.X - 1, cameraProp.Y - 1);
World.AddCamera(camera);
camerasOrientation[camera] = cameraProp.Orientation;
}
// To remove if possible
World.InitializeCameras();
_model = new MarkovModel(World);
TrueState = new State(systemView.TrueState[0] - 1, systemView.TrueState[1] - 1, camerasOrientation);
Distribution <State> d = new Distribution <State>();
// Ignore the first and last row/column to account for the offset caused by the outside walls
for (int i = 1; i < systemView.Probabilities.Length - 1; i++)
{
for (int j = 1; j < systemView.Probabilities[i].Length - 1; j++)
{
if (systemView.Probabilities[i][j] > 0)
{
d.SetProba(new State(i - 1, j - 1, camerasOrientation), systemView.Probabilities[i][j]);
}
}
}
CurrentDistribution = d;
}
public System(World world, State initialState)
{
TrueState = initialState;
World = world;
_model = new MarkovModel(World);
InitializeSystem();
}
public MarkovModel MakeFromText(string inputText)
{
var model = new MarkovModel();
var preparedText = _textPreparator.Prepare(inputText);
var inputWordSentence = _textSplitter.SplitBySentence(preparedText);
var inputWordChains = inputWordSentence.Select(x => _textSplitter.SplitSentenceByWords(x));
model.Words = inputWordChains.SelectMany(x =>
{
return(x.Select(y => y));
}).Distinct(new StringEqualityComparer()).Select(x => new Word {
Value = x
}).ToArray();
var links = new List <WordLink>();
foreach (var chain in inputWordChains)
{
var from = chain[0];
var wordFrom = model.Words.Single(x => x.Value.Equals(from));
wordFrom.IsStart = true;
for (var i = 1; i < chain.Length; i++)
{
var to = chain[i];
var wordTo = model.Words.Single(x => x.Value.Equals(to));
//skip давайте - давайте
if (wordFrom != wordTo)
{
var link = links.SingleOrDefault(x => x.FromWord == wordFrom && x.ToWord == wordTo);
if (link == null)
{
link = new WordLink {
FromWord = wordFrom, ToWord = wordTo
};
links.Add(link);
}
link.Weight = link.Weight + 1;
from = to;
wordFrom = wordTo;
}
}
}
model.WordLinks = links;
model.StartWords = model.Words.Where(x => x.IsStart).ToArray();
return(model);
}
public void PhraseGeneratorTest()
{
var one = new Word {
Value = "one", IsStart = true
};
var two = new Word {
Value = "two", IsStart = false
};
var three = new Word {
Value = "three", IsStart = true
};
var four = new Word {
Value = "four", IsStart = false
};
var model = new MarkovModel
{
Words = new Word[]
{
one,
two,
three,
four
},
StartWords = new Word[]
{
one,
three
},
WordLinks = new WordLink[]
{
new WordLink {
FromWord = one, ToWord = two, Weight = 100
},
new WordLink {
FromWord = three, ToWord = four, Weight = 100
},
new WordLink {
FromWord = two, ToWord = three, Weight = 10
},
}
};
var generator = new MarkovPhraseGenerator(model, true);
for (var index = 0; index < 100; index++)
{
var phrase = generator.GetPhrase();
Assert.IsTrue(phrase.StartsWith("One two three") ||
phrase.StartsWith("Three four"));
}
}
public async Task <IActionResult> OnPostAsync()
{
MarkovModel = await MarkovModels.FindAsync(Id);
if (MarkovModel == null)
{
return(NotFound());
}
await DeleteHelper.Delete(MarkovModel);
return(RedirectToPage("/Analysis/Markov/Index", new { Id = MarkovModel.AssignmentId }));
}
public async Task <IActionResult> OnGetAsync()
{
MarkovModel = await MarkovModels.FindAsync(Id);
if (MarkovModel == null)
{
return(NotFound());
}
Context.Entry(MarkovModel).Reference(x => x.Assignment)
.Query().Load();
return(Page());
}
public async Task Generate(IList <Snapshot> snapshots, MarkovModelOptions options, DirectoryHandler handler, DevAssignment assignment)
{
var markovModel = new MarkovModel()
{
Assignment = assignment,
Finished = false,
};
await MarkovModelRepository.Add(markovModel);
var distanceMatrix = DistanceMatrix(snapshots, options, handler, assignment);
markovModel.States = MarkovModelCreator.Create(snapshots, distanceMatrix, options.NumberOfStates);
markovModel.Finished = true;
await MarkovModelRepository.Update(markovModel);
}
public async Task Delete(MarkovModel markovModel)
{
Context.Entry(markovModel).Collection(x => x.States).Query()
.Include(x => x.Snapshots)
.Include(x => x.Transitions).Load();
foreach (var state in markovModel.States)
{
foreach (var transition in state.Transitions)
{
Context.Remove(transition);
}
foreach (var snapshot in state.Snapshots)
{
Context.Remove(snapshot);
}
Context.Remove(state);
}
Context.Remove(markovModel);
await Context.SaveChangesAsync();
}
public MarkovPhraseGenerator(MarkovModel model, bool nextWordByDistribution)
{
_model = model;
_nextWordByDistribution = nextWordByDistribution;
}
