public bool FitsInto(SegmentedRegion destRegion, SegmentOffset destOffset, int acceptableCollisions)
{
int collisions = 0;
// For every segment within this "source" region, check to see if
// each can be placed in its relative location in the destRegion.
foreach (SegmentOffset offset in this.segments.Keys)
{
SegmentOffset adjusted = new SegmentOffset(destOffset.xOffset + offset.xOffset, destOffset.yOffset + offset.yOffset);
if (destRegion.segments.ContainsKey(adjusted))
{
ProcessingWindow segment = (ProcessingWindow)destRegion.segments[adjusted][0];
if (segment.filled)
{
if (++collisions >= acceptableCollisions)
{
return(false);
}
}
}
else
{
return(false);
}
}
return(true);
}
public bool AttemptIncorporation(SegmentedRegion toBeIncorporated)
{
System.Random rand = new Random();
double percentageCollisionsToAllow = 0.10 + (rand.Next(0, 3) / 100.0);
int acceptableCollisions = (int)(toBeIncorporated.segments.Count * percentageCollisionsToAllow); // random segment segment collision is OK
for (int y = 0; y < this.MaxYOffset; y++)
{
for (int x = 0; x < this.MaxXOffset; x++)
{
SegmentOffset offset = new SegmentOffset(x, y);
if (toBeIncorporated.FitsInto(this, offset, acceptableCollisions))
{
this.Incorporate(toBeIncorporated, offset);
//System.Console.WriteLine("Region fits at location: " + offset.xOffset * toBeIncorporated.segWidth + ", " + offset.yOffset * toBeIncorporated.segHeight);
return(true);
}
}
}
return(false);
}
public void Incorporate(SegmentedRegion toBeIncorporated, SegmentOffset absoluteOffset)
{
foreach (SegmentOffset relativeOffset in toBeIncorporated.segments.Keys)
{
SegmentOffset windowOffset = new SegmentOffset(absoluteOffset.xOffset + relativeOffset.xOffset, absoluteOffset.yOffset + relativeOffset.yOffset);
// RSM: Changed to support dictionary segments!!!
//ProcessingWindow segment = (ProcessingWindow)toBeIncorporated.segments[relativeOffset];
//segment.filled = true;
//AddSegment(segment, windowOffset);
foreach (ProcessingWindow segment in toBeIncorporated.segments[relativeOffset])
{
segment.filled = true;
AddSegment(segment, windowOffset);
}
}
}
public SegmentedRegion AboveAverageSegments()
{
Hashtable scores = new Hashtable();
int accumulator = 0;
foreach (SegmentOffset offset in this.segments.Keys)
{
ProcessingWindow segment = (ProcessingWindow)this.segments[offset][0];
int maxY = segment.y + segment.Height;
int maxX = segment.x + segment.Width;
int segmentScore = 0;
for (int y = segment.y; y < maxY; y++)
{
for (int x = segment.x; x < maxX; x++)
{
//if (segment.sourceImage.data[y][x].R == 0)
if (segment.sourceImage.GetColor(x, y).R == 0)
{
segmentScore++;
}
}
}
accumulator += segmentScore;
ArrayList list = null;
if (scores.ContainsKey(segmentScore))
{
list = (ArrayList)scores[segmentScore];
}
else
{
list = new ArrayList();
scores[segmentScore] = list;
}
OffsetSegmentPair pair = new OffsetSegmentPair();
pair.offset = offset;
pair.segment = segment;
list.Add(pair);
}
// Determine the average across all segments
double average = accumulator / this.segments.Keys.Count;
SegmentedRegion result = new SegmentedRegion(this.segWidth, this.segHeight, this.Width, this.Height);
foreach (int score in scores.Keys)
{
if (score > average)
{
ArrayList list = (ArrayList)scores[score];
foreach (OffsetSegmentPair pair in list)
{
result.AddSegment(pair.segment, pair.offset);
}
}
}
return(result);
}
