public Main() { // this is generated by VisualStudio InitializeComponent(); // create new windows speech recognizer initializeSpeechRecognier(); // initialize codeBook with the speech recognizer codeBook = new CodeBook(speechRecognizer, authenticationThreshold); // for each folder next to the program, each folder contains MFCC files for a person foreach (string folderName in Directory.GetDirectories(".")) { // obtail username from folder path, (folder path may start with .\ or sth like that) string username = Path.GetFileName(folderName); // add the saved user to code book codeBook.AddToModel( username, // pass all MFCC files inside the folder Directory.GetFiles(folderName), // pass the password priorly saved for that user File.ReadAllText(username + ".password") ); } }
static void TestRandomData(string testDataSavePath = null) { var chars = "abcdefghijklmnopqrstuvwxyz"; chars += chars.ToUpper() + "0123456789`~!@#$%^&*()_+=-{}[]|:><,.\"'\\?/"; var validCharBytes = Encoding.UTF8.GetBytes(chars); var codeBook = CodeBook.InitFromValidChars(validCharBytes); var codeBookMetaData = codeBook.GetMetaData(); var codeBook2 = CodeBook.InitFromMetaData(codeBookMetaData); var seeds = new List <string> { "PaladinDu01", "PaladinDu02", "PaladinDu03", }; var keys = new List <byte[]>(); foreach (var seed in seeds) { keys.Add(codeBook.InitSeed(Encoding.UTF8.GetBytes(seed))); } var testDatas = new List <byte[]> { Encoding.UTF8.GetBytes("aaaaaaaaaaaaaaaaaaaaaaa"), Encoding.UTF8.GetBytes("aaaaaaaaaaaaaaaaaaaaaaab"), Encoding.UTF8.GetBytes("aaaaaaaaaaaaaaaaaaaaaaac"), Encoding.UTF8.GetBytes("aaaaaaaaaaaaaaaaaaaaaaad") }; for (int i = 0; i < 1000; ++i) { testDatas.Add(GetRandomBytes(validCharBytes, 20)); } foreach (var testData in testDatas) { TestData(codeBook, keys[0], testData); TestData(codeBook2, keys[0], testData); } foreach (var key in keys) { TestData(codeBook, key, testDatas[0]); } if (testDataSavePath != null) { var testCases = new List <List <string> >(); foreach (var testData in testDatas) { testCases.Add(new List <string> { Encoding.UTF8.GetString(testData), Encoding.UTF8.GetString(codeBook.Encryption(testData, keys[0])) }); } var json = JsonConvert.SerializeObject(new TestDataInfo { meta = codeBookMetaData, seed = seeds[0], cases = testCases }); System.IO.File.WriteAllText(testDataSavePath, json); } }
public async Task <CodeBook> AddCodeBook(CodeBook codeBook) { await _context.CodeBook.AddAsync(codeBook); await _context.SaveChangesAsync(); return(codeBook); }
public EdditSetting(int id, CodeBook settingId, string name) { Id = id; status = settingId; InitializeComponent(); Name = name; rnServices = new RnServices(); }
public void WriteBook(CodeBook book, int a) { if ((a < 0) || (a >= book.Entries)) { return; } Write(book.CodeList[a], book.StaticBook.LengthList[a]); }
private void EncodePart(EncodeBuffer buffer, int[] vec, int offset, int n, CodeBook book) { var step = n / book.Dimensions; for (var i = 0; i < step; i++) { var entry = LocalBookBestError(book, vec, offset + i * book.Dimensions); buffer.WriteBook(book, entry); } }
public static CodeBook[,] CreateCodeBook(Image <Hsv, byte> image) { CodeBook[,] codebooks = new CodeBook[image.Height, image.Width]; for (int i = 0; i < image.Height; i++) { for (int j = 0; j < image.Width; j++) { codebooks[i, j] = new CodeBook(); } } return(codebooks); }
static public CodeBook InitFromValidChars(byte[] validChars) { var ret = new CodeBook(); ret.CharToIndexMap = new int[256]; ret.CharsCount = validChars.Length; var charCount = 0; var charMap = new int[256]; for (int i = 0; i < 256; ++i) { charMap[i] = InvalidIndex; } foreach (var validChar in validChars) { if (charMap[validChar] != 1) { charMap[validChar] = 1; charCount += 1; } } ret.IndexToCharMap = new byte[charCount]; for (int i = 0, j = 0; i < 256; ++i) { if (charMap[i] == 1) { ret.IndexToCharMap[j] = (byte)i; ret.CharToIndexMap[i] = j; j++; } } ret.EncryptionMap = new byte[charCount]; ret.DecryptionMap = new byte[charCount]; for (int i = 0; i < ret.CharsCount; ++i) { ret.EncryptionMap[i] = (byte)i; } var rand = new Random(); for (int i = 0; i < ret.CharsCount; ++i) { var randInt = rand.Next(0, ret.CharsCount - i); var tmpCode = ret.EncryptionMap[i]; ret.EncryptionMap[i] = ret.EncryptionMap[i + randInt]; ret.DecryptionMap[ret.EncryptionMap[i]] = (byte)i; ret.EncryptionMap[i + randInt] = tmpCode; } return(ret); }
static void TestData(CodeBook strCoding, byte[] key, byte[] data) { var encodeData = strCoding.Encryption(data, key); var decodeData = strCoding.Decryption(encodeData, key); if (Encoding.UTF8.GetString(data).Equals(Encoding.UTF8.GetString(decodeData))) { Console.WriteLine($"encryption success: {Encoding.UTF8.GetString(data)},{Encoding.UTF8.GetString(encodeData)}"); } else { Console.WriteLine($"encryption error: {Encoding.UTF8.GetString(data)},{Encoding.UTF8.GetString(decodeData)}"); } }
/// <summary> /// Retrieve fragment index inside codebook that is associated to a time index /// </summary> /// <returns>Returns -1 if the time index isn't covered by the codebook</returns> public int GetCodeBookFragmentIndex(ref CodeBook codeBook, TimeIndex timeIndex) { int numIntervals = codeBook.intervals.Length; int fragmentIndex = 0; for (int i = 0; i < numIntervals; ++i) { ref Interval interval = ref GetInterval(codeBook.intervals[i]); if (interval.Contains(timeIndex)) { fragmentIndex += timeIndex.frameIndex - interval.firstFrame; return(fragmentIndex); } fragmentIndex += interval.numFrames; }
public async Task <IActionResult> AddCodeBook(CodeBook codeBook) { var codeBookCreate = new CodeBook { CodeBookName = codeBook.CodeBookName }; var createdCodeBook = await _codeBookRepo.AddCodeBook(codeBookCreate); var codeBookKeyCreate = new CodeBookKey { CodeBookKeyId = codeBook.Id, CodeBookId = createdCodeBook.Id }; var createdCodeBookKey = await _codeBookKeyRepo.AddCodeBookKeys(codeBookKeyCreate); return(Ok(createdCodeBookKey)); }
/// <summary> /// This function returns TRUE if code book item selected by code book name and /// code book code exists. Otherwise this function returns false. /// </summary> /// <param name="fieldItem"></param> /// <param name="valueToValidate"></param> /// <param name="currentCodeBook"></param> /// <returns></returns> private bool CodeBookFieldValidate(FieldItem fieldItem, string valueToValidate, out string currentCodeBook) { currentCodeBook = string.Empty; CodeBook codeBook = fieldItem.FieldType as CodeBook; if (codeBook == null || string.IsNullOrEmpty(valueToValidate)) { return(true); } currentCodeBook = codeBook.CodeBookName; if (!this._package.CodeBook.IsValidValue(codeBook.CodeBookName, valueToValidate, out string message)) { return(false); } return(true); }
public ResidueLookup(Residue residue, List <CodeBook> fullBooks) { if (residue.ResidueType != ResidueType.Two) { throw new NotImplementedException("ResidueTypes other than 'Two' are not yet implemented"); } _residue = residue; _phraseBook = fullBooks[residue.GroupBook]; var acc = 0; var maxstage = 0; _partitionBooks = new CodeBook[residue.Partitions][]; for (var j = 0; j < _partitionBooks.Length; j++) { var stages = Encoding.Log(residue.SecondStages[j]); if (stages == 0) { continue; } if (stages > maxstage) { maxstage = stages; } _partitionBooks[j] = new CodeBook[stages]; for (var k = 0; k < stages; k++) { if ((residue.SecondStages[j] & (1 << k)) != 0) { _partitionBooks[j][k] = fullBooks[residue.BookList[acc++]]; } } } _stages = maxstage; }
static void TestByTestData(string testDataPath) { string text = System.IO.File.ReadAllText(testDataPath); var testDataInfo = JsonConvert.DeserializeObject <TestDataInfo>(text); var codeBook = CodeBook.InitFromMetaData(testDataInfo.meta); var key = codeBook.InitSeed(Encoding.UTF8.GetBytes(testDataInfo.seed)); foreach (var caseData in testDataInfo.cases) { var decryptionData = codeBook.Decryption(Encoding.UTF8.GetBytes(caseData[1]), key); if (caseData[0].Equals(Encoding.UTF8.GetString(decryptionData))) { Console.WriteLine($"decryption success:{caseData[0]},{caseData[1]}"); } else { Console.WriteLine($"decryption error:{caseData[0]},{caseData[1]},{Encoding.UTF8.GetString(decryptionData)}"); } } }
static public CodeBook InitFromMetaData(string metaData) { var ret = new CodeBook(); byte[] metaDataBytes = Encoding.UTF8.GetBytes(metaData); ret.CharsCount = metaData.Length / 4; ret.CharToIndexMap = new int[256]; ret.IndexToCharMap = new byte[ret.CharsCount]; ret.EncryptionMap = new byte[ret.CharsCount]; ret.DecryptionMap = new byte[ret.CharsCount]; for (int i = 0; i < ret.CharsCount; ++i) { var tmpChar = (byte)((HexToNumMap[metaDataBytes[i * 2]] << 4) | HexToNumMap[metaDataBytes[i * 2 + 1]]); ret.CharToIndexMap[tmpChar] = i; ret.IndexToCharMap[i] = tmpChar; tmpChar = (byte)((HexToNumMap[metaDataBytes[i * 2 + ret.CharsCount * 2]] << 4) | HexToNumMap[metaDataBytes[i * 2 + 1 + ret.CharsCount * 2]]); ret.EncryptionMap[i] = tmpChar; ret.DecryptionMap[tmpChar] = (byte)i; } return(ret); }
public ResidueLookup(ResidueEntry residue, CodeBook[] fullBooks) { _residue = residue; _phraseBook = fullBooks[residue.GroupBook]; var acc = 0; var maxstage = 0; _partitionBooks = new CodeBook[residue.Partitions][]; for (var j = 0; j < _partitionBooks.Length; j++) { var stages = Encoding.Log(residue.SecondStages[j]); if (stages == 0) { continue; } if (stages > maxstage) { maxstage = stages; } _partitionBooks[j] = new CodeBook[stages]; for (var k = 0; k < stages; k++) { if ((residue.SecondStages[j] & (1 << k)) != 0) { _partitionBooks[j][k] = fullBooks[residue.BookList[acc++]]; } } } _stages = maxstage; }
/// <summary> /// Separate inputs columns from output column (from ExtractedDataset /// table) and convert strings into numeric values. /// </summary> /// <param name="attributeToPredict">Name of the output column.</param> /// <param name="codeBook">Codebook to be used (by default null).</param> /// <returns>Bool value indicating whether the dataset was /// processed correctly or not.</returns> public bool ProcessDataset(string attributeToPredict, Codification codeBook = null) { // ProcessedDataset will have the same structure of ExtractedDataset. ProcessedDataset = ExtractedDataset.Clone(); // Inputs and outputs must preserve ExtractedDataset's dimensions. InputData = new double[ExtractedDataset.Rows.Count][]; OutputData = new int[ExtractedDataset.Rows.Count]; // Except for the output column, columns' types are changed to // double type (classifiers work with numbers, not with strings). foreach (DataColumn column in ExtractedDataset.Columns) { if (column.ColumnName != attributeToPredict) { InputColumnNames.Add(column.ColumnName); ProcessedDataset.Columns[column.Ordinal].DataType = typeof(double); } else { OutputColumnName = column.ColumnName; } } try { // Temporary variables. double tempValue = 0; DataRow processedRow = null; List <double> tempInput = null; for (int row = 0; row < ExtractedDataset.Rows.Count; ++row) { // Process one row at time. processedRow = ProcessedDataset.NewRow(); tempInput = new List <double>(); foreach (DataColumn column in ExtractedDataset.Columns) { if (column.ColumnName != attributeToPredict) { Double.TryParse( ExtractedDataset.Rows[row][column.Ordinal] as string, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out tempValue); // Create a row of numeric values to be // added to ProcessedDataset and InputData. processedRow[column.Ordinal] = tempValue; tempInput.Add(tempValue); } else { // Don't convert the output column to a number yet, just copy the string // value (conversion to number will be done later by CodeBook). processedRow[column.Ordinal] = ExtractedDataset.Rows[row][column.Ordinal]; } } // Add/fill a row in ProcessedDataset and InputData // before going to next row. ProcessedDataset.Rows.Add(processedRow); InputData[row] = tempInput.ToArray(); } if (codeBook != null) { // Use given codebook (codebook should be given only when dealing // with testing datasets, in order to have the same codebook both // for training and for testing data). this.CodeBook = codeBook; } else { // If no codebook is given, create one for the output column. CodeBook = new Codification(ExtractedDataset, attributeToPredict); } // Apply codebook to the ProcessedDataset. ProcessedDataset = CodeBook.Apply(ProcessedDataset); // InputData is already set, OutputData is set to be the output // column codified with the codebook. OutputData = ProcessedDataset.ToArray <int>(attributeToPredict); // Number of input columns. InputAttributeNumber = ExtractedDataset.Columns.Count - 1; // Number of possible values the output column may assume. OutputPossibleValues = CodeBook[attributeToPredict].Symbols; } catch { return(false); } return(true); }
public static void ClearStaleEntries(CodeBook[,] cbs) { //閾値は5秒 long staleThresh = 5 * 10 ^ 7; foreach (CodeBook cb in cbs) { for (int i = 0; i < cb.Entries.Count; i++) { CodeElement e = (CodeElement)cb.Entries[i]; if (e.Stale > staleThresh) { cb.Entries.RemoveAt(i); } } } }
public static CodeBook[,] CreateCodeBook(Image<Hsv, byte> image) { CodeBook[,] codebooks = new CodeBook[image.Height, image.Width]; for (int i = 0; i < image.Height; i++) { for (int j = 0; j < image.Width; j++) { codebooks[i, j] = new CodeBook(); } } return codebooks; }
public static int UpdateCodeBook(byte[] p, CodeBook cb) { cb.Ticks = Time; byte[] high, low; high = new byte[3]; low = new byte[3]; for (int i = 0; i < 3; i++) { high[i] = (byte)((p[i] + 10 > 255) ? 255 : (p[i] + 10)); low[i] = (byte)((p[i] - 10 < 0) ? 0 : (p[i] - 10)); } int matchChannel; int matchedIndex = 0; for (int i = 0; i < cb.Entries.Count; i++) { matchChannel = 0; CodeElement e = (CodeElement)cb.Entries[i]; for (int k = 0; k < 3; k++) { if (e.learnLow[k] <= p[k] && e.learnHigh[k] >= p[k]) { matchChannel++; } } if (matchChannel == 3) { e.LastUpdate = cb.Ticks; for (int k = 0; k < 3; k++) { if (e.max[k] < p[k]) { e.max[k] = p[k]; } else if (e.min[k] > p[k]) { e.min[k] = p[k]; } if (e.learnHigh[k] < high[k]) { e.learnHigh[k] += 1; } if (e.learnLow[k] < low[k]) { e.learnLow[k] -= 1; } } matchedIndex = i; break; } if (i == cb.Entries.Count - 1) { matchedIndex = cb.Entries.Count; break; } } for (int s = 0; s < cb.Entries.Count; s++) { CodeElement e = (CodeElement)cb.Entries[s]; long negRun = cb.Ticks - e.LastUpdate; if (e.Stale < negRun) { e.Stale = negRun; } } if (matchedIndex == cb.Entries.Count) { CodeElement enew = new CodeElement(); for (int k = 0; k < 3; k++) { enew.learnHigh[k] = high[k]; enew.learnLow[k] = low[k]; enew.max[k] = p[k]; enew.min[k] = p[k]; } enew.LastUpdate = cb.Ticks; enew.Stale = 0; cb.Entries.Add(enew); } return(matchedIndex); }
public static void UpdateCodeBooks(Image<Hsv, byte> image, CodeBook[,] codebooks) { if (image.Height == codebooks.GetLength(0) && image.Width == codebooks.GetLength(1)) { throw new ArgumentException("InvalidArgument"); } for (int i = 0; i < image.Height; i++) { for (int j = 0; j < image.Width; j++) { Hsv p = image[i, j]; UpdateCodeBook(new byte[3] { (byte)p.Hue, (byte)p.Satuation, (byte)p.Value }, codebooks[i, j]); } } }
public static LookupCollection Create(VorbisInfo info) { var codecSetup = info.CodecSetup; var psyGlobal = new PsyGlobalLookup(codecSetup.PsyGlobalParam); var envelope = new EnvelopeLookup(codecSetup.PsyGlobalParam, info); // MDCT is tranform 0 var transform = new MdctLookup[2]; transform[0] = new MdctLookup(codecSetup.BlockSizes[0]); transform[1] = new MdctLookup(codecSetup.BlockSizes[1]); // analysis always needs an fft var fftLookup = new DrftLookup[2]; fftLookup[0] = new DrftLookup(codecSetup.BlockSizes[0]); fftLookup[1] = new DrftLookup(codecSetup.BlockSizes[1]); // finish the codebooks if (codecSetup.FullBooks == null) { codecSetup.FullBooks = new CodeBook[codecSetup.BookParams.Count]; for (var i = 0; i < codecSetup.BookParams.Count; i++) { codecSetup.FullBooks[i] = CodeBook.InitEncode(codecSetup.BookParams[i]); } } var psyLookup = new PsyLookup[codecSetup.PsyParams.Count]; for (var i = 0; i < psyLookup.Length; i++) { psyLookup[i] = new PsyLookup( codecSetup.PsyParams[i], codecSetup.PsyGlobalParam, codecSetup.BlockSizes[codecSetup.PsyParams[i].BlockFlag] / 2, info.SampleRate); } // initialize all the backend lookups var floor = new FloorLookup[codecSetup.FloorParams.Count]; for (var i = 0; i < floor.Length; i++) { floor[i] = new FloorLookup(codecSetup.FloorParams[i]); } var residue = new ResidueLookup[codecSetup.ResidueParams.Count]; for (var i = 0; i < residue.Length; i++) { residue[i] = new ResidueLookup(codecSetup.ResidueParams[i], new List <CodeBook>(codecSetup.FullBooks)); } return(new LookupCollection( envelope, new List <MdctLookup>(transform), psyGlobal, new List <PsyLookup>(psyLookup), new List <DrftLookup>(fftLookup), new List <FloorLookup>(floor), new List <ResidueLookup>(residue))); }
private static int LocalBookBestError(CodeBook book, int[] vec, int offset) { int i; int o; var ze = book.QuantValues >> 1; var index = 0; // assumes integer/centered encoder codebook maptype 1 no more than dim 8 var p = new int[8]; if (book.Delta != 1) { for (i = 0, o = book.Dimensions; i < book.Dimensions; i++) { var v = (vec[offset + --o] - book.MinVal + (book.Delta >> 1)) / book.Delta; var m = v < ze ? ((ze - v) << 1) - 1 : (v - ze) << 1; index = index * book.QuantValues + (m < 0 ? 0 : (m >= book.QuantValues ? book.QuantValues - 1 : m)); p[o] = v * book.Delta + book.MinVal; } } else { for (i = 0, o = book.Dimensions; i < book.Dimensions; i++) { var v = vec[offset + --o] - book.MinVal; var m = v < ze ? ((ze - v) << 1) - 1 : (v - ze) << 1; index = index * book.QuantValues + (m < 0 ? 0 : (m >= book.QuantValues ? book.QuantValues - 1 : m)); p[o] = v * book.Delta + book.MinVal; } } if (book.StaticBook.LengthList[index] <= 0) { // assumes integer/centered encoder codebook maptype 1 no more than dim 8 var best = -1; var e = new int[8]; var maxval = book.MinVal + book.Delta * (book.QuantValues - 1); for (i = 0; i < book.Entries; i++) { if (book.StaticBook.LengthList[i] > 0) { var current = 0; for (var j = 0; j < book.Dimensions; j++) { var val = e[j] - vec[offset + j]; current += val * val; } if ((best == -1) || (current < best)) { for (var x = 0; x < e.Length; x++) { p[x] = e[x]; } best = current; index = i; } } // assumes the value patterning created by the tools in vq var l = 0; while (e[l] >= maxval) { e[l++] = 0; } if (e[l] >= 0) { e[l] += book.Delta; } e[l] = -e[l]; } } if (index > -1) { for (i = 0; i < book.Dimensions; i++) { vec[offset++] -= p[i]; } } return(index); }
public static int UpdateCodeBook(byte[] p, CodeBook cb) { cb.Ticks = Time; byte[] high, low; high = new byte[3]; low = new byte[3]; for (int i = 0; i < 3; i++) { high[i] = (byte)((p[i] + 10 > 255) ? 255 : (p[i] + 10)); low[i] = (byte)((p[i] - 10 < 0) ? 0 : (p[i] - 10)); } int matchChannel; int matchedIndex = 0; for (int i = 0; i < cb.Entries.Count; i++) { matchChannel = 0; CodeElement e = (CodeElement)cb.Entries[i]; for (int k = 0; k < 3; k++) { if (e.learnLow[k] <= p[k] && e.learnHigh[k] >= p[k]) { matchChannel++; } } if (matchChannel == 3) { e.LastUpdate = cb.Ticks; for (int k = 0; k < 3; k++) { if (e.max[k] < p[k]) { e.max[k] = p[k]; } else if (e.min[k] > p[k]) { e.min[k] = p[k]; } if (e.learnHigh[k] < high[k]) e.learnHigh[k] += 1; if (e.learnLow[k] < low[k]) e.learnLow[k] -= 1; } matchedIndex = i; break; } if (i == cb.Entries.Count - 1) { matchedIndex = cb.Entries.Count; break; } } for (int s = 0; s < cb.Entries.Count; s++) { CodeElement e = (CodeElement)cb.Entries[s]; long negRun = cb.Ticks - e.LastUpdate; if (e.Stale < negRun) { e.Stale = negRun; } } if (matchedIndex == cb.Entries.Count) { CodeElement enew = new CodeElement(); for (int k = 0; k < 3; k++) { enew.learnHigh[k] = high[k]; enew.learnLow[k] = low[k]; enew.max[k] = p[k]; enew.min[k] = p[k]; } enew.LastUpdate = cb.Ticks; enew.Stale = 0; cb.Entries.Add(enew); } return matchedIndex; }