/// <summary><para>Die Funktion <see cref="Load(bool, int, bool)"/> gibt ein Satellitenbild zurück, so dass die
/// so dass die Koordinate, die durch das <see cref="MapService"/>-Objekt festgelegt ist, sich in der Mitte
/// des Bildes befindet.</para></summary>
/// <remarks><para>Die Koordinate befindet sich in der Regel nicht in der Mitte eines von einem Provider
/// zurück gelieferten Satellitenbildes. Diese Funktion berechnet die Abweichung, und lädt intern die notwendigen
/// angrenzenden Satellitenbilder nach, fügt sie zusammen und beschneidet das so entstandene Bild auf die
/// Größe eines normalen Satellitenbildes. Über den Parameter <i>threshold</i> kann angegeben werden, ab welcher
/// Abweichung vom Mittelpunkt eines Bildes eine Koordinatennormalisierung stattfinden soll. Bitte beachten
/// Sie, dass bei einer notwendigen Normalisierung 4 Bilder nachgeladen werden müssen. Dies kann bei langsamen
/// Internetverbindungen eventuell zu kurzen Verzögerungen oder erhöhtem Netzverkehr führen.</para></remarks>
///
/// <param name="centered">Legt fest, ob der zugrundeliegende Koordinatenpunkt auf dem resultierenden Bild zentriert werden soll.</param>
/// <param name="threshold">Abweichung vom Mittelpunkt in Bildpunkten (Pixel), ab der eine Normalisierung durchgeführt werden soll. Mögliche Werte liegen zwischen 0 (immer normalisieren) bis 100 (keine Normalisierung).</param>
/// <param name="silent">Legt fest, ob im Fehlerfall eine Exception weitergegeben wird (false) oder nicht (true).</param>
/// <returns>Ein Bild vom Typ <see cref="System.Drawing.Image"/> mit einem eventuell zentrierten Koordinatenpunkt.</returns>
public Image Load(bool centered, int threshold, bool silent)
{
Image image = new Bitmap(TILE_SIZE, TILE_SIZE);
int shiftX, shiftY, shift, radius;
int halfsize = TILE_SIZE / 2;
GeoSystem.Helper.GeoPoint point = this.Parent.TileInfo.GeoPosition;
// Radius mit Thresholdwert auf alle möglichen Bildgrößen umrechnen
if ((threshold < 0) || (threshold > 100))
{
threshold = 0;
}
radius = Convert.ToInt32(threshold * halfsize / 100);
// Abstand vom Mittelpunkt (Pythagoras)
shiftX = point.X - halfsize;
shiftY = point.Y - halfsize;
Rectangle crop = new Rectangle(0, 0, TILE_SIZE, TILE_SIZE);
shift = Convert.ToInt32(Math.Sqrt((shiftX * shiftX) + (shiftY * shiftY)));
if ((shift <= radius) || (centered == false)) // Koordinate liegt innerhalb Schwellwert oder keine Normalisierung
{
image = Load(this.Parent.Tile, silent);
}
else
{
// Umgebungsbild laden, so dass die gesuchte Koordinate nahe am Zentrum liegt
Image area = null;
if ((shiftX <= 0) && (shiftY <= 0))
{
area = this.Area(Info.MapDirection.Northwest, false, out point);
}
else if ((shiftX > 0) && (shiftY <= 0))
{
area = this.Area(Info.MapDirection.Northeast, false, out point);
}
else if ((shiftX <= 0) && (shiftY > 0))
{
area = this.Area(Info.MapDirection.Southwest, false, out point);
}
else if ((shiftX > 0) && (shiftY > 0))
{
area = this.Area(Info.MapDirection.Southeast, false, out point);
}
if (area == null)
{
return(null);
}
// Umgebungsbild so beschneiden, dass die Koordinate genau im Zentrum liegt
crop.X = point.X - halfsize;
crop.Y = point.Y - halfsize;
Graphics graph = Graphics.FromImage(image);
Rectangle dest = new Rectangle(0, 0, TILE_SIZE, TILE_SIZE);
graph.DrawImage(area, dest, crop, GraphicsUnit.Pixel);
}
return(image);
}
/// <summary><para>Die überladene Funktion <see cref="Load(int, bool)"/> lädt das Satellitenbild, welches durch das aktuelle
/// <see cref="MapService"/>-Objekt definiert ist. Es wird ein Bild in der Größe der übergebenen Parameter
/// zurückgegeben. Eventuell auftretende Exceptions werden unterdrückt.</para></summary>
///
/// <example>
/// Das folgende Beispiel zeigt die Verwendung der Funktion. Der Beispielcode verwendet ein
/// <strong>PictureBox</strong>-Steuerelement zur Anzeige des Bildes.
/// <code>
/// using System.Drawing;
/// using GeoUtility.GeoSystem;
/// Geographic geo = new Geographic(8.12345, 50.56789);
/// MapService.Info.MapServer server = MapService.Info.MapServer.VirtualEarth;
/// MapService map = new MapService(geo, server);
/// map.Zoom = 15;
/// Image img = map.Image.Load(200, 200);
/// picturebox.Image = img;
/// </code>
/// </example>
/// <param name="size">Größe des zurückgegebenen Bildes in Pixel (20 - 2000)</param>
/// <param name="mark">Position markieren</param>
/// <returns>Ein Bild vom allgemeinen Typ <see cref="System.Drawing.Image"/>.</returns>
public Image Load(int size, bool mark)
{
if (size < 20)
{
size = 20;
}
else if (size > 2000)
{
size = 2000;
}
Image image = null;
Image sizedImage = new Bitmap(size, size);
if (Parent.Center == true)
{
image = Load(true, 0, true);
}
else
{
image = Load(this.Parent.Tile, true);
}
if (image != null)
{
Graphics graph = Graphics.FromImage(sizedImage);
Rectangle destRect = new Rectangle(0, 0, size, size);
Rectangle sourceRect = new Rectangle(0, 0, image.Width, image.Height);
graph.DrawImage(image, destRect, sourceRect, GraphicsUnit.Pixel);
if (mark == true)
{
int markSize = 2;
if (Parent.Zoom >= 18)
{
markSize = 14;
}
else if (Parent.Zoom >= 15)
{
markSize = 12;
}
else if (Parent.Zoom >= 12)
{
markSize = 10;
}
else if (Parent.Zoom >= 9)
{
markSize = 8;
}
else if (Parent.Zoom >= 6)
{
markSize = 6;
}
else if (Parent.Zoom >= 3)
{
markSize = 4;
}
double ratio = (double)size / (double)TILE_SIZE;
markSize = Convert.ToInt32((double)markSize * ratio);
if (markSize == 0)
{
markSize = 2;
}
GeoSystem.Helper.GeoPoint point = Parent.TileInfo.GeoPosition;
if (Parent.Center == true)
{
point = new GeoUtility.GeoSystem.Helper.GeoPoint(TILE_SIZE / 2, TILE_SIZE / 2);
}
int left = Convert.ToInt32((double)point.X * ratio) - markSize / 2;
int top = Convert.ToInt32((double)point.Y * ratio) - markSize / 2;
Rectangle rect = new Rectangle(left, top, markSize, markSize);
Pen pen = new Pen(Color.Red, 1);
graph.DrawRectangle(pen, rect);
}
return(sizedImage);
}
return(null);
}
