Beispiel #1
0
    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);
    }
Beispiel #2
0
        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);
                }
            }
        }
Beispiel #3
0
        /// <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."));
        }
Beispiel #4
0
        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());
        }
Beispiel #5
0
        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);
        }
Beispiel #6
0
        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);
            }
        }
Beispiel #7
0
    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);
    }
Beispiel #8
0
        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");
        }
Beispiel #9
0
        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);
        }
Beispiel #10
0
    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));
                }
            }
        }
    }
Beispiel #11
0
        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());
        }
Beispiel #12
0
 public DifferenceTable(DifferenceNode node, Program program) : base(node, program)
 {
 }