public static LabeledImage[] Subset(int Rows, LabeledImage[] Images, int SubsetSize)
{
var ImagesByLabel = OrganizeByLabel(Rows, Images);
var LeadSet = new LabeledImage[SubsetSize];
int count = 0;
byte label = 0;
while (count < SubsetSize)
{
var image = ImagesByLabel[label].Last();
LeadSet[count] = image;
ImagesByLabel[label].Remove(image);
count++; label++;
if (label >= NumLabels)
{
label = 0;
}
}
Debug.Assert(ImagesByLabel.Sum(pair => pair.Value.Count) == Rows - SubsetSize);
return(Shuffle(LeadSet));
}
public static LabeledImage[] Init()
{
// Read label meta file.
var LabelNames = File.ReadAllLines(Path.Combine(TrainingDataDir, LabelFile));
// Read training data.
var bytes = File.ReadAllBytes(Path.Combine(TrainingDataDir, FileName));
Debug.Assert(bytes.Length == Rows * RowSize);
// Unpack training data.
LabeledImage[] images = new LabeledImage[Rows];
var source_index = 0;
for (int row = 0; row < Rows; row++)
{
var image = images[row] = new LabeledImage();
var pixels = image.Pixels = new float[Width, Height, 3];
image.Label = bytes[source_index++];
for (int channel = 0; channel < 3; channel++)
{
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
pixels[x, y, channel] = bytes[source_index++] / 255f;
}
}
}
//// Swap out source images for derivatives.
//var diff = new float[Width, Height, 3];
//for (int x = 0; x < Width; x++)
//for (int y = 0; y < Height; y++)
//{
// diff[x, y, 0] = .33333f * (pixels[x, y, 0] + pixels[x, y, 0] + pixels[x, y, 0]);
// diff[x, y, 1] = 0;
// diff[x, y, 2] = 0;
//}
//for (int x = 1; x < Width - 1; x++)
//for (int y = 1; y < Height - 1; y++)
//{
// diff[x, y, 1] = 10 * (pixels[x + 1, y, 0] - pixels[x, y, 0]);
// diff[x, y, 2] = 10 * (pixels[x, y + 1, 0] - pixels[x, y, 0]);
//}
//for (int x = 0; x < Width; x++)
//for (int y = 0; y < Height; y++)
//{
// diff[x, y, 0] = 0;
//}
//images[row].Pixels = diff;
}
Debug.Assert(source_index == Rows * RowSize);
return(images);
}
void ProcessLabeledImage(LabeledImage labeledImage)
{
ProcessedImageServer labeledAvImage = new ProcessedImageServer(labeledImage.Name,
labeledImage.Label,
labeledImage.ByteImage);
_dispatcher.Post(() =>
{
Task t = new Task(() =>
{
ProcessedImageCollection.Add(labeledAvImage);
_databaseMailbox.Post(labeledAvImage);
_processedImagesAmount++;
_addedNewProcessedImage.Set();
Console.Write($"[Ready {_processedImagesAmount}/{_newImagesAmount}]");
Console.WriteLine($" Image <{labeledAvImage.Name}> added into Database.");
if (_processedImagesAmount == _newImagesAmount)
{
_dispatcherCompletionEvent.Set();
}
});
t.Start();
return(t);
});
}
public static LabeledImage[] Remainder(LabeledImage[] FullSet, LabeledImage[] OtherSet)
{
LabeledImage[] RemainderSet = new LabeledImage[FullSet.Length - OtherSet.Length];
int index = 0;
foreach (var image in FullSet)
{
if (!OtherSet.Contains(image))
{
RemainderSet[index++] = image;
}
}
return(Shuffle(RemainderSet));
}
private void GetImg(LabeledImage j)
{
var img = new Image {
Source = j.imagen
};
var lbl = new TextBlock {
Text = j.titulo, FontSize = 11
};
var pnl = new StackPanel {
Children = { img, lbl }
};
var bl = new BlockUIContainer(pnl);
_fltImages.Blocks.Add(bl);
Rsze();
_imgAdjust += pnl.ActualHeight + 80;
}
public static LabeledImage[] SampleSet(int Rows, LabeledImage[] Images, int InLabel, int SampleSize, int InLabelSize)
{
var LeadSet = new LabeledImage[SampleSize];
int lead_index = 0, source_index = rnd.Next(0, Rows);
while (lead_index < SampleSize)
{
source_index++; if (source_index >= Rows)
{
source_index = 0;
}
if (lead_index < InLabelSize && Images[source_index].Label == InLabel ||
lead_index >= InLabelSize && Images[source_index].Label != InLabel)
{
LeadSet[lead_index] = Images[source_index];
lead_index++;
}
}
return(LeadSet);
}
public void ProcessResults(LabeledImage image)
{
Console.WriteLine(image.ToString());
}
/// <summary>
/// Classifies each point from <paramref name="image"/> and trackes which nodes it visits.
/// </summary>
/// <param name="tree">The tree used for the computation</param>
/// <param name="image">Image to add to the tree</param>
/// <param name="mode">Mode to use when sampling the image</param>
public static void Fill <T>(this DecisionTree <ImageDataPoint <T>, T[]> tree, LabeledImage <T> image, BackgroundSampleMode mode)
{
List <ImageDataPoint <T> > points = image.CreateAllDataPoints(mode);
tree.Fill(points);
}
/// <summary>
/// Classifies every pixel in the provided image, returning a full distribution over all labels.
/// </summary>
/// <param name="forest">The forest used for the computation</param>
/// <param name="image">Image to classify</param>
/// <returns>The classified image</returns>
public static DistributionImage ClassifySoft <T>(this DecisionForest <ImageDataPoint <T>, T[]> forest, LabeledImage <T> image)
{
DistributionImage dist = new DistributionImage(image.Image.Rows, image.Image.Columns, forest.LabelCount);
dist.ID = image.ID;
for (int t = 0; t < forest.TreeCount; t++)
{
forest[t].ClassifySoft(image, dist);
}
dist.DivideThrough(forest.TreeCount);
dist.Normalize();
return(dist);
}
/// <summary>
/// Computes a histogram for all trees from the provided image.
/// </summary>
/// <param name="forest">The forest used for the computation</param>
/// <param name="image">Image to classify</param>
/// <returns>The histogram</returns>
public static TreeHistogram ComputeHistogram <T>(this DecisionForest <ImageDataPoint <T>, T[]> forest, LabeledImage <T> image)
{
return(forest.ComputeHistogram(image.CreateAllDataPoints(BackgroundSampleMode.Full)));
}
/// <summary>
/// Adds the data from <paramref name="image"/> to each tree in the forest.
/// </summary>
/// <param name="forest">The forest used for the computation</param>
/// <param name="image">Image to learn from</param>
/// <param name="mode">Mode to use when sampling the image background</param>
public static void Fill <T>(this DecisionForest <ImageDataPoint <T>, T[]> forest, LabeledImage <T> image, BackgroundSampleMode mode)
{
for (int i = 0; i < forest.TreeCount; i++)
{
forest[i].Fill(image, mode);
}
forest.RefreshMetadata();
}
/// <summary>
/// Classifies points from <paramref name="labeledImage"/> (using the mask if present) and adds the distributions at each pixel to <paramref name="dist"/>.
/// </summary>
/// <param name="tree">The tree used for the computation</param>
/// <param name="labeledImage">The image to classify</param>
/// <param name="dist">Image which is used to store the distributions</param>
public static void ClassifySoft <T>(this DecisionTree <ImageDataPoint <T>, T[]> tree, LabeledImage <T> labeledImage, DistributionImage dist)
{
List <ImageDataPoint <T> > points = labeledImage.CreateAllDataPoints(BackgroundSampleMode.Full);
List <int> indices = new List <int>();
for (int i = 0; i < points.Count; i++)
{
indices.Add(i);
}
INodeInfo <ImageDataPoint <T>, T[]>[] info = new INodeInfo <ImageDataPoint <T>, T[]> [points.Count];
DecisionTree <ImageDataPoint <T>, T[]> .assignLabels(tree._root, points, info, indices);
for (int i = 0; i < info.Length; i++)
{
dist.Add(points[i].Row, points[i].Column, info[i].Distribution);
}
}
private static void PrintLogs(LabeledImage img)
{
System.Console.WriteLine(img.Name + " " + img.Label);
}
public BlockedImage(LabeledImage image)
{
this.Pixels = image.Pixels;
this.Label = image.Label;
}
