source: trunk/CrypPlugins/PlayfairAnalysisStatistic/PlayfairAnalysisStatistic.cs @ 2527

Last change on this file since 2527 was 2334, checked in by Matthäus Wander, 11 years ago

removed 1006 occurences of DisplayLevel in 218 files (see #122)

File size: 17.4 KB
Line 
1/* HOWTO: Change year, author name and organization.
2   Copyright 2010 Your Name, University of Duckburg
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16using System;
17using System.Collections.Generic;
18using System.Linq;
19using System.Text;
20using Cryptool.PluginBase;
21using Cryptool.PluginBase.Analysis;
22using Cryptool.PluginBase.Cryptography;
23using System.ComponentModel;
24using Cryptool.PluginBase.IO;
25using Cryptool.PluginBase.Miscellaneous;
26using System.Windows.Controls;
27
28namespace Cryptool.Plugins.PlayfairAnalysisStatistic
29{   
30    [Author("Christoph Hartmann", "chris-ha@freenet.de", "Johannes Gutenberg-Universität Mainz", "http://www.uni-mainz.de")]
31    [PluginInfo(true, "Playfair Analysis Statistic", "Generates Bigraph Statistic for Playfair Analysis Plugin ", null, "CrypWin/images/default.png")]
32    [EncryptionType(EncryptionType.Classic)]
33    public class PlayfairAnalysisStatistic : ISpecific
34    {
35        #region Private Variables
36               
37        private PlayfairAnalysisStatisticSettings settings = new PlayfairAnalysisStatisticSettings();       
38        private byte[] unformattedTextByte;
39        private string unformattedText;
40        private string formattedText;
41        private string sortedAlphabet;
42        private double[,] logStat;
43        private double[] logStat2;
44        private byte[] logStatByte;
45
46        #endregion
47
48        #region Data Properties
49
50        /// <summary>
51        /// HOWTO: Input interface to read the input data.
52        /// You can add more input properties of other type if needed.
53        /// </summary>
54       
55
56        /// <summary>
57        /// HOWTO: Output interface to write the output data.
58        /// You can add more output properties ot other type if needed.
59        /// </summary>
60       
61        /*
62        [PropertyInfo(Direction.OutputData, "Bigraph Statistic", "Bigraph Statistic for Playfair Analysis Plugin", null)]
63        public virtual double[] BigraphStatistic
64        {
65            get { return this.logStat2; }
66            set
67            {
68                if (value != this.logStat2)
69                {
70                    this.logStat2 = value;
71                    OnPropertyChanged("BigraphStatistic");
72                }
73            }
74        }
75        */
76
77        CryptoolStream csBigraphStatistic;
78        [PropertyInfo(Direction.OutputData, "Bigraph Statistic", "Bigraph Statistic for Playfair Analysis Plugin", null)]
79        public CryptoolStream OutputStream
80        {
81            get
82            {
83                if (this.csBigraphStatistic != null)
84                {
85                    CryptoolStream cs = new CryptoolStream();
86                    cs.OpenRead(this.csBigraphStatistic.FileName);
87                    return cs;
88                }
89                return null;
90            }
91
92            set
93            {
94                if (value != this.csBigraphStatistic)
95                {
96                    this.csBigraphStatistic = value;                   
97                    OnPropertyChanged("OutputStream");
98                }
99            }
100        }
101
102
103        #endregion
104
105        #region IPlugin Members
106
107        public ISettings Settings
108        {
109            get { return settings; }
110        }
111
112        /// <summary>
113        /// HOWTO: You can provide a custom (tabbed) presentation to visualize your algorithm.
114        /// Return null if you don't provide one.
115        /// </summary>
116        public UserControl Presentation
117        {
118            get { return null; }
119        }
120
121        /// <summary>
122        /// HOWTO: You can provide custom (quickwatch) presentation to visualize your algorithm.
123        /// Return null if you don't provide one.
124        /// </summary>
125        public UserControl QuickWatchPresentation
126        {
127            get { return null; }
128        }
129
130        public void PreExecution()
131        {
132        }
133
134        /// <summary>
135        /// HOWTO: Enter the algorithm you'd like to implement in this method.
136        /// </summary>
137        public void Execute()
138        {
139            int matrixSize;
140           
141            switch (settings.MatrixSize)
142            {
143                case 0:
144                    matrixSize = 5;                                     
145                    break;
146                case 1:
147                    matrixSize = 6;                   
148                    break;
149                default:
150                    matrixSize = 5;                   
151                    break;
152            }
153
154            // HOWTO: Use this to show the progress of a plugin algorithm execution in the editor.
155            ProgressChanged(0, 1);
156
157            // HOWTO: After you have changed an output property, make sure you announce the name of the changed property to the CT2 core.
158           
159            //OnPropertyChanged("Difference");
160
161            // HOWTO: You can pass error, warning, info or debug messages to the CT2 main window.
162
163            GuiLogMessage("Text Corpus File: " + settings.TextCorpusFile, NotificationLevel.Info);
164
165
166            if ((settings.Alphabet.Contains(settings.Separator)) && (settings.Alphabet.Contains(settings.SeparatorReplacement))
167                && (settings.Alphabet.Contains(settings.ReplacementChar)))
168            {
169
170                if (!ContainsDuplicates(settings.Alphabet))
171                {
172
173                    if (settings.TextCorpusFile != null && settings.TextCorpusFile.EndsWith(".txt"))
174                    {
175                        if (((matrixSize == 5) && (settings.Alphabet.Length == 25))
176                            || ((matrixSize == 6) && (settings.Alphabet.Length == 36)))
177                        {
178                            unformattedTextByte = System.IO.File.ReadAllBytes(settings.TextCorpusFile);
179                            unformattedText = Encoding.Default.GetString(unformattedTextByte);
180
181                            GuiLogMessage(settings.Alphabet, NotificationLevel.Info);
182
183                            SortAlphabet(settings.Alphabet);
184                            GuiLogMessage("sortedAlphabet: " + sortedAlphabet, NotificationLevel.Info);
185                            GuiLogMessage("ToUpper: " + Convert.ToString(settings.CorpusToUpper), NotificationLevel.Info);
186
187                            FormatText();
188
189                            GuiLogMessage("formatted text: " + formattedText, NotificationLevel.Info);
190
191                            CalcLogStat();
192
193                           
194                            // Write Alphabet Length, sortedAlphabet and logStat (double array) in logStatByte (byte array)
195                            logStatByte = new byte[(8*logStat.Length) + 1 + sortedAlphabet.Length];
196                            byte[] doubleValue = new byte[8];
197                            int index = 0;
198
199                            logStatByte[index] = (byte)sortedAlphabet.Length;
200                            index++;
201
202                            for (int i = 0; i < sortedAlphabet.Length; i++)
203                            {
204                                logStatByte[index] = Convert.ToByte(sortedAlphabet[i]);
205                                index++;
206                            }                           
207
208                            for (int i = 0; i < (int)Math.Pow(matrixSize, 2); i++)
209                            {
210                                for (int j = 0; j < (int)Math.Pow(matrixSize, 2); j++)
211                                {
212                                    doubleValue = BitConverter.GetBytes(logStat[i, j]);
213                                    for (int k = 0; k < 8; k++)
214                                    {
215                                        logStatByte[index] = doubleValue[k];
216                                        index++;
217                                    }
218                                }
219                            }
220                           
221
222                            csBigraphStatistic = new CryptoolStream();
223                            csBigraphStatistic.OpenWrite();
224                             
225                           
226
227                            csBigraphStatistic.Write(logStatByte);
228                            OnPropertyChanged("OutputStream");
229
230
231                            GuiLogMessage("CalcLogStat completed: ", NotificationLevel.Info);                           
232
233                        }
234
235                        else
236                        {
237                            System.Windows.MessageBox.Show("Wrong Alphabet Length!\nAlphabet must contain " + Convert.ToString(Math.Pow(matrixSize, 2)) + " characters.");
238                        }
239
240                    }
241                    else if (settings.TextCorpusFile == null)
242                    {
243                        System.Windows.MessageBox.Show("For calculating the bigraph statistic a text corpus file is needed!");
244                    }
245                    else
246                    {
247                        System.Windows.MessageBox.Show("Text Corpus File has to be a .txt file!");
248                        settings.TextCorpusFile = null;
249                    }
250
251                }
252                else
253                {
254                    System.Windows.MessageBox.Show("Alphabet contains duplicate characters!");
255                }
256
257            }
258
259            else
260            {
261                System.Windows.MessageBox.Show("Alphabet must contain Separator, Separator Replacement and Replacement Character!");
262            }
263                       
264            ProgressChanged(1, 1);           
265        }
266
267        public void PostExecution()
268        {
269        }
270
271        public void Pause()
272        {
273        }
274
275        public void Stop()
276        {
277        }
278
279        public void Initialize()
280        {
281            settings.MatrixSize = 0;
282            settings.Alphabet = settings.SmallAlphabet;
283            settings.RemoveChar = 'J';
284            settings.ReplacementChar = 'I';
285            settings.Separator = 'X';
286            settings.SeparatorReplacement = 'Y';
287            settings.CorpusToUpper = true;
288            settings.ConvertSpecialSigns = true;
289            settings.ReplaceCharacter = true;
290        }
291
292        public void Dispose()
293        {
294        }
295
296        #endregion
297
298        #region Private Methods
299
300        void SortAlphabet(string alphabet)
301        {
302            char[] alphabetArray;
303            sortedAlphabet = "";
304           
305            alphabetArray = alphabet.ToCharArray();
306            Array.Sort(alphabetArray);
307           
308            for (int i = 0; i < alphabet.Length; i++)
309            {
310                sortedAlphabet += alphabetArray[i];
311            }                       
312        }
313
314        bool ContainsDuplicates(string alphabet)
315        {
316            bool returnVal = false;
317
318            for (int i = 0; i < alphabet.Length - 1; i++)
319            {
320                for (int j = i + 1; j < alphabet.Length; j++)
321                {
322                    if (alphabet[i] == alphabet[j])
323                        returnVal = true;
324                }
325            }
326            return returnVal;
327        }
328
329        void FormatText()
330        {           
331            int length = unformattedText.Length;
332            StringBuilder FormattedTextSB = new StringBuilder(unformattedText.Length);
333           
334            if (settings.CorpusToUpper)
335            {
336                formattedText = unformattedText.ToUpper();               
337            }
338            else
339            {
340                formattedText = unformattedText;
341            }
342
343            if (settings.ConvertSpecialSigns)
344            {
345                for (int i = 0; i < formattedText.Length; i++)
346                {
347                    if (formattedText[i] == 'Ä')
348                        FormattedTextSB.Append("AE");
349                    else if (formattedText[i] == 'Ö')
350                        FormattedTextSB.Append("OE");
351                    else if (formattedText[i] == 'Ü')
352                        FormattedTextSB.Append("UE");
353                    else if (formattedText[i] == 'ß')
354                        if (settings.CorpusToUpper)
355                            FormattedTextSB.Append("SS");
356                        else
357                            FormattedTextSB.Append("ss");
358                    else if (formattedText[i] == 'ä')
359                        FormattedTextSB.Append("ae");
360                    else if (formattedText[i] == 'ö')
361                        FormattedTextSB.Append("oe");
362                    else if (formattedText[i] == 'ü')
363                        FormattedTextSB.Append("ue");
364                    else
365                        FormattedTextSB.Append(formattedText[i]);                   
366                }               
367            }
368            else
369            {
370                FormattedTextSB.Append(formattedText);
371            }
372
373            ProgressChanged(0.1, 1);
374
375            if (settings.ReplaceCharacter)
376            {           
377                FormattedTextSB.Replace(settings.RemoveChar, settings.ReplacementChar);
378            }
379
380            formattedText = FormattedTextSB.ToString();
381            FormattedTextSB = new StringBuilder(formattedText.Length);
382
383            ProgressChanged(0.2, 1);
384           
385            for (int i = 0; i < formattedText.Length; i++)
386            {
387                if (sortedAlphabet.Contains(formattedText[i]))
388                    FormattedTextSB.Append(formattedText[i]);
389            }
390
391            ProgressChanged(0.3, 1);
392           
393
394            for (int i = 0; i < FormattedTextSB.Length - 1; i += 2)
395            {
396                if (FormattedTextSB[i] == FormattedTextSB[i + 1])
397                {
398                    if (FormattedTextSB[i] == settings.Separator)
399                        FormattedTextSB.Insert(i + 1, settings.SeparatorReplacement);
400                    else
401                        FormattedTextSB.Insert(i + 1, settings.Separator);                   
402                }
403
404                if ((i == (FormattedTextSB.Length / 2)) || (i == (FormattedTextSB.Length / 2) + 1) )
405                    ProgressChanged(0.45, 1);
406            }                                 
407
408            ProgressChanged(0.6, 1);
409
410            if ((FormattedTextSB.Length % 2) == 1)
411            {
412                if (FormattedTextSB[FormattedTextSB.Length - 1] == settings.Separator)
413                    FormattedTextSB.Append(settings.SeparatorReplacement);
414                else
415                    FormattedTextSB.Append(settings.Separator);
416            }
417
418            formattedText = FormattedTextSB.ToString();
419        }
420
421
422        public void CalcLogStat()
423        {
424            int Pos1, Pos2;
425            int sum = 0;
426            int matrixSize;
427
428            switch (settings.MatrixSize)
429            {
430                case 0:
431                    matrixSize = 5;
432                    break;
433
434                case 1:
435                    matrixSize = 6;                   
436                    break;
437
438                default:
439                    matrixSize = 5;
440                    break;
441            }
442
443            logStat = new double[(int)Math.Pow(matrixSize, 2), (int)Math.Pow(matrixSize, 2)];
444
445            for (int i = 0; i < formattedText.Length - 1; i += 2)
446            {
447                Pos1 = sortedAlphabet.IndexOf(formattedText[i]);
448                Pos2 = sortedAlphabet.IndexOf(formattedText[i + 1]);
449
450                logStat[Pos1, Pos2]++;
451                sum++;
452            }                   
453
454            ProgressChanged(0.8, 1);
455
456            for (int i = 0; i < (int)Math.Pow(matrixSize, 2); i++)
457            {
458                for (int j = 0; j < (int)Math.Pow(matrixSize, 2); j++)
459                {
460                    if (logStat[i, j] > 0)
461                    {
462                        logStat[i, j] = Math.Log(logStat[i, j] / sum);
463                    }
464                    else
465                        logStat[i, j] = -10;
466                }
467            }
468
469        }
470
471        #endregion
472
473        #region Event Handling
474
475        public event StatusChangedEventHandler OnPluginStatusChanged;
476
477        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
478
479        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
480
481        public event PropertyChangedEventHandler PropertyChanged;
482
483        private void GuiLogMessage(string message, NotificationLevel logLevel)
484        {
485            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
486        }
487
488        private void OnPropertyChanged(string name)
489        {
490            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
491        }
492
493        private void ProgressChanged(double value, double max)
494        {
495            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
496        }
497
498
499        #endregion
500    }
501}
Note: See TracBrowser for help on using the repository browser.