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));
}
