{

// we shall make all the calculations in server projection (either GMercator or custom)

// and then transform bounds to the current coordinate system

//Point2D center = _extents.GetCenter();

double minX, maxX, minY, maxY; // size of control in pixels

PROJECTION_TO_PIXEL(_extents.left, _extents.bottom, minX, minY);

PROJECTION_TO_PIXEL(_extents.right, _extents.top, maxX, maxY);

const double screenHeight = abs(maxY - minY);

const double screenWidth = abs(maxX - minX);

// multiplication ratio, to make texts more legible when projection-related scaling is under way

double ratio;

static_cast<CTiles*>(_tiles)->get_ScalingRatio(&ratio); // 1.0 by default

// half of equator circumference (width and height for Mercator projection)

const double projWidth = static_cast<CTiles*>(_tiles)->get_Provider()->get_Projection()->GetWidth();

// TODO: use height as well

const double pxWidth = ratio * 512.0 * pow(2.0, zoom - 1); // width of map in pixels at the requested zoom

const double w = screenWidth / pxWidth * projWidth; // requested width in server projection

const double h = screenHeight / pxWidth * projWidth; // requested height in server projection

size.WidthLng = w;

size.HeightLat = h;

{

if (_transformationMode == tmNotDefined) {

return VARIANT_FALSE;

}

if (_viewWidth == 0 || _viewHeight == 0) {

return VARIANT_FALSE;

}

SizeLatLng size;

GetTilesZoomLevelSize(zoom, size);

if (_tileProjectionState == ProjectionMatch)

{

SetMapExtentsSize(size, logPrevious);

_currentZoom = zoom;

}

else

{

Extent box;

MapExtentsForTileBounds(size, box);

SetExtentsCore(box, logPrevious, false, false);

_currentZoom = zoom;

AdjustZoom(zoom);

}

return VARIANT_FALSE;

{

Point2D center = _extents.GetCenter();

const double minX = center.x - size.WidthLng / 2.0;

const double maxX = center.x + size.WidthLng / 2.0;

const double minY = center.y - size.HeightLat / 2.0;

const double maxY = center.y + size.HeightLat / 2.0;

SetExtentsCore(Extent(minX, maxX, minY, maxY), logPrevious, false, false);

{

IGeoProjection* tilesToMapTransform = GetTilesToMapTransform();

if (!tilesToMapTransform) {

ErrorMsg(tkFAILED_TO_REPROJECT);

return false;

}

const Point2D center = _extents.GetCenter();

double xCent = center.x;

double yCent = center.y;

// bounds defined in tiles projection

VARIANT_BOOL vb, vb2;

GetMapToTilesTransform()->Transform(&xCent, &yCent, &vb);

double minX = xCent - size.WidthLng / 2.0;

double maxX = xCent + size.WidthLng / 2.0;

double minY = yCent - size.HeightLat / 2.0;

double maxY = yCent + size.HeightLat / 2.0;

Extent extrapolatedBounds;

const bool extrapolation = ExtrapolateSphericalMercatorToDegrees(minX, maxX, minY, maxY, extrapolatedBounds);

// transforming to map projection

tilesToMapTransform->Transform(&minX, &minY, &vb);

tilesToMapTransform->Transform(&maxX, &maxY, &vb2);

// substitute with extrapolated values if we are outside bounds

if (extrapolation)

{

if (extrapolatedBounds.left != 0.0) minX = extrapolatedBounds.left;

if (extrapolatedBounds.right != 0.0) maxX = extrapolatedBounds.right;

if (extrapolatedBounds.bottom != 0.0) minY = extrapolatedBounds.bottom;

if (extrapolatedBounds.top != 0.0) maxY = extrapolatedBounds.top;

}

if (!vb || !vb2)

{

ErrorMsg(tkFAILED_TO_REPROJECT);

return false;

}

// finally adjust the center to it's initial position

extents = Extent(minX, maxX, minY, maxY);

extents.MoveTo(center.x, center.y);

return true;

{

VARIANT_BOOL sphericalMercator;

_tiles->get_ProjectionIsSphericalMercator(&sphericalMercator);

const bool extrapolation = sphericalMercator && _transformationMode == tmWgs84Complied;

double minLng = 0.0, maxLng = 0.0, minLat = 0.0, maxLat = 0.0;

if (extrapolation) // ding extrapolation for WGS84

{

// In case we are outside bounds of GMercator, results will be incorrect.

// Let's use clipping and extrapolation as a remedy.

// We shall assume that GMercator meters to map units ratio is constant and doesn't

// depend on latitude or longitude, which is not true.

// TODO: do transformation in several points within world bounds for better extrapolation.

const double maxVal = MERCATOR_MAX_VAL;

if (xMin < -maxVal)

minLng = -MAX_LONGITUDE - abs(xMin + maxVal) / maxVal * MAX_LONGITUDE;

if (xMax > maxVal)

maxLng = MAX_LONGITUDE + abs(xMax - maxVal) / maxVal * MAX_LONGITUDE;

if (yMin < -maxVal)

minLat = -MAX_LATITUDE - abs(yMin + maxVal) / maxVal * MAX_LATITUDE;

if (yMax > maxVal)

maxLat = MAX_LATITUDE + abs(yMax - maxVal) / maxVal * MAX_LATITUDE;

}

extents.left = minLng;

extents.right = maxLng;

extents.top = maxLat;

extents.bottom = minLat;

return extrapolation;

{

VARIANT_BOOL vb;

double xTemp = (_extents.left + _extents.right) / 2.0;

double yTemp = (_extents.bottom + _extents.top) / 2.0;

IGeoProjection* gp = GetMapToWgs84Transform();

gp->Transform(&xTemp, &yTemp, &vb);

PointLatLng loc;

loc.Lat = yTemp;

loc.Lng = xTemp;

double size = TileHelper::GetTileSizeProj(_tileProjectionState == ProjectionMatch,

static_cast<CTiles*>(_tiles)->get_Provider(), GetWgs84ToMapTransform(), loc, zoom);

const double pixelsPerMapUnit = PixelsPerMapUnit();

size *= pixelsPerMapUnit;

return size;

{

if (_transformationMode == tmWgs84Complied || _tileProjectionState == ProjectionMatch)

return;

double size = GetCurrentTileSize(zoom);

if (size < 0) return;

Debug::WriteWithTime(Debug::Format("After zooming; tile size: %f", size), DebugTiles);

double scalingRatio;

static_cast<CTiles*>(_tiles)->get_ScalingRatio(&scalingRatio);

const double targetSize = 256.0 * scalingRatio;

if (abs(size - targetSize) > 1.0)

{

// let's adjust it

const double xTemp = (_extents.left + _extents.right) / 2.0;

const double yTemp = (_extents.bottom + _extents.top) / 2.0;

const double ratio = size / targetSize;

const double w = _extents.Width() * ratio;

const double h = _extents.Height() * ratio;

_extents.left = xTemp - w / 2.0;

_extents.right = xTemp + w / 2.0;

_extents.top = yTemp - h / 2.0;

_extents.bottom = yTemp + h / 2.0;

this->SetExtentsCore(_extents, false, false, false);

}

size = GetCurrentTileSize(zoom);

Debug::WriteWithTime(Debug::Format("After adjusting; tile size: %f", size), DebugTiles);

{

double cLeft = ext.left;

double cRight = ext.right;

double cBottom = ext.bottom;

double cTop = ext.top;

// If new extents are 2 or more times smaller than current ones

// we'll zoom in to the next level (or through several levels), otherwise return to the previous one.

// As a user generally expects zooming, let's make extents smaller manually to force zooming

// if they are not small enough.

if (ForceDiscreteZoom())

{

int zoom, maxZoom, minZoom;

_tiles->get_CurrentZoom(&zoom);

GetMinMaxZoom(minZoom, maxZoom);

if ((zoom + 1 > maxZoom && zoomIn) || (zoom - 1 < minZoom && !zoomIn))

return;

const double ratioX = (_extents.right - _extents.left) / (cRight - cLeft);

const double ratioY = (_extents.top - _extents.bottom) / (cTop - cBottom);

const double ratio = MIN(ratioX, ratioY);

const double targetRatio = zoomIn ? 2.001 : 0.499; // 2.001 = add some margin for rounding issues

if ((zoomIn && ratio < 2.0) || !zoomIn && ratio > 0.5)

{

// no need to preserve the aspect ratio of new selection; control will adjust it all the same

const double w = (_extents.right - _extents.left) / targetRatio;

const double h = (_extents.top - _extents.bottom) / targetRatio;

const double centX = (cRight + cLeft) / 2.0;

const double centY = (cTop + cBottom) / 2.0;

cLeft = centX - w / 2.0;

cRight = centX + w / 2.0;

cTop = centY - h / 2.0;

cBottom = centY + h / 2.0;

}

}

SetExtentsCore(Extent(cLeft, cRight, cBottom, cTop));

{

_knownExtents = keNone;

_lastRedrawTime = 0.0f;

CalculateVisibleExtents(ext, mapSizeChanged);

if (ForceDiscreteZoom() && adjustZoom)

{

// Adjust it to the smaller discrete zoom level.

// The computation overhead on calculating twice is negligible

// In order it to work, Tiles.ChooseZoomLevel must not scale down the tiles

// (i.e. tiles size is always > 256 (original) and the same size in chosen in ZoomToTileLevel)

int zoom;

_tiles->get_CurrentZoom(&zoom);

ZoomToTileLevelCore(zoom, logExtents);

_tiles->get_CurrentZoom(&zoom);

return;

}

if (!ForceDiscreteZoom())

{

_currentZoom = GetCurrentZoom();

}

ScheduleLayerRedraw();

if (logExtents)

{

LogPrevExtent();

}

FireExtentsChanged();

_lastWidthMeters = 0.0; // extents has changed it must be recalculated

if (!_lockCount)

{

RedrawCore(RedrawAll, false, true);

}

{

double minX, maxX, minY, maxY; // size of map control in pixels

ProjectionToPixel(_extents.left, _extents.top, minX, minY);

ProjectionToPixel(_extents.right, _extents.bottom, maxX, maxY);

sh = (maxY - minY) / 96.0; // Number of pixels per logical inch along the screen width.

sw = (maxX - minX) / 96.0; // Number of pixels per logical inch along the screen height

{

const double convFact = Utility::GetConversionFactor(_unitsOfMeasure);

mh = _extents.Height() * convFact;

mw = _extents.Width() * convFact;

{

AFX_MANAGE_STATE(AfxGetStaticModuleState());

if (_extents.Width() == 0.0 || _extents.Height() == 0.0 || _viewWidth == 0 || _viewHeight == 0)

{

return 0.0;

}

double sw, sh, mw, mh;

GetScreenInches(sw, sh);

GetMapSizeInches(mw, mh);

const double md = sqrt(pow(mw, 2) + pow(mh, 2));

const double sd = sqrt(pow(sw, 2) + pow(sh, 2));

return md / sd;

{

AFX_MANAGE_STATE(AfxGetStaticModuleState());

if (newVal <= 0.0) return;

double sw, sh;

GetScreenInches(sw, sh);

// diagonal of map extents in inches

const double sd = sqrt(pow(sw, 2) + pow(sh, 2));

const double md = newVal * sd;

const double a = sw / sh; // we need width and height, but have diagonal and the sides ratio of triangle only; this makes 2 equations:

double mh = sqrt(pow(md, 2) / (pow(a, 2) + 1)); // x/y = a

double mw = mh * a; // x^2 + y^2 = b^2 // where b - mapDiag

// Taking x from first:

// y^2*a^2 + y^2 = b^2

// y = sqrt(b^2/(a^2 + 1))

// x = y*a

// converting to the map units

mh /= Utility::GetConversionFactor(_unitsOfMeasure);

mw /= Utility::GetConversionFactor(_unitsOfMeasure);

const Point2D center = _extents.GetCenter();

const Extent box(center, mw, mh);

SetExtentsCore(box);

{

if (!newValue)

{

ErrorMessage(tkUNEXPECTED_NULL_PARAMETER);

return;

}

Extent box(newValue);

SetExtentsCore(box);

{

AFX_MANAGE_STATE(AfxGetStaticModuleState());

if (!extents)

{

this->ErrorMessage(tkUNEXPECTED_NULL_PARAMETER);

return VARIANT_FALSE;

}

if (_transformationMode == tmNotDefined)

{

this->ErrorMessage(tkTRANSFORMATIONMODE_NOT_DEFINED);

return VARIANT_FALSE;

}

this->LockWindow(tkLockMode::lmLock);

if (_transformationMode == tmWgs84Complied)

{

this->SetExtents(extents);

}

else if (_transformationMode == tmDoTransformation)

{

double xMin, xMax, yMin, yMax, zMin, zMax;

extents->GetBounds(&xMin, &yMin, &zMin, &xMax, &yMax, &zMax);

VARIANT_BOOL vbretval;

IGeoProjection* p = GetWgs84ToMapTransform();

if (p) {

p->Transform(&xMin, &yMin, &vbretval);

if (!vbretval) {

this->LockWindow(tkLockMode::lmUnlock);

this->ErrorMessage(tkFAILED_TO_REPROJECT);

return VARIANT_FALSE;

}

p->Transform(&xMax, &yMax, &vbretval);

if (!vbretval) {

this->LockWindow(tkLockMode::lmUnlock);

this->ErrorMessage(tkFAILED_TO_REPROJECT);

return VARIANT_FALSE;

}

}

else

{

this->LockWindow(tkLockMode::lmUnlock);

this->ErrorMessage(tkFAILED_TO_REPROJECT);

return VARIANT_FALSE;

}

extents->SetBounds(xMin, yMin, zMin, xMax, yMax, zMax);

this->SetExtents(extents);

}

if (ForceDiscreteZoom())

{

int zoom;

_tiles->get_CurrentZoom(&zoom);

ZoomToTileLevel(zoom);

}

this->LockWindow(tkLockMode::lmUnlock);

return VARIANT_TRUE;

{

// we don't want to have coordinates outside world bounds, as it breaks tiles loading

IExtents* ext = GetGeographicExtentsCore(clipForTiles, clipExtents);

if (!ext) return false;

const Extent bounds(ext);

ext->Release();

result = bounds;

return true;

{

AFX_MANAGE_STATE(AfxGetStaticModuleState());

double val = 1.0;

if (this->_unitsOfMeasure != umDecimalDegrees)

{

if (!Utility::ConvertDistance(umDecimalDegrees, this->_unitsOfMeasure, val))

{

return 0.0;

}

}

double x = 0.0, y = 0.0;

double screenX = 0.0, screenY = 0.0;

this->ProjToPixel(x, y, &screenX, &screenY);

const double x1 = screenX;

const double y1 = screenY;

x = y = val;

this->ProjToPixel(x, y, &screenX, &screenY);

const double result = (abs(screenX - x1) + abs(screenY - y1)) / 2.0;

// alternative approach (results depend on latitude)

/*double px, py, px2, py2;

return result;

{

AFX_MANAGE_STATE(AfxGetStaticModuleState());

const double val = 1.0;

double x = 0.0, y = 0.0;

double screenX = 0.0, screenY = 0.0;

this->ProjToPixel(x, y, &screenX, &screenY);

const double x1 = screenX;

x = y = val;

this->ProjToPixel(x, y, &screenX, &screenY);

return abs(screenX - x1);

{

double val = 1.0;

if (_unitsOfMeasure == umDecimalDegrees)

{

return val;

}

if (Utility::ConvertDistance(this->_unitsOfMeasure, umDecimalDegrees, val))

{

return val;

}

return 1.0;

{

double minX, maxX, minY, maxY;

PROJECTION_TO_PIXEL(_extents.left, _extents.bottom, minX, minY);

PROJECTION_TO_PIXEL(_extents.right, _extents.top, maxX, maxY);

if (minX == maxX && minY == maxY)

{

return 0.0;

}

return sqrt(pow(_extents.right - _extents.left, 2) + pow(_extents.top - _extents.bottom, 2)) /

sqrt(pow(maxX - minX, 2) + pow(maxY - minY, 2));

{

AFX_MANAGE_STATE(AfxGetStaticModuleState());

long numSelected = 0;

IShapefile* sf = this->GetShapefile(layerHandle);

if (sf)

{

sf->get_NumSelected(&numSelected);

if (numSelected > 0)

{

double xMin, yMin, xMax, yMax;

ShapefileHelper::GetSelectedExtents(sf, xMin, yMin, xMax, yMax);

SetExtentsWithPadding(Extent(xMin, xMax, yMin, yMax));

}

sf->Release();

}

return numSelected > 0 ? VARIANT_TRUE : VARIANT_FALSE;

{

bool extentsSet = false;

const long endcondition = _activeLayers.size();

for (int i = 0; i < endcondition; i++)

{

if (this->LayerIsEmpty(_activeLayers[i])) continue;

const Layer* l = _allLayers[_activeLayers[i]];

this->AdjustLayerExtents(_activeLayers[i]);

const double xrange = l->extents.right - l->extents.left;

const double yrange = l->extents.top - l->extents.bottom;

//Neio 2009-07-02 for empty layer will cause the caculation error

if (xrange == 0 && yrange == 0 && l->extents.right == 0 && l->extents.top == 0)

continue;

if (extentsSet == false)

{

_extents.left = l->extents.left - xrange * m_extentPad;

_extents.right = l->extents.right + xrange * m_extentPad;

_extents.top = l->extents.top + yrange * m_extentPad;

_extents.bottom = l->extents.bottom - yrange * m_extentPad;

extentsSet = true;

}

else

{

if (l->extents.left - xrange * m_extentPad < _extents.left)

_extents.left = l->extents.left - xrange * m_extentPad;

if (l->extents.right + xrange * m_extentPad > _extents.right)

_extents.right = l->extents.right + xrange * m_extentPad;

if (l->extents.bottom - yrange * m_extentPad < _extents.bottom)

_extents.bottom = l->extents.bottom - yrange * m_extentPad;

if (l->extents.top + yrange * m_extentPad > _extents.top)

_extents.top = l->extents.top + yrange * m_extentPad;

}

}

if (!extentsSet)

_extents = Extent(0, 0, 0, 0);

this->SetExtentsCore(_extents);

{

bool extentsSet = false;

const long endcondition = _activeLayers.size();

for (int i = 0; i < endcondition; i++)

{

Layer* l = _allLayers[_activeLayers[i]];

this->AdjustLayerExtents(_activeLayers[i]);

if (l->get_Visible())

{

const double xrange = l->extents.right - l->extents.left;

const double yrange = l->extents.top - l->extents.bottom;

if (xrange == 0 && yrange == 0 && l->extents.right == 0 && l->extents.top == 0)

continue;

if (extentsSet == false)

{

_extents.left = l->extents.left - xrange * m_extentPad;

_extents.right = l->extents.right + xrange * m_extentPad;

_extents.top = l->extents.top + yrange * m_extentPad;

_extents.bottom = l->extents.bottom - yrange * m_extentPad;

extentsSet = true;

}

else

{

if (l->extents.left - xrange * m_extentPad < _extents.left)

_extents.left = l->extents.left - xrange * m_extentPad;

if (l->extents.right + xrange * m_extentPad > _extents.right)

_extents.right = l->extents.right + xrange * m_extentPad;

if (l->extents.bottom - yrange * m_extentPad < _extents.bottom)

_extents.bottom = l->extents.bottom - yrange * m_extentPad;

if (l->extents.top + yrange * m_extentPad > _extents.top)

_extents.top = l->extents.top + yrange * m_extentPad;

}

}

}

if (!extentsSet)

_extents = Extent(0, 0, 0, 0);

this->SetExtentsCore(_extents);

{

if (IS_VALID_LAYER(LayerHandle, _allLayers))

{

AdjustLayerExtents(LayerHandle);

const Layer* l = _allLayers[LayerHandle];

SetExtentsWithPadding(l->extents);

}

else

this->ErrorMessage(tkINVALID_LAYER_HANDLE);

{

double xrange = ext.right - ext.left;

double yrange = ext.top - ext.bottom;

//if the minimum and maximum extents are the same, use a range of 1 for

// xrange and yrange to allow a point to be centered in the map window

// when ZoomToShape is used on a point shapefile.

if (xrange == 0)

xrange = 1;

if (yrange == 0)

yrange = 1;

ext.left = ext.left - xrange * m_extentPad;

ext.right = ext.right + xrange * m_extentPad;

ext.top = ext.top + yrange * m_extentPad;

ext.bottom = ext.bottom - yrange * m_extentPad;

this->SetExtentsCore(ext);

{

if (!IsValidShape(layerHandle, shapeIndex))

return VARIANT_FALSE;

IShapefile* sf = GetShapefile(layerHandle);

double left, right, top, bottom;

static_cast<CShapefile*>(sf)->QuickExtentsCore(shapeIndex, &left, &bottom, &right, &top);

sf->Release();

Extent extNew(left, right, bottom, top);

if (ifOutsideOnly && extNew.Intersects(_extents)) {

return VARIANT_FALSE;

}

SetExtentsWithPadding(extNew);

return VARIANT_TRUE;

{

double left = MIN(e.left, e.right);

double right = MAX(e.left, e.right);

double bottom = MIN(e.bottom, e.top);

double top = MAX(e.bottom, e.top);

if (left == right) // lsu 26 jul 2009 for zooming to single point

{

left -= 0.5;

right += 0.5;

}

if (bottom == top)

{

bottom -= 0.5;

top += 0.5;

}

double xrange = right - left;

double yrange = top - bottom;

double yextent;

double xextent = yextent = 0.0;

if (!MapSizeChanged && _mapResizeBehavior != rbWarp)

{

// size of control is the same, we need just to apply new extents

if (_viewHeight != 0 && _viewWidth != 0 && xrange != 0.0 && yrange != 0.0)

{

// make extents proportional to screen sides ratio

const double ratio = (static_cast<double>(_viewWidth) / static_cast<double>(_viewHeight)) / (xrange / yrange);

if (ratio > 1)

{

left = left - xrange * (ratio - 1) / 2;