/**
* Find the the union of this rectangle and the passed rectangle.
* Neither rectangle is altered
*
* @param r The rectangle to union with this rectangle
*/
internal Rectangle union(Rectangle r)
{
Rectangle union = this.copy();
union.add(r);
return union;
}
public void ExecuteIntersectionQuery(SharpMap.Geometries.BoundingBox box, SharpMap.Data.FeatureDataSet ds)
{
Rectangle r = new Rectangle((float)box.Left, (float)box.Bottom, (float)box.Right, (float)box.Top, (float)0.0, (float)0.0);
FdoFeature[] matches = _data.Intersects(r);
FeatureDataTable table = new FeatureDataTable();
foreach (DataColumn col in _data.Columns)
{
table.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
//Filter the initial result set by inverting the operands. This weeds out non-matches on point intersection tests.
IEnvelope env = Converter.EnvelopeFromBoundingBox(box);
FdoGeometry poly = new FdoGeometry(Converter.CreatePolygonFromEnvelope(env));
foreach (FdoFeature feat in matches)
{
FdoGeometry geom = feat.DesignatedGeometry;
if (geom != null)
{
if (geom.Contains(env) || geom.Intersects(poly))
{
FeatureDataRow row = table.NewRow();
bool add = true;
foreach (DataColumn col in _data.Columns)
{
if (col.ColumnName == _data.GeometryColumn)
{
try
{
row.Geometry = Converter.FromFdoGeometry(geom, _geomFactory);
}
catch //Can't help you if you fail conversion.
{
add = false;
}
}
else
{
row[col.ColumnName] = feat[col.ColumnName];
}
}
if (add)
table.AddRow(row);
}
}
}
ds.Tables.Add(table);
}
/**
* Calculate the area by which this rectangle would be enlarged if
* added to the passed rectangle. Neither rectangle is altered.
*
* @param r Rectangle to union with this rectangle, in order to
* compute the difference in area of the union and the
* original rectangle
*/
internal float enlargement(Rectangle r)
{
float enlargedArea = (Math.Max(max[0], r.max[0]) - Math.Min(min[0], r.min[0])) *
(Math.Max(max[1], r.max[1]) - Math.Min(min[1], r.min[1]));
return enlargedArea - area();
}
/**
* Computes the union of this rectangle and the passed rectangle, storing
* the result in this rectangle.
*
* @param r Rectangle to add to this rectangle
*/
internal void add(Rectangle r)
{
for (int i = 0; i < DIMENSIONS; i++)
{
if (r.min[i] < min[i])
{
min[i] = r.min[i];
}
if (r.max[i] > max[i])
{
max[i] = r.max[i];
}
}
}
/**
* Return the furthst possible distance between this rectangle and
* the passed rectangle.
*
* Find the distance between this rectangle and each corner of the
* passed rectangle, and use the maximum.
*
*/
internal float furthestDistance(Rectangle r)
{
float distanceSquared = 0;
for (int i = 0; i < DIMENSIONS; i++)
{
distanceSquared += Math.Max(r.min[i], r.max[i]);
#warning possible didn't convert properly
//distanceSquared += Math.Max(distanceSquared(i, r.min[i]), distanceSquared(i, r.max[i]));
}
return (float)Math.Sqrt(distanceSquared);
}
/**
* Return the distance between this rectangle and the passed rectangle.
* If the rectangles overlap, the distance is zero.
*
* @param r Rectangle to find the distance to
*
* @return distance between this rectangle and the passed rectangle
*/
internal float distance(Rectangle r)
{
float distanceSquared = 0;
for (int i = 0; i < DIMENSIONS; i++)
{
float greatestMin = Math.Max(min[i], r.min[i]);
float leastMax = Math.Min(max[i], r.max[i]);
if (greatestMin > leastMax)
{
distanceSquared += ((greatestMin - leastMax) * (greatestMin - leastMax));
}
}
return (float)Math.Sqrt(distanceSquared);
}
/**
* Determine whether this rectangle is contained by the passed rectangle
*
* @param r The rectangle that might contain this rectangle
*
* @return true if the passed rectangle contains this rectangle, false if
* it does not
*/
internal bool containedBy(Rectangle r)
{
for (int i = 0; i < DIMENSIONS; i++)
{
if (max[i] > r.max[i] || min[i] < r.min[i])
{
return false;
}
}
return true;
}
/**
* Determine whether this rectangle intersects the passed rectangle
*
* @param r The rectangle that might intersect this rectangle
*
* @return true if the rectangles intersect, false if they do not intersect
*/
internal bool intersects(Rectangle r)
{
// Every dimension must intersect. If any dimension
// does not intersect, return false immediately.
for (int i = 0; i < DIMENSIONS; i++)
{
if (max[i] < r.min[i] || min[i] > r.max[i])
{
return false;
}
}
return true;
}
/**
* Determine whether an edge of this rectangle overlies the equivalent
* edge of the passed rectangle
*/
internal bool edgeOverlaps(Rectangle r)
{
for (int i = 0; i < DIMENSIONS; i++)
{
if (min[i] == r.min[i] || max[i] == r.max[i])
{
return true;
}
}
return false;
}