public static byte[] Create(int size) { var bytes = new byte[size]; ThreadsafeRandom.NextBytes(bytes); return(bytes); }
/// <summary> /// Creates a new feature. /// </summary> /// <returns>An object which implements <see cref="T:IFeature" /></returns> public IFeature <T, float[]> Create() { int index1 = ThreadsafeRandom.Next(0, _length); int index2 = ThreadsafeRandom.Next(0, _length); while (index2 == index1) { index2 = ThreadsafeRandom.Next(0, _length); } switch (_combo) { case BinaryCombination.Add: return(new Add(index1, index2, _modifier)); case BinaryCombination.Divide: return(new Divide(index1, index2, _modifier)); case BinaryCombination.Log: return(new Log(index1, index2, _modifier)); case BinaryCombination.Multiply: return(new Multiply(index1, index2, _modifier)); case BinaryCombination.Subtract: default: return(new Subtract(index1, index2, _modifier)); } }
public IEnumerable <int> Receive(int minMessageCount, int maxMessageCount) { var returnedMessages = ThreadsafeRandom.Next(minMessageCount, maxMessageCount + 1); for (var i = 0; i < returnedMessages; i++) { yield return(i); } }
public static string CreateAlphanumeric(int length) { var buffer = new char[length]; for (var i = 0; i < length; i++) { buffer[i] = _alphanumeric[ThreadsafeRandom.Next(_alphanumeric.Length)]; } return(new string(buffer)); }
/// <summary> /// Creates a new feature. /// </summary> /// <returns>An object which implements <see cref="T:IFeature" /></returns> public IFeature <ImageDataPoint <float>, float[]> Create() { int row, column; row = ThreadsafeRandom.Next(-_boxRows, _boxRows); column = ThreadsafeRandom.Next(-_boxColumns, _boxColumns); int channel = ThreadsafeRandom.Next(0, _numChannels); return(new UnaryFeature(row, column, channel, _modifier)); }
/// <summary> /// Creates several splits of the dataset. /// </summary> /// <param name="sampleFrequency">How often to sample pixels within the training images.</param> /// <param name="boxRows">Vertical trim around the edges of images to avoid feature tests beyond the boundary of the image</param> /// <param name="boxColumns">Vertical trim around the edges of images to avoid feature tests beyond the boundary of the image</param> /// <param name="numSplits">Number of splits to create</param> /// <returns>Splits of the data</returns> public List <ImageDataPoint <T> >[] CreateDataPoints(int sampleFrequency, int boxRows, int boxColumns, int numSplits) { List <ImageDataPoint <T> > points = new List <ImageDataPoint <T> >(); foreach (LabeledImage <T> labelledImage in _images) { IMultichannelImage <T> image = labelledImage.Image; LabelImage labels = labelledImage.Labels; LabelSet set = labels.Labels; string id = labelledImage.ID; bool[,] valid = labelledImage.Valid; int maxRows = image.Rows - boxRows; int maxColumns = image.Columns - boxColumns; for (int r = boxRows; r < maxRows; r += sampleFrequency) { for (int c = boxColumns; c < maxColumns; c += sampleFrequency) { short label = getLabel(labels[r, c], set); bool sample = valid[r, c]; if (sample && label == LabelImage.BackgroundLabel) { switch (_backgroundSampleMode) { case BackgroundSampleMode.Ignore: sample = false; break; case BackgroundSampleMode.Half: sample = ThreadsafeRandom.Test(.5); break; } } if (sample) { points.Add(new ImageDataPoint <T>(image, (short)r, (short)c, label)); } } } } List <ImageDataPoint <T> >[] splits = new List <ImageDataPoint <T> > [numSplits]; for (int i = 0; i < numSplits; i++) { if (_byImage) { splits[i] = sampleByImage(points); } else { splits[i] = sample(points); } } return(splits); }
private List <ImageDataPoint <T> > sample(List <ImageDataPoint <T> > points) { List <ImageDataPoint <T> > result = new List <ImageDataPoint <T> >(); for (int i = 0; i < points.Count; i++) { if (ThreadsafeRandom.Test(_dataPercentage)) { result.Add(points[i]); } } return(result); }
/// <summary> /// Creates a new feature. /// </summary> /// <returns>An object which implements <see cref="T:IFeature" /></returns> public IFeature <ImageDataPoint <float>, float[]> Create() { int row = ThreadsafeRandom.Next(-BoxSize, BoxSize); int column = ThreadsafeRandom.Next(-BoxSize, BoxSize); int rows = ThreadsafeRandom.Next(1, MaxRows); int columns = ThreadsafeRandom.Next(1, MaxColumns); int channel = ThreadsafeRandom.Next(ChannelCount); return(new RectangleFeature(new Rectangle { R = row, C = column, Rows = rows, Columns = columns }, channel)); }
/// <summary> /// Computes the inverse label frequency array for the image. This is an array in which each index holds a value equal /// to the total number of image labels divided by the total number of that particular label. /// </summary> /// <param name="numLabels">Total number of labels</param> /// <returns>Inverse label frequency</returns> public unsafe float[] ComputeInverseLabelFrequency(int numLabels) { int[] counts = new int[numLabels]; foreach (LabeledImage <T> image in _images) { LabelImage labels = image.Labels; LabelSet set = labels.Labels; fixed(short *labelsSrc = labels.RawArray) { int count = labels.Rows * labels.Columns; short *labelsPtr = labelsSrc; while (count-- > 0) { short index = getLabel(*labelsPtr++, set); bool sample = true; if (index == LabelImage.BackgroundLabel) { switch (_backgroundSampleMode) { case BackgroundSampleMode.Ignore: sample = false; break; case BackgroundSampleMode.Half: sample = ThreadsafeRandom.Test(.5); break; } } if (!sample) { continue; } counts[index]++; } } } float[] frequency = new float[numLabels]; float sum = 0; for (short i = 0; i < frequency.Length; i++) { frequency[i] = 1 + counts[i]; sum += frequency[i]; } for (int i = 0; i < frequency.Length; i++) { frequency[i] = sum / frequency[i]; } return(frequency); }
/// <summary> /// Creates a new part feature. /// </summary> /// <returns>The part feature</returns> public IFeature <ImageDataPoint <float>, float[]> Create() { Part[] parts = new Part[_numParts]; for (int i = 0; i < _numParts; i++) { parts[i] = new Part( ThreadsafeRandom.Next(-_boxSize, _boxSize), ThreadsafeRandom.Next(-_boxSize, _boxSize), ThreadsafeRandom.Next(0, _numChannels), 1f - ThreadsafeRandom.NextFloat(2) ); } return(new PartFeature(parts)); }
private List <ImageDataPoint <T> > sampleByImage(List <ImageDataPoint <T> > points) { List <ImageDataPoint <T> > result = new List <ImageDataPoint <T> >(); var imageGroups = points.GroupBy(o => o.ImageID); foreach (var group in imageGroups) { if (ThreadsafeRandom.Test(_imagePercentage)) { result.AddRange(group.Where(o => ThreadsafeRandom.Test(_dataPercentage))); } } return(result); }
private short getLabel(short label, LabelSet labels) { switch (_supervisionMode) { case SupervisionMode.Full: return(label); case SupervisionMode.Part: return(labels.SelectRandom()); case SupervisionMode.None: return((short)ThreadsafeRandom.Next(20)); } return(0); }
private List <LabelVector> findCenterCandidates(object arg) { Job job = arg as Job; List <LabelVector> result = new List <LabelVector>(); double norm = OversampleRate / _phi; for (int i = job.StartIndex; i < job.EndIndex; i++) { LabelVector x = _data[i]; double sample = x.FeatureValue * norm; if (ThreadsafeRandom.Test(sample)) { LabelVector center = x.Clone() as LabelVector; result.Add(center); } } return(result); }
/// <summary> /// Creates a new feature. /// </summary> /// <returns>An object which implements <see cref="T:IFeature" /></returns> public IFeature <T, float[]> Create() { int index; if (_random) { index = ThreadsafeRandom.Next(0, _length); } else { index = _currentIndex++; if (_currentIndex == _length) { _currentIndex = 0; } } return(new UnaryFeature(index, _modifier)); }
private unsafe List <ImageDataPoint <T> > createAllDataPointsLabels(BackgroundSampleMode mode) { List <ImageDataPoint <T> > points = new List <ImageDataPoint <T> >(); int rows = _image.Rows; int columns = _image.Columns; LabelSet set = _labels.Labels; fixed(short *labelsSrc = _labels.RawArray) { fixed(bool *validSrc = _valid) { short *labelsPtr = labelsSrc; bool * validPtr = validSrc; for (short r = 0; r < rows; r++) { for (short c = 0; c < columns; c++) { short label = getLabel(*labelsPtr++, set); bool sample = *validPtr++; if (sample && label == LabelImage.BackgroundLabel) { switch (mode) { case BackgroundSampleMode.Ignore: sample = false; break; case BackgroundSampleMode.Half: sample = ThreadsafeRandom.Test(.5); break; } } if (sample) { points.Add(new ImageDataPoint <T>(_image, r, c, label)); } } } } } return(points); }
private static void Run(IReadOnlyList <string> Arguments) { (string inputFilename, string xPath, ParsingTechnique ? parsingTechnique, string outputFilename, int?fileSizeMb) = ParseCommandLine(Arguments); IThreadsafeRandom random = new ThreadsafeRandom(); Stopwatch stopwatch = Stopwatch.StartNew(); if (inputFilename != null) { IParser parser = GetParser(parsingTechnique.Value); int nodes = parser.CountNodes(inputFilename, xPath); stopwatch.Stop(); fileSizeMb = (int?)((new FileInfo(inputFilename)).Length / (1024d * 1024d)); Console.WriteLine($"Found {nodes} nodes."); Console.WriteLine($"Parsing of {fileSizeMb.Value} MB file took {stopwatch.Elapsed.TotalSeconds:0.000} seconds."); } if (outputFilename != null) { XmlGenerator xmlGenerator = new XmlGenerator(random); xmlGenerator.CreateFile(outputFilename, fileSizeMb.Value); stopwatch.Stop(); Console.WriteLine($"Creation of {fileSizeMb.Value} MB file took {stopwatch.Elapsed.TotalSeconds:0.000} seconds."); } }
/// <summary> /// Creates a new feature. /// </summary> /// <returns>An object which implements <see cref="T:IFeature" /></returns> public IFeature <ImageDataPoint <float>, float[]> Create() { int index = ThreadsafeRandom.Next(0, HaarFeatures.FEATURES.Length); Rectangle[] rectangles = HaarFeatures.FEATURES[index]; int[] channels = new int[rectangles.Length]; if (_mixChannels) { for (int i = 0; i < channels.Length; i++) { channels[i] = ThreadsafeRandom.Next(0, _numChannels); } } else { int channel = ThreadsafeRandom.Next(0, _numChannels); for (int i = 0; i < channels.Length; i++) { channels[i] = channel; } } return(new HaarFeature(HaarFeatures.FEATURES[index], channels)); }
/// <summary> /// Creates a new feature. /// </summary> /// <returns>An object which implements <see cref="T:IFeature" /></returns> public IFeature <ImageDataPoint <float>, float[]> Create() { int row1, row2, column1, column2, channel1, channel2; row1 = randomRow(); row2 = randomRow(); column1 = randomColumn(); column2 = randomColumn(); channel1 = ThreadsafeRandom.Next(0, _numChannels); if (_mixChannels) { channel2 = ThreadsafeRandom.Next(0, _numChannels); } else { channel2 = channel1; } switch (_combo) { case BinaryCombination.Add: return(new Add(row1, column1, channel1, row2, column2, channel2, _modifier)); case BinaryCombination.Divide: return(new Divide(row1, column1, channel1, row2, column2, channel2, _modifier)); case BinaryCombination.Log: return(new Log(row1, column1, channel1, row2, column2, channel2, _modifier)); case BinaryCombination.Multiply: return(new Multiply(row1, column1, channel1, row2, column2, channel2, _modifier)); case BinaryCombination.Subtract: default: return(new Subtract(row1, column1, channel1, row2, column2, channel2, _modifier)); } }
private int randomRow() { return(ThreadsafeRandom.Next(-_boxRows, _boxRows)); }
private int randomColumn() { return(ThreadsafeRandom.Next(-_boxColumns, _boxColumns)); }