public void TestUnsupportedScaleOperations()
{
var tsd = ObjectFactory.CreateTileSetDefinition(new Version(3, 0, 0));
tsd.SetXYZProviderParameters();
ITileSetAbstract tsTileSet = tsd;
Assert.False(tsTileSet.SupportsCustomFiniteDisplayScalesUnconditionally);
Assert.False(tsTileSet.SupportsCustomFiniteDisplayScales);
Assert.Throws <InvalidOperationException>(() => tsTileSet.SetFiniteDisplayScales(new double[] { 1.0, 2.0, 4.0 }));
Assert.Throws <InvalidOperationException>(() => { var x = tsTileSet.ScaleCount; });
Assert.Throws <InvalidOperationException>(() => tsTileSet.SetFiniteDisplayScales(new double[] { 1.0, 2.0, 4.0, 8.0, 16.0 }));
Assert.Throws <InvalidOperationException>(() => tsTileSet.GetScaleAt(0));
Assert.Throws <InvalidOperationException>(() => tsTileSet.RemoveScaleAt(3));
Assert.Throws <InvalidOperationException>(() => tsTileSet.RemoveFiniteDisplayScale(1.2));
Assert.Throws <InvalidOperationException>(() => tsTileSet.RemoveAllScales());
Assert.Throws <InvalidOperationException>(() => tsTileSet.AddFiniteDisplayScale(1234.0));
}
public void FiniteScalesTest()
{
var mdf = ObjectFactory.CreateMapDefinition(new Version(3, 0, 0), "Test");
var tsd = ObjectFactory.CreateTileSetDefinition(new Version(3, 0, 0));
mdf.InitBaseMap();
tsd.SetDefaultProviderParameters(300, 300, "", new double[] { });
ITileSetAbstract tsMapDef = mdf.BaseMap;
ITileSetAbstract tsTileSet = tsd;
Assert.False(tsTileSet.SupportsCustomFiniteDisplayScalesUnconditionally);
Assert.True(tsTileSet.SupportsCustomFiniteDisplayScales);
tsMapDef.SetFiniteDisplayScales(new double[] { 1.0, 2.0, 4.0 });
tsTileSet.SetFiniteDisplayScales(new double[] { 1.0, 2.0, 4.0 });
Assert.Equal(3, tsMapDef.ScaleCount);
Assert.Equal(3, tsTileSet.ScaleCount);
tsMapDef.SetFiniteDisplayScales(new double[] { 1.0, 2.0, 4.0, 8.0, 16.0 });
tsTileSet.SetFiniteDisplayScales(new double[] { 1.0, 2.0, 4.0, 8.0, 16.0 });
Assert.Equal(5, tsMapDef.ScaleCount);
Assert.Equal(5, tsTileSet.ScaleCount);
Assert.Equal(1.0, tsMapDef.GetScaleAt(0));
Assert.Equal(1.0, tsTileSet.GetScaleAt(0));
Assert.Equal(2.0, tsMapDef.GetScaleAt(1));
Assert.Equal(2.0, tsTileSet.GetScaleAt(1));
Assert.Equal(4.0, tsMapDef.GetScaleAt(2));
Assert.Equal(4.0, tsTileSet.GetScaleAt(2));
Assert.Equal(8.0, tsMapDef.GetScaleAt(3));
Assert.Equal(8.0, tsTileSet.GetScaleAt(3));
Assert.Equal(16.0, tsMapDef.GetScaleAt(4));
Assert.Equal(16.0, tsTileSet.GetScaleAt(4));
tsMapDef.RemoveScaleAt(3);
tsTileSet.RemoveScaleAt(3);
Assert.Equal(1.0, tsMapDef.GetScaleAt(0));
Assert.Equal(1.0, tsTileSet.GetScaleAt(0));
Assert.Equal(2.0, tsMapDef.GetScaleAt(1));
Assert.Equal(2.0, tsTileSet.GetScaleAt(1));
Assert.Equal(4.0, tsMapDef.GetScaleAt(2));
Assert.Equal(4.0, tsTileSet.GetScaleAt(2));
Assert.Equal(16.0, tsMapDef.GetScaleAt(3));
Assert.Equal(16.0, tsTileSet.GetScaleAt(3));
tsMapDef.RemoveScaleAt(0);
tsTileSet.RemoveScaleAt(0);
Assert.Equal(2.0, tsMapDef.GetScaleAt(0));
Assert.Equal(2.0, tsTileSet.GetScaleAt(0));
Assert.Equal(4.0, tsMapDef.GetScaleAt(1));
Assert.Equal(4.0, tsTileSet.GetScaleAt(1));
Assert.Equal(16.0, tsMapDef.GetScaleAt(2));
Assert.Equal(16.0, tsTileSet.GetScaleAt(2));
tsMapDef.RemoveScaleAt(2);
tsTileSet.RemoveScaleAt(2);
Assert.Equal(2.0, tsMapDef.GetScaleAt(0));
Assert.Equal(2.0, tsTileSet.GetScaleAt(0));
Assert.Equal(4.0, tsMapDef.GetScaleAt(1));
Assert.Equal(4.0, tsTileSet.GetScaleAt(1));
Assert.Equal(2.0, tsMapDef.GetMinScale());
Assert.Equal(2.0, tsTileSet.GetMinScale());
tsMapDef.RemoveFiniteDisplayScale(1.2);
tsTileSet.RemoveFiniteDisplayScale(1.2);
Assert.Equal(2.0, tsMapDef.GetScaleAt(0));
Assert.Equal(2.0, tsTileSet.GetScaleAt(0));
Assert.Equal(4.0, tsMapDef.GetScaleAt(1));
Assert.Equal(4.0, tsTileSet.GetScaleAt(1));
Assert.Throws <ArgumentOutOfRangeException>(() => tsMapDef.RemoveScaleAt(6));
Assert.Throws <ArgumentOutOfRangeException>(() => tsTileSet.RemoveScaleAt(6));
Assert.Equal(2.0, tsMapDef.GetScaleAt(0));
Assert.Equal(2.0, tsTileSet.GetScaleAt(0));
Assert.Equal(4.0, tsMapDef.GetScaleAt(1));
Assert.Equal(4.0, tsTileSet.GetScaleAt(1));
tsMapDef.AddFiniteDisplayScale(3.0);
tsTileSet.AddFiniteDisplayScale(3.0);
Assert.Equal(3, tsMapDef.ScaleCount);
Assert.Equal(3, tsTileSet.ScaleCount);
Assert.Equal(3.0, tsMapDef.GetScaleAt(1));
Assert.Equal(3.0, tsTileSet.GetScaleAt(1));
tsMapDef.RemoveAllScales();
tsTileSet.RemoveAllScales();
Assert.Equal(0, tsMapDef.ScaleCount);
Assert.Equal(0, tsTileSet.ScaleCount);
}
internal void CalculateDimensionsInternal()
{
if (m_tileset.ScaleCount == 0)
{
m_scaleindexmap = new int[0];
m_dimensions = new long[0][];
return;
}
IEnvelope extents = m_tileSetExtents; //this.MaxExtent ?? m_tileSetExtents;
double maxscale = m_maxscale;
m_dimensions = new long[this.Resolutions][];
m_scaleindexmap = new int[m_dimensions.Length];
double width_in_meters = Math.Abs(m_parent.Config.MetersPerUnit * (extents.MaxX - extents.MinX));
double height_in_meters = Math.Abs(m_parent.Config.MetersPerUnit * (extents.MaxY - extents.MinY));
m_dimensions = new long[this.Resolutions][];
for (int i = this.Resolutions - 1; i >= 0; i--)
{
long rows, cols, rowTileOffset = 0, colTileOffset = 0;
double scale = m_tileset.GetScaleAt(i);
// This is the official method, and the only one MgCooker will ever use
// This is the algorithm proposed by the MapGuide team:
// http://www.nabble.com/Pre-Genererate--tiles-for-the-entire-map-at-all-pre-defined-zoom-scales-to6074037.html#a6078663
//
// Method description inline (in case nabble link disappears):
//
// The upper left corner of the extents of the map corresponds to tile (0,0). Then tile (1,0) is to the right of that and tile (0,1) is under tile (0,0).
// So assuming you know the extents of your map, you can calculate how many tiles it spans at the given scale, using the following
//
// number of tiles x = map width in meters / ( 0.079375 * map_scale)
// number of tiles y = map height in meters / ( 0.079375 * map_scale)
//
// where 0.079375 = [inch to meter] / image DPI * tile size = 0.0254 / 96 * 300.
//
// This assumes you know the scale factor that converts your map width and height to meters. You can get this from the coordinate system of the map if you don't know it, but it's much easier to just plug in the number into this equation.
//
// Also have in mind that you can also request tiles beyond the map extent (for example tile (-1, -1), however, there is probably no point to cache them unless you have valid data outside your initial map extents.
//The tile extent in meters
double tileMapWidth = ((INCH_TO_METER / m_parent.Config.DPI * m_parent.Config.TileWidth) * (scale));
double tileMapHeight = ((INCH_TO_METER / m_parent.Config.DPI * m_parent.Config.TileHeight) * (scale));
//Using this algorithm, yields a negative number of columns/rows, if the max scale is larger than the max extent of the map.
rows = Math.Max(1, (int)Math.Ceiling((height_in_meters / tileMapHeight)));
cols = Math.Max(1, (int)Math.Ceiling((width_in_meters / tileMapWidth)));
if (m_maxExtent != null)
{
//The extent is overridden, so we need to adjust the start offsets
//and re-compute row/col span against the overridden extents
double offsetMapX = Math.Abs(m_parent.Config.MetersPerUnit * (m_maxExtent.MinX - m_tileSetExtents.MinX));
double offsetMapY = Math.Abs(m_parent.Config.MetersPerUnit * (m_tileSetExtents.MaxY - m_maxExtent.MaxY));
rowTileOffset = (int)Math.Floor(offsetMapY / tileMapHeight);
colTileOffset = (int)Math.Floor(offsetMapX / tileMapWidth);
//Re-compute rows/cols against override extent
width_in_meters = Math.Abs(m_parent.Config.MetersPerUnit * (m_maxExtent.MaxX - m_maxExtent.MinX));
height_in_meters = Math.Abs(m_parent.Config.MetersPerUnit * (m_maxExtent.MaxY - m_maxExtent.MinY));
rows = Math.Max(1, (int)Math.Ceiling((height_in_meters / tileMapHeight)));
cols = Math.Max(1, (int)Math.Ceiling((width_in_meters / tileMapWidth)));
}
m_dimensions[i] = new long[] { rows, cols, rowTileOffset, colTileOffset };
}
}