public bool AddReverse(Difference difference, int startIndex) { if (startIndex == difference.Length) { if (EndOfWord) { return(false); } EndOfWord = true; return(true); } DifferenceNode child; char c = difference.CharAtFromEnd(startIndex); if (!Children.TryGetValue(c, out child)) { child = new DifferenceNode(); Children.Add(c, child); } var result = child.Add(difference, startIndex + 1); return(result); }
public void TestDifferenceNode() { Size testSize = new Size(5, 5); Frame inputA = new Frame(testSize); Frame inputB = new Frame(testSize); Frame black = new Frame(testSize); for (int x = 0; x < testSize.Width; x++) { for (int y = 0; y < testSize.Height; y++) { inputA[x, y] = new Rgb((byte)(x + y), (byte)(x + y), (byte)(x + y)); inputB[x, y] = new Rgb((byte)(x * y), (byte)(x * y), (byte)(x * y)); } } DifferenceNode diffNode = new DifferenceNode(); Frame[] diffReal = { inputA, inputB }; Frame[] diffSelf = { inputA, inputA }; Frame[] resultReal = diffNode.Process(diffReal, 0); Frame[] resultSelf = diffNode.Process(diffSelf, 0); for (int x = 0; x < testSize.Width; x++) { for (int y = 0; y < testSize.Height; y++) { Assert.Equal(127, resultSelf[0][x, y].R); Assert.Equal(127, resultSelf[0][x, y].G); Assert.Equal(127, resultSelf[0][x, y].B); Assert.Equal(127 + (((int)inputA[x, y].R - inputB[x, y].R) / 2), resultReal[0][x, y].R); Assert.Equal(127 + (((int)inputA[x, y].G - inputB[x, y].G) / 2), resultReal[0][x, y].G); Assert.Equal(127 + (((int)inputA[x, y].B - inputB[x, y].B) / 2), resultReal[0][x, y].B); } } }
/// <summary> /// Validates the Sequences for all the general test cases. /// </summary> /// <param name="node">Xml Node Name</param> /// <param name="additionalParameter"> /// Additional Parameter based /// on which the validations are done. /// </param> private void ValidateComputeFeature(string node, AssemblyParameters additionalParameter) { // Get the parameters from Xml string firstSequence = utilityObj.xmlUtil.GetTextValue(node, Constants.SequenceNode1); string secondSequence = utilityObj.xmlUtil.GetTextValue(node, Constants.SequenceNode2); string kmerLength = utilityObj.xmlUtil.GetTextValue(node, Constants.KmerLengthNode); string expectedFeatureCount = utilityObj.xmlUtil.GetTextValue(node, Constants.FeatureCount); string expectedFeature = utilityObj.xmlUtil.GetTextValue(node, Constants.FeatureName); string expectedFeatureType = utilityObj.xmlUtil.GetTextValue(node, Constants.FeatureType); string expectedStartIndex = utilityObj.xmlUtil.GetTextValue(node, Constants.StartIndexNode); string expectedEndIndex = utilityObj.xmlUtil.GetTextValue(node, Constants.EndIndexNode); ISequence seq1 = null; ISequence seq2 = null; // Create Sequences. switch (additionalParameter) { case AssemblyParameters.Assemble: var seqObj1 = new Sequence(Alphabets.Protein, firstSequence); var seqObj2 = new Sequence(Alphabets.Protein, secondSequence); seq1 = seqObj1; seq2 = seqObj2; break; case AssemblyParameters.Consensus: seq1 = new Sequence(Alphabets.DNA, firstSequence); seq2 = new Sequence(Alphabets.DNA, secondSequence); break; } var kmerBuilder = new SequenceToKmerBuilder(); KmersOfSequence kmerList = kmerBuilder.Build(seq1, int.Parse(kmerLength, null)); List <WordMatch> nodes = WordMatch.BuildMatchTable( kmerList, seq2, int.Parse(kmerLength, null)); List <WordMatch> matchList = WordMatch.GetMinimalList(nodes, int.Parse(kmerLength, null)); List <DifferenceNode> diffNode = DifferenceNode.BuildDiffList(matchList, seq1, seq2); List <DifferenceNode.CompareFeature> features = DifferenceNode.OutputDiffList(diffNode, seq1, seq2); // Validate difference. Assert.AreEqual(expectedFeatureCount, features.Count.ToString((IFormatProvider)null)); Assert.AreEqual(expectedFeature, features[0].Feature); Assert.AreEqual(expectedFeatureType, features[0].FeatureType); Assert.AreEqual(expectedStartIndex, features[0].Start.ToString((IFormatProvider)null)); Assert.AreEqual(expectedEndIndex, features[0].End.ToString((IFormatProvider)null)); ApplicationLog.WriteLine(string.Format(null, "Kmer P1 : Validated DifferenceNodes successfully.")); }
public void ValidateDifferenceNodeProperty() { var diffObj = new DifferenceNode(1, 1, 4, 4); Assert.AreEqual(1, diffObj.Sequence1Start); Assert.AreEqual(1, diffObj.Sequence2Start); Assert.AreEqual(4, diffObj.Sequence1End); Assert.AreEqual(4, diffObj.Sequence2End); Assert.AreEqual("1 : 1 : 4 : 4", diffObj.ToString()); }
public void GlobalTest10() { MainViewModel mvm = MainViewModelTest.GetInstance(); PipelineViewModel pvm = mvm.PipelineViewModel; // Step 1: The user clicks "New" to create a new pipeline mvm.Clear(); Assert.Empty(mvm.Model.Graph.Nodes); var mock = new Mock <IDragEventInfo>(); // Step 2: Create each type of node once by drag-and-drop VideoInputNode vin = (VideoInputNode)AddNode <VideoInputNode>(pvm, mock, new Point(10, 30)); AdditiveMergeNode amn = (AdditiveMergeNode)AddNode <AdditiveMergeNode>(pvm, mock, new Point(30, 30)); BlurNode bn = (BlurNode)AddNode <BlurNode>(pvm, mock, new Point(50, 30)); BrightnessContrastSaturationNode bcsn = (BrightnessContrastSaturationNode)AddNode <BrightnessContrastSaturationNode>(pvm, mock, new Point(70, 30)); ColorInputNode cin = (ColorInputNode)AddNode <ColorInputNode>(pvm, mock, new Point(10, 50)); DelayNode dln = (DelayNode)AddNode <DelayNode>(pvm, mock, new Point(90, 30)); DiagramNode dgn = (DiagramNode)AddNode <DiagramNode>(pvm, mock, new Point(110, 30)); DifferenceNode dfn = (DifferenceNode)AddNode <DifferenceNode>(pvm, mock, new Point(30, 50)); HistogramNode hn = (HistogramNode)AddNode <HistogramNode>(pvm, mock, new Point(50, 50)); ImageInputNode imin = (ImageInputNode)AddNode <ImageInputNode>(pvm, mock, new Point(70, 50)); InverterNode invn = (InverterNode)AddNode <InverterNode>(pvm, mock, new Point(90, 50)); NoiseInputNode nin = (NoiseInputNode)AddNode <NoiseInputNode>(pvm, mock, new Point(110, 50)); OverlayNode on = (OverlayNode)AddNode <OverlayNode>(pvm, mock, new Point(10, 70)); RgbSplitNode rgbsn = (RgbSplitNode)AddNode <RgbSplitNode>(pvm, mock, new Point(30, 70)); WeightedAveragedMergeNode wamn = (WeightedAveragedMergeNode)AddNode <WeightedAveragedMergeNode>(pvm, mock, new Point(50, 70)); // Step 3: Create the edges mvm.Model.Graph.AddEdge(vin.Outputs[0], bn.Inputs[0]); Assert.Equal(vin.Outputs[0], bn.Inputs[0].Source); amn.Inputs.Add(new Node.Input()); mvm.Model.Graph.AddEdge(vin.Outputs[0], amn.Inputs[0]); Assert.Equal(vin.Outputs[0], amn.Inputs[0].Source); mvm.Model.Graph.AddEdge(bn.Outputs[0], dln.Inputs[0]); Assert.Equal(bn.Outputs[0], dln.Inputs[0].Source); mvm.Model.Graph.AddEdge(dln.Outputs[0], dfn.Inputs[0]); Assert.Equal(dln.Outputs[0], dfn.Inputs[0].Source); mvm.Model.Graph.AddEdge(imin.Outputs[0], dfn.Inputs[1]); Assert.Equal(imin.Outputs[0], dfn.Inputs[1].Source); mvm.Model.Graph.AddEdge(dfn.Outputs[0], invn.Inputs[0]); Assert.Equal(dfn.Outputs[0], invn.Inputs[0].Source); mvm.Model.Graph.AddEdge(invn.Outputs[0], on.Inputs[0]); Assert.Equal(invn.Outputs[0], on.Inputs[0].Source); mvm.Model.Graph.AddEdge(vin.Outputs[0], on.Inputs[1]); Assert.Equal(vin.Outputs[0], on.Inputs[1].Source); mvm.Model.Graph.AddEdge(vin.Outputs[0], rgbsn.Inputs[0]); Assert.Equal(vin.Outputs[0], rgbsn.Inputs[0].Source); mvm.Model.Graph.AddEdge(rgbsn.Outputs[2], hn.Inputs[0]); Assert.Equal(rgbsn.Outputs[2], hn.Inputs[0].Source); }
public static void FindDifferencesInSequences(string firstFile, string secondFile) { // parsowanie pierwszej listy if (!SequenceParsers.IsFasta(firstFile)) { Console.WriteLine("Nieprawidlowy format pierwszego pliku!"); return; } if (!SequenceParsers.IsFasta(secondFile)) { Console.WriteLine("Nieprawidlowy format drugiego pliku!"); return; } var firstParser = SequenceParsers.FindParserByFileName(firstFile); firstParser.Alphabet = AmbiguousProteinAlphabet.Instance; var firstSequenceList = firstParser.Parse(); var firstFileSequences = Helper.ConvertIenumerableToList(firstSequenceList); // parsowanie drugiej listy var secondParser = SequenceParsers.FindParserByFileName(firstFile); secondParser.Alphabet = AmbiguousProteinAlphabet.Instance; var secondSequenceList = secondParser.Parse(); var secondFileSequences = Helper.ConvertIenumerableToList(secondSequenceList); // pobranie listy KMER'ów var kmerBuilder = new SequenceToKmerBuilder(); var kmerList = kmerBuilder.Build(firstFileSequences.First(), 2); var nodes = WordMatch.BuildMatchTable(kmerList, secondFileSequences.First(), 2); var list2 = new List <WordMatch>(nodes); var matchList = WordMatch.GetMinimalList(list2, 2); var list3 = new List <WordMatch>(matchList); // znajdŸ ró¿nice miêdzy wêz³ami var diffNode = DifferenceNode.BuildDiffList(list3, firstFileSequences.First(), secondFileSequences.First()); var list4 = new List <DifferenceNode>(diffNode); var features = DifferenceNode.OutputDiffList(list4, firstFileSequences.First(), secondFileSequences.First()); foreach (var compareFeature in features) { Console.WriteLine(compareFeature.Feature); } }
public string solution(string S) { string oneLetterPalindrom = GetOneLetterPalindrom(S); if (oneLetterPalindrom != NoAnswer) { return(oneLetterPalindrom); } List <Word> words = GetWords(S).ToList(); var palindromWord = words.LastOrDefault(w => w.IsPalindrom); if (palindromWord != null) { return(palindromWord.OriginWord); } string result = NoAnswer; var words1 = words.GroupBy(w => w.OriginWord[0]).ToDictionary(g => g.Key, g => g.ToList()); var words2 = words.GroupBy(w => w.OriginWord[w.OriginWord.Length - 1]).ToDictionary(g => g.Key, g => g.ToList()); List <SymmetricGroup> symmetricGroups = words.Select(w => new SymmetricGroup(new Sentence(w), new Sentence(), new Difference(w.OriginWord))).ToList(); var differenceRoot1 = new DifferenceNode(); var differenceRoot2 = new DifferenceNode(); foreach (SymmetricGroup symmetricGroup in symmetricGroups) { differenceRoot1.Add(symmetricGroup.Difference, 0); } while (symmetricGroups.Any(x => x.Sentence.Length < MaxLength)) { result = GetPalindrom(symmetricGroups); if (result != NoAnswer) { return(result); } symmetricGroups = symmetricGroups.SelectMany(x => x.Join(words1, words2, differenceRoot1, differenceRoot2)).ToList(); if (!symmetricGroups.Any()) { return(NoAnswer); } } return(result); }
public void SequenceCompare() { ISequence seq1 = new Sequence(Alphabets.DNA, "AAAAAA"); ISequence seq2 = new Sequence(Alphabets.DNA, "AAATAA"); SequenceToKmerBuilder kmerBuilder = new SequenceToKmerBuilder(); KmersOfSequence kmers = kmerBuilder.Build(seq1, 2); List <WordMatch> nodes = WordMatch.BuildMatchTable(kmers, seq1, seq2, 2); List <WordMatch> matchList = WordMatch.GetMinimalList(nodes, 2); List <DifferenceNode> diffNode = DifferenceNode.BuildDiffList(matchList, seq1, seq2); List <DifferenceNode.CompareFeature> features = DifferenceNode.OutputDiffList(diffNode, seq1, seq2); Assert.AreEqual(features.Count, 4); Assert.AreEqual(features[0].Feature, "Insertion of 1 bases in 2 "); Assert.AreEqual(features[1].FeatureType, "REPLACE"); Assert.AreEqual(features[2].Feature, "Insertion of 1 bases in 1 "); Assert.AreEqual(features[3].FeatureType, "REPLACE"); }
public void ValidateSequenceCompare() { string firstSequence = utilityObj.xmlUtil.GetTextValue(Constants.SequenceCompareNode, Constants.SequenceNode1); string secondSequence = utilityObj.xmlUtil.GetTextValue(Constants.SequenceCompareNode, Constants.SequenceNode2); string replace = utilityObj.xmlUtil.GetTextValue(Constants.SequenceCompareNode, Constants.ReplaceNode); ISequence seq1 = new Sequence(Alphabets.DNA, firstSequence); ISequence seq2 = new Sequence(Alphabets.DNA, secondSequence); var kmerBuilder = new SequenceToKmerBuilder(); KmersOfSequence kmers = kmerBuilder.Build(seq1, 2); List <WordMatch> nodes = WordMatch.BuildMatchTable(kmers, seq2, 2); List <WordMatch> matchList = WordMatch.GetMinimalList(nodes, 2); List <DifferenceNode> diffNode = DifferenceNode.BuildDiffList(matchList, seq1, seq2); List <DifferenceNode.CompareFeature> features = DifferenceNode.OutputDiffList(diffNode, seq1, seq2); //Validating the bahavior. Assert.AreEqual(features.Count, 4); Assert.AreEqual(features[0].Feature, Constants.InsertionOfOneBaseIn2); Assert.AreEqual(features[1].FeatureType, replace); Assert.AreEqual(features[2].Feature, Constants.InsertionOfOneBaseIn1); Assert.AreEqual(features[3].FeatureType, replace); }
internal IEnumerable <SymmetricGroup> Join( Dictionary <char, List <Word> > words1, Dictionary <char, List <Word> > words2, DifferenceNode differenceRoot1, DifferenceNode differenceRoot2) { int len1 = Sentence.Length; int len2 = ReverseSentence.Length; if (len1 < len2) { List <Word> words; if (!words1.TryGetValue(Difference.CharAtFromEnd(0), out words)) { yield break; } foreach (Word word in words) { bool canJoin = true; int charCountToCheck = Math.Min(word.OriginWord.Length, len2 - len1); for (int i = 1; i < charCountToCheck; i++) { if (word.OriginWord[i] != Difference.CharAtFromEnd(i)) { canJoin = false; break; } } if (canJoin) { Difference newDifference; if (len2 - len1 >= word.OriginWord.Length) { string baseWord = ReverseSentence.Words.First.OriginWord; newDifference = new Difference(baseWord, 0, len2 - len1 - word.OriginWord.Length); if (!differenceRoot2.AddReverse(newDifference, 0)) { continue; } } else { newDifference = new Difference(word.OriginWord, len2 - len1, word.OriginWord.Length - len2 + len1); if (!differenceRoot1.Add(newDifference, 0)) { continue; } } yield return(new SymmetricGroup(Sentence.Append(word), ReverseSentence, newDifference)); } } } if (len1 > len2) { List <Word> words; if (!words2.TryGetValue(Difference.CharAt(0), out words)) { yield break; } foreach (Word word in words) { bool canJoin = true; int charCountToCheck = Math.Min(word.OriginWord.Length, len1 - len2); for (int i = 1; i < charCountToCheck; i++) { if (word.OriginWord[word.OriginWord.Length - 1 - i] != Difference.CharAt(i)) { canJoin = false; break; } } if (canJoin) { Difference newDifference; if (len1 - len2 >= word.OriginWord.Length) { string baseWord = Sentence.Words.Last.OriginWord; newDifference = new Difference(baseWord, baseWord.Length - len1 + len2 + word.OriginWord.Length, len1 - len2 - word.OriginWord.Length); if (!differenceRoot1.Add(newDifference, 0)) { continue; } } else { newDifference = new Difference(word.OriginWord, 0, word.OriginWord.Length - len1 + len2); if (!differenceRoot2.AddReverse(newDifference, 0)) { continue; } } yield return(new SymmetricGroup(Sentence, ReverseSentence.Prepend(word), newDifference)); } } } }
public DifferenceTable(DifferenceNode node, Program program) : base(node, program) { }