private Region GetBiggest(Dictionary <object, object> cache, int start, int end)
{
List <object> matches = new List <object>();
foreach (object key in cache.Keys)
{
if (key is RegionParameters)
{
RegionParameters r = (RegionParameters)key;
if (r.Start == start && r.End == end)
{
matches.Add(r);
}
}
}
RegionParameters max = null;
foreach (object match in matches)
{
RegionParameters m = (RegionParameters)match;
if (max == null || m.Depth > max.Depth)
{
max = m;
}
}
if (max != null)
{
return((Region)cache[max]);
}
return(null);
}
public static bool RegionDepthLessThanWidth(object v1, object v2)
{
Tuple <Size, RegionParameters> pair = GetFromValues(v1, v2);
Size size = pair.Item1;
RegionParameters parameters = pair.Item2;
return(parameters.Depth < size.Width);
}
public static bool RegionDepthEqualsHeight(object v1, object v2)
{
Tuple <Size, RegionParameters> pair = GetFromValues(v1, v2);
Size size = pair.Item1;
RegionParameters parameters = pair.Item2;
return(size.Height == parameters.Depth);
}
public static bool RegionStartEqualsHeight(object v1, object v2)
{
Tuple <Size, RegionParameters> pair = GetFromValues(v1, v2);
Size rect = (Size)pair.Item1;
RegionParameters parameters = pair.Item2;
return(rect.Height == parameters.Start);
}
public static bool RegionEndEqualsWidth(object v1, object v2)
{
Tuple <Size, RegionParameters> pair = GetFromValues(v1, v2);
Size size = pair.Item1;
RegionParameters parameters = pair.Item2;
return(parameters.End == size.Width);
}
public static bool DepthIsSmallWidth(object v1, object v2)
{
Tuple <Size, RegionParameters> pair = GetFromValues(v1, v2);
Size size = pair.Item1;
RegionParameters parameters = pair.Item2;
return(size.Width == 0 || parameters.Depth <= size.Width);
}
public static Tuple <Size, RegionParameters> GetFromValues(object v1, object v2)
{
Size size = v1 as Size;
RegionParameters parameters = v2 as RegionParameters;
if (size == null)
{
size = v2 as Size;
parameters = v1 as RegionParameters;
}
return(new Tuple <Size, RegionParameters>(size, parameters));
}
private ArrayList GetEdgeValues(List <string> types, RegionParameters min, RegionParameters max)
{
ArrayList values = new ArrayList();
foreach (string type in types)
{
for (int depth = min.Depth; depth <= max.Depth; depth++)
{
for (int left = min.Start; left <= max.Start; left++)
{
for (int right = min.End; right <= max.End; right++)
{
object value = new RegionParameters(type, left, right, depth);
values.Add(value);
}
}
}
}
return(values);
}
public static bool RegionStartEqualsEnd(object v1, object v2)
{
RegionParameters r1 = (RegionParameters)v1;
return(r1.Start == 0 || r1.End == 0 || r1.Start == r1.End);
}
public Dictionary <string, Part> GetParts(IEnumerable <Bitmap> positives, IEnumerable <Bitmap> negatives)
{
Dictionary <string, Part> parts = new Dictionary <string, Part>();
List <string> edgetypes = new List <string>()
{
"repeating"
};
ArrayList interiortypes = new ArrayList {
"horizontal", "vertical", "single"
};
RegionParameters minhoriz = new RegionParameters(null, c_minCornerSize, c_minCornerSize, 1);
RegionParameters maxhoriz = new RegionParameters(null, c_maxCornerSize, c_maxCornerSize, c_maxCornerSize);
RegionParameters minvert = new RegionParameters(null, c_minCornerSize, c_minCornerSize, 1);
RegionParameters maxvert = new RegionParameters(null, c_maxCornerSize, c_maxCornerSize, c_maxCornerSize);
int smallestWidth = int.MaxValue;
int smallestHeight = int.MaxValue;
foreach (Bitmap example in positives)
{
if (example.Width < smallestWidth)
{
smallestWidth = example.Width;
}
if (example.Height < smallestHeight)
{
smallestHeight = example.Height;
}
}
smallestHeight -= 2;
smallestWidth -= 2;
maxhoriz.Depth = (int)Math.Min(smallestHeight / 2, maxhoriz.Depth);
maxhoriz.Start = (int)Math.Min(smallestWidth / 2, maxhoriz.Start);
maxhoriz.End = (int)Math.Min(smallestWidth / 2, maxhoriz.End);
maxvert.Depth = (int)Math.Min(smallestWidth / 2, maxvert.Depth);
maxvert.Start = (int)Math.Min(smallestHeight / 2, maxvert.Start);
maxvert.End = (int)Math.Min(smallestHeight / 2, maxvert.End);
parts.Add("topleft", new Part(GetCornerValues(smallestWidth, smallestHeight)));
parts.Add("topright", new Part(GetCornerValues(smallestWidth, smallestHeight)));
parts.Add("bottomleft", new Part(GetCornerValues(smallestWidth, smallestHeight)));
parts.Add("bottomright", new Part(GetCornerValues(smallestWidth, smallestHeight)));
parts.Add("top", new Part(GetEdgeValues(edgetypes, minhoriz, maxhoriz)));
parts.Add("bottom", new Part(GetEdgeValues(edgetypes, minhoriz, maxhoriz)));
parts.Add("left", new Part(GetEdgeValues(edgetypes, minvert, maxvert)));
parts.Add("right", new Part(GetEdgeValues(edgetypes, minvert, maxvert)));
parts.Add("interior", new Part(interiortypes));
return(parts);
}
/// <summary>
/// Uses the assigned value to a part to parameterize that part from examples.
/// It caches the parameterizations, and checks the cache to see if it has
/// made the parameterization beforeache.
/// </summary>
/// <param name="name">Name of the part to parameterize.</param>
/// <param name="value">The part's value.</param>
/// <param name="assignment">The whole assignment.</param>
/// <param name="positives">Positive examples</param>
/// <param name="negatives">Negative examples</param>
/// <param name="cache">The cache foreach storing parameterizations to check foreach subsequent calls.</param>
/// <returns>The parameterized part (either a feature or region)</returns>
public static object ExtractPart(string name, object value,
Dictionary <string, Part> assignment, IEnumerable <Bitmap> positives, IEnumerable <Bitmap> negatives, Dictionary <object, object> cache)
{
//Look in our cache to see if we extracted the part beforeache
object extracted = null;
Size size = null;
RegionParameters rps = null;
BackgroundValue bv = null;
if (value is Size)
{
size = (Size)value;
}
else if (value is RegionParameters)
{
rps = (RegionParameters)value;
}
else if (value is string)
{
bv = GetBackgroundValue((String)value, assignment);
value = bv;
}
Tuple <string, object> key = new Tuple <string, object>(name, value);
if (!cache.ContainsKey(key))
{
switch (name)
{
case "topleft":
extracted = CropFromManyRelativeTopLeft(0, 0, size.Width, size.Height, positives);
break;
case "bottomleft":
extracted = CropFromManyRelativeBottomLeft(size.Height, 0, size.Width, size.Height, positives);
break;
case "topright":
extracted = CropFromManyRelativeTopRight(0, size.Width, size.Width, size.Height, positives);
break;
case "bottomright":
extracted = CropFromManyRelativeBottomRight(size.Height, size.Width, size.Width, size.Height, positives);
break;
case "top":
extracted = GetHorizontal(true, rps.Start, rps.End, rps.Depth, positives);
break;
case "bottom":
extracted = GetHorizontal(false, rps.Start, rps.End, rps.Depth, positives);
break;
case "left":
extracted = GetVertical(true, rps.Start, rps.End, rps.Depth, positives);
break;
case "right":
extracted = GetVertical(false, rps.Start, rps.End, rps.Depth, positives);
break;
case "interior":
extracted = GetInterior(bv, positives);
break;
}
//Features that have all one value are likely to be background. So we disallow it.
//Features that are all transparent can't be found (obviously). So we disallow it.
if (extracted != null && extracted is Bitmap && (Bitmap.AllOneValue((Bitmap)extracted) || Bitmap.AllTransparent((Bitmap)extracted)))
{
extracted = null;
}
cache.Add(key, extracted);
}
else
{
extracted = cache[key];
}
return(extracted);
}
