private Alphabet AlphabetCapture()
{
Speak("Alphabet Capture ready, every letter you enter from now will be added to your custom alphabet. " +
"Press Enter/Escape to end Capture. Remember that word character order is important. Repeats will be ignored");
var alpha = new Alphabet();
while (true)
{
var character = Console.ReadKey(true);
if (character.Key == ConsoleKey.Enter || character.Key == ConsoleKey.Escape)
{
break;
}
var added = alpha.Add(character.KeyChar);
if (added)
{
Console.Write(character.KeyChar);
}
}
Console.WriteLine();
Speak($"Alphabet Capture ended with {alpha.Count} characters.");
return(alpha);
}
/// <summary>
/// Loads sequence by id from db and converts it to <see cref="Chain"/>.
/// </summary>
/// <param name="sequenceId">
/// The sequence id.
/// </param>
/// <returns>
/// The sequence as <see cref="Chain"/>.
/// </returns>
public Chain GetLibiadaChain(long sequenceId)
{
if (Db.CommonSequence.Any(s => s.Id == sequenceId))
{
var matter = Db.CommonSequence.Include(s => s.Matter).Single(s => s.Id == sequenceId).Matter;
return(new Chain(Db.GetSequenceBuilding(sequenceId), GetAlphabet(sequenceId), sequenceId));
}
// if it is not "real" sequence , then it must be image "sequence"
var imageSequence = Db.ImageSequences.Include(s => s.Matter).Single(s => s.Id == sequenceId);
if (imageSequence.Matter.Nature != Nature.Image)
{
throw new Exception("Cannot find sequence to return");
}
var image = Image.Load(imageSequence.Matter.Source);
var orderExtractor = imageSequence.OrderExtractor.GetAttribute <ImageOrderExtractor, ImageOrderExtractorAttribute>().Value;
var sequence = ImageProcessor.ProcessImage(image, new IImageTransformer[0], new IMatrixTransformer[0], (IImageOrderExtractor)Activator.CreateInstance(orderExtractor));
var alphabet = new Alphabet {
NullValue.Instance()
};
var incompleteAlphabet = sequence.Alphabet;
for (int j = 0; j < incompleteAlphabet.Cardinality; j++)
{
alphabet.Add(incompleteAlphabet[j]);
}
return(new Chain(sequence.Building, alphabet));
}
/// <summary>
/// Manually adds a letter to the set of recognizable letters.
/// </summary>
/// <param name="letter">Letter to recognize.</param>
public void AddLetter(A letter)
{
if (Alphabet.Contains(letter))
{
return;
}
Alphabet.Add(letter);
}
public void Add_ExistsSymbols_NotExtendAlphabet()
{
//arrange
var alphabet = new Alphabet("a");
//act
alphabet.Add("aaaaa");
//assert
Assert.AreEqual(0, alphabet.LowerCase.Except("a").Count());
}
public void Add_NewSymbols_ExtendAlphabet()
{
//arrange
var alphabet = new Alphabet("a");
//act
alphabet.Add("bc");
//assert
Assert.AreEqual(0, "abc".Except(alphabet.LowerCase).Count());
}
private static Alphabet GetAlphabet(IEnumerable <HtmlNode> nodes)
{
var alphabet = new Alphabet();
foreach (var node in nodes)
{
var child = node.ChildNodes.First();
alphabet.Add(new Letter(
child.InnerText,
"http://apteka.103.by" + child.Attributes["href"].Value
));
}
return(alphabet);
}
/// <summary>
/// The to libiada alphabet.
/// </summary>
/// <param name="elementIds">
/// The element ids.
/// </param>
/// <returns>
/// The <see cref="Alphabet"/>.
/// </returns>
public Alphabet ToLibiadaAlphabet(long[] elementIds)
{
var alphabet = new Alphabet {
NullValue.Instance()
};
List <Element> elements = GetElements(elementIds);
foreach (long elementId in elementIds)
{
Element el = elements.Single(e => e.Id == elementId);
alphabet.Add(new ValueString(el.Value));
}
return(alphabet);
}
/// <summary>
/// The check recovery available.
/// </summary>
/// <param name="chain">
/// Source sequence.
/// </param>
/// <param name="length">
/// Length of L-gram.
/// </param>
/// <returns>
/// true if chain is recoverable form L-grams.
/// </returns>
private bool CheckRecoveryAvailable(AbstractChain chain, int length)
{
var iterator = new IteratorStart(chain, length, 1);
var alphabet = new Alphabet();
while (iterator.Next())
{
if (alphabet.Contains(iterator.Current()))
{
return false;
}
alphabet.Add(iterator.Current());
}
return true;
}
/// <summary>
/// Adiciona transição entre 2 estados.
/// </summary>
/// <param name="estadoOrigem">O estado origem do autômato.</param>
/// <param name="consumirFita">O símbolo a ser avaliado.</param>
/// <param name="estadoDestino">O estado destino.</param>
public void AdicionarTransicao(string estadoOrigem, string estadoDestino, Symbol consumirPilha,
Symbol consumirFita, params Symbol[] gravarPilha)
{
if (consumirPilha == null)
{
consumirPilha = Symbol.EmptySymbol;
}
SymbolList vars = new SymbolList();
if (gravarPilha == null || gravarPilha.Length == 0)
{
vars.Add(Symbol.EmptySymbol);
}
else
{
vars.AddRange(gravarPilha);
}
foreach (var symbol in vars)
{
if (StackAlphabet.IndexOf(symbol) < 0 && symbol != Symbol.EmptySymbol && symbol != Symbol.StackFinal && symbol != Symbol.TapeFinal)
{
StackAlphabet.Add(symbol);
}
}
// Adiciona transições..
if (States.ContainsKey(estadoOrigem) && States.ContainsKey(estadoDestino))
{
if (!Alphabet.Contains(consumirFita))
{
Alphabet.Add(consumirFita);
}
States[estadoOrigem].AdicionarTransicao(States[estadoDestino], consumirFita, consumirPilha, vars);
}
}
public ActionResult Index(short[] characteristicLinkIds, string[] customSequences, bool localFile, string fileType, bool toLower, bool removePunctuation)
{
return(CreateTask(() =>
{
int sequencesCount = localFile ? Request.Files.Count : customSequences.Length;
var sequencesNames = new string[sequencesCount];
var sequences = new Chain[sequencesCount];
if (localFile)
{
for (int i = 0; i < sequencesCount; i++)
{
Stream sequenceStream = FileHelper.GetFileStream(Request.Files[i]);
sequencesNames[i] = Request.Files[i].FileName;
switch (fileType)
{
case "text":
using (var sr = new StreamReader(sequenceStream))
{
string stringTextSequence = sr.ReadToEnd();
if (toLower)
{
stringTextSequence = stringTextSequence.ToLower();
}
if (removePunctuation)
{
stringTextSequence = Regex.Replace(stringTextSequence, @"[^\w\s]", "");
}
sequences[i] = new Chain(stringTextSequence);
}
break;
case "image":
var image = Image.Load(sequenceStream);
var sequence = ImageProcessor.ProcessImage(image, new IImageTransformer[0], new IMatrixTransformer[0], new LineOrderExtractor());
var alphabet = new Alphabet {
NullValue.Instance()
};
var incompleteAlphabet = sequence.Alphabet;
for (int j = 0; j < incompleteAlphabet.Cardinality; j++)
{
alphabet.Add(incompleteAlphabet[j]);
}
sequences[i] = new Chain(sequence.Building, alphabet);
break;
case "genetic":
ISequence fastaSequence = NcbiHelper.GetFastaSequence(sequenceStream);
var stringSequence = fastaSequence.ConvertToString();
sequences[i] = new Chain(stringSequence);
sequencesNames[i] = fastaSequence.ID;
break;
case "wavFile":
var reader = new BinaryReader(Request.Files[i].InputStream);
int chunkID = reader.ReadInt32();
int fileSize = reader.ReadInt32();
int riffType = reader.ReadInt32();
int fmtID = reader.ReadInt32();
int fmtSize = reader.ReadInt32();
int fmtCode = reader.ReadInt16();
int channels = reader.ReadInt16();
int sampleRate = reader.ReadInt32();
int fmtAvgBPS = reader.ReadInt32();
int fmtBlockAlign = reader.ReadInt16();
int bitDepth = reader.ReadInt16();
if (fmtSize == 18)
{
// Read any extra values
int fmtExtraSize = reader.ReadInt16();
reader.ReadBytes(fmtExtraSize);
}
int dataID = reader.ReadInt32();
int dataSize = reader.ReadInt32();
byte[] byteArray = reader.ReadBytes(dataSize);
var shortArray = new short[byteArray.Length / 2];
Buffer.BlockCopy(byteArray, 0, shortArray, 0, byteArray.Length);
//shortArray = Amplitude(shortArray, 20);
shortArray = Sampling(shortArray, 50);
//shortArray = shortArray.Select(s => (short)(s / 10)).ToArray();
sequences[i] = new Chain(shortArray);
break;
default:
throw new ArgumentException("Unknown file type", nameof(fileType));
}
}
}
else
{
for (int i = 0; i < sequencesCount; i++)
{
sequences[i] = new Chain(customSequences[i]);
sequencesNames[i] = $"Custom sequence {i + 1}. Length: {customSequences[i].Length}";
}
}
var sequencesCharacteristics = new SequenceCharacteristics[sequences.Length];
for (int j = 0; j < sequences.Length; j++)
{
var characteristics = new double[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkIds[k]);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkIds[k]);
IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
characteristics[k] = calculator.Calculate(sequences[j], link);
}
sequencesCharacteristics[j] = new SequenceCharacteristics
{
MatterName = sequencesNames[j],
Characteristics = characteristics
};
}
var characteristicNames = new string[characteristicLinkIds.Length];
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k]);
characteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = characteristicNames[k],
Selected = false
};
}
var result = new Dictionary <string, object>
{
{ "characteristics", sequencesCharacteristics },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
/// <summary>
/// The to libiada alphabet.
/// </summary>
/// <param name="elementIds">
/// The element ids.
/// </param>
/// <returns>
/// The <see cref="Alphabet"/>.
/// </returns>
public Alphabet ToLibiadaAlphabet(List<long> elementIds)
{
var alphabet = new Alphabet { NullValue.Instance() };
foreach (long elementId in elementIds)
{
Element el = db.Element.Single(e => e.Id == elementId);
alphabet.Add(new ValueString(el.Value));
}
return alphabet;
}
/// <summary>
/// (Overridable) Accepts an unassigned Puzzle and returns it created and populated with required values.
/// </summary>
/// <param name="Puzzle"></param>
public virtual void InitializePuzzle(out Puzzle Puzzle)
{
List<string> puzzleRows = GetPuzzleContent();
int[] cellValues = new int[puzzleRows[0].Length * puzzleRows.Count];
Alphabet puzzleAlphabet = new Alphabet();
ExtractMetadata(puzzleRows);
// Assumption: All values in the puzzle's alphabet can be found among the pre-filled cells it contains.
for (int rowIndex = 0; rowIndex < puzzleRows.Count; rowIndex++)
{
for (int columnIndex = 0; columnIndex < puzzleRows[rowIndex].Length; columnIndex++)
{
string cellValue = puzzleRows[rowIndex].Substring(columnIndex, 1);
if (cellValue != _EmptyCellDesignator && !puzzleAlphabet.Contains(int.Parse(cellValue)))
{
puzzleAlphabet.Add(int.Parse(cellValue));
}
cellValues[rowIndex * puzzleRows.Count + columnIndex] = cellValue == _EmptyCellDesignator ? _EmptyCellValue : int.Parse(cellValue);
}
}
Puzzle = new Puzzle(puzzleRows[0].Length, puzzleRows.Count, this.BoxWidth, this.BoxHeight, puzzleAlphabet);
for (int cellIndex = 0; cellIndex < Puzzle.Cells.Count; cellIndex++)
{
Puzzle.Cells[cellIndex].Value = cellValues[cellIndex];
if (Puzzle.Cells[cellIndex].Value != _EmptyCellValue)
{
Puzzle.Cells[cellIndex].SetAsSolved();
}
}
if (Puzzle.SolveCount == 0)
{
Puzzle.ErrorMessage = "Error: The puzzle has no starting values in it.";
}
else
{
Puzzle.ErrorMessage = null;
}
}
