/// <inheritdoc/>
public virtual CartesianBounds GetBounds(
CartesianChartCore <TDrawingContext> chart, IAxis <TDrawingContext> x, IAxis <TDrawingContext> y)
{
var seriesLength = 0;
var stack = chart.SeriesContext.GetStackPosition(this, GetStackGroup());
var bounds = new CartesianBounds();
foreach (var point in Fetch(chart))
{
var secondary = point.SecondaryValue;
var primary = point.PrimaryValue;
if (stack != null)
{
primary = stack.StackPoint(point);
}
var abx = bounds.SecondaryBounds.AppendValue(secondary);
var aby = bounds.PrimaryBounds.AppendValue(primary);
seriesLength++;
}
return(bounds);
}
public void Init(CartesianBounds cartesianBounds)
{
UserObject = GameObject.Find("UserObject");
BuildOctree(cartesianBounds);
_intersectionCamera = UserObject.GetComponentInChildren <Camera>();
_lastEnableLods = _enableLods;
}
public void ExtentsTest()
{
CartesianBounds subject = new CartesianBounds(3, 3, 10, 10);
Assert.AreEqual(3, subject.Left);
Assert.AreEqual(3, subject.Bottom);
Assert.AreEqual(13, subject.Right);
Assert.AreEqual(13, subject.Top);
}
public void ContainsVectorTest()
{
CartesianBounds subject;
Vector obj;
subject = new CartesianBounds(3, 3, 10, 10);
obj = new Vector(5, 5);
Assert.IsTrue(subject.Contains(obj));
obj = new Vector(50, 50);
Assert.IsFalse(subject.Contains(obj));
}
public void BuildOctree(CartesianBounds cartesianBounds)
{
float centerX = (float)(cartesianBounds.MinimumCoordinates.X + cartesianBounds.MaximumCoordinates.X) / 2f;
float centerZ = (float)(cartesianBounds.MinimumCoordinates.Y + cartesianBounds.MaximumCoordinates.Y) / 2f;
float sizeX = (float)(cartesianBounds.MaximumCoordinates.X - cartesianBounds.MinimumCoordinates.X);
float sizeZ = (float)(cartesianBounds.MaximumCoordinates.Y - cartesianBounds.MinimumCoordinates.Y);
// NOTE: This is offset in y in a naive way, just so that two nodes on top of one another
// don't have their adjoining edge at y=0 which many model bounds would intersect. So it improves the insertion quality for our purposes
var boundary = new Bounds(new Vector3(centerX, 100f, centerZ), new Vector3(sizeX, 1000f, sizeZ));
_octree = new Octree(boundary, 1);
_octree.Build(Models);
}
public void ContainsBoundsTest()
{
CartesianBounds subject, obj;
subject = new CartesianBounds(3, 3, 10, 10);
obj = new CartesianBounds(5, 5, 3, 3);
Assert.IsTrue(subject.Contains(obj));
obj = new CartesianBounds(1, 1, 50, 50);
Assert.IsFalse(subject.Contains(obj));
obj = new CartesianBounds(1, 1, 5, 5);
Assert.IsFalse(subject.Contains(obj));
obj = new CartesianBounds(100, 100, 10, 10);
Assert.IsFalse(subject.Contains(obj));
}
//void Update()
//{
// if (Database == null)
// return;
// GetTerrainElevation();
//}
private void GetTerrainElevation()
{
if (Database == null)
{
isOverTile = false;
return;
}
Tile tile = GetTileBelowCamera();
if (tile == null || tile.IsLoaded == false)
{
isOverTile = false;
return;
}
else
{
isOverTile = true;
}
CartesianBounds cartesianBounds = tile.GeographicBounds.TransformedWith(Database.Projection);
double spcX = (cartesianBounds.MaximumCoordinates.X - cartesianBounds.MinimumCoordinates.X) / tile.MeshDimension;
double spcZ = (cartesianBounds.MaximumCoordinates.Y - cartesianBounds.MinimumCoordinates.Y) / tile.MeshDimension;
double orgX = cartesianBounds.MinimumCoordinates.X;
double orgZ = cartesianBounds.MinimumCoordinates.Y;
float xComponent = transform.position.x - (float)orgX;
float zComponent = transform.position.z - (float)orgZ;
int xIndex = Math.Min(tile.MeshDimension - 2, (int)Math.Floor(xComponent / spcX));
int zIndex = Math.Min(tile.MeshDimension - 2, (int)Math.Floor(zComponent / spcZ));
indicesBelowCamera[0] = zIndex * tile.MeshDimension + xIndex;
indicesBelowCamera[1] = indicesBelowCamera[0] + 1;
indicesBelowCamera[2] = indicesBelowCamera[0] + tile.MeshDimension;
indicesBelowCamera[3] = indicesBelowCamera[0] + tile.MeshDimension + 1;
for (int i = 0; i < indicesBelowCamera.Length; ++i)
{
verticesBelowCamera[i] = tile.vertices[indicesBelowCamera[i]];
}
SetMinElevationWithTriangle(transform.position, verticesBelowCamera[0], verticesBelowCamera[2], verticesBelowCamera[3]);
SetMinElevationWithTriangle(transform.position, verticesBelowCamera[0], verticesBelowCamera[1], verticesBelowCamera[3]);
}
public Tile GetTileBelowCamera()
{
var camera = new CartesianCoordinates(transform.position.x, transform.position.z);
foreach (var elem in Database.ActiveTiles)
{
Tile tile = elem.Value;
CartesianBounds cartesianBounds = tile.GeographicBounds.TransformedWith(Database.Projection);
if (cartesianBounds.MaximumCoordinates.X > camera.X &&
cartesianBounds.MaximumCoordinates.Y > camera.Y &&
cartesianBounds.MinimumCoordinates.X < camera.X &&
cartesianBounds.MinimumCoordinates.Y < camera.Y)
{
return(tile);
}
}
return(null);
}
public void OverlapsTest()
{
CartesianBounds subject, obj;
subject = new CartesianBounds(3, 3, 10, 10);
obj = new CartesianBounds(5, 5, 3, 3);
Assert.IsTrue(subject.Overlaps(obj));
obj = new CartesianBounds(1, 1, 50, 50);
Assert.IsTrue(subject.Overlaps(obj));
obj = new CartesianBounds(1, 1, 5, 5);
Assert.IsTrue(subject.Overlaps(obj));
obj = new CartesianBounds(8, 8, 5, 5);
Assert.IsTrue(subject.Overlaps(obj));
obj = new CartesianBounds(100, 100, 10, 10);
Assert.IsFalse(subject.Overlaps(obj));
}
void GenerateVertices()
{
var meshDimension = MeshDimension;
CartesianBounds cartesianBounds = GeographicBounds.TransformedWith(Database.Projection);
double spacingX = (cartesianBounds.MaximumCoordinates.X - cartesianBounds.MinimumCoordinates.X) / RasterDimension;
double spacingY = (cartesianBounds.MaximumCoordinates.Y - cartesianBounds.MinimumCoordinates.Y) / RasterDimension;
double originX = cartesianBounds.MinimumCoordinates.X;
double originY = cartesianBounds.MinimumCoordinates.Y;
vertices = new Vector3[meshDimension * meshDimension];
int vertexIndex = 0;
for (int row = 0; row < meshDimension; ++row)
{
for (int column = 0; column < meshDimension; ++column, ++vertexIndex)
{
ref Vector3 vertex = ref vertices[vertexIndex];
vertex.x = (float)(originX + (column * spacingX));
vertex.y = 0f;
vertex.z = (float)(originY + (row * spacingY));
}
}
private void GenerateMesh(QuadTreeNode tile)
{
var data = DataByTile[tile];
TileMatrix tileMatrix = ElevationTileMatrixSet[tile.Depth];
int MeshDimension = (int)tileMatrix.TileWidth;
CartesianBounds cartesianBounds = tile.GeographicBounds.TransformedWith(Projection);
double spacingX = (cartesianBounds.MaximumCoordinates.X - cartesianBounds.MinimumCoordinates.X) / tileMatrix.TileWidth;
double spacingY = (cartesianBounds.MaximumCoordinates.Y - cartesianBounds.MinimumCoordinates.Y) / tileMatrix.TileHeight;
double originX = cartesianBounds.MinimumCoordinates.X;
double originY = cartesianBounds.MinimumCoordinates.Y;
// vertices
{
data.vertices = new Vector3[MeshDimension * MeshDimension];
int vertexIndex = 0;
for (int row = 0; row < MeshDimension; ++row)
{
for (int column = 0; column < MeshDimension; ++column, ++vertexIndex)
{
data.vertices[vertexIndex] = new Vector3((float)(originX + (column * spacingX)), 0.0f, (float)(originY + (row * spacingY)));
}
}
}
// triangles
{
data.triangles = new int[(MeshDimension - 1) * (MeshDimension - 1) * 6];
int triangleIndex = 0;
for (int row = 0; row < (MeshDimension - 1); ++row)
{
for (int column = 0; column < (MeshDimension - 1); ++column, triangleIndex += 6)
{
int vertexIndex = (row * MeshDimension) + column;
int lowerLeftIndex = vertexIndex;
int lowerRightIndex = lowerLeftIndex + 1;
int upperLeftIndex = lowerLeftIndex + MeshDimension;
int upperRightIndex = upperLeftIndex + 1;
data.triangles[triangleIndex + 0] = lowerLeftIndex;
data.triangles[triangleIndex + 1] = upperLeftIndex;
data.triangles[triangleIndex + 2] = upperRightIndex;
data.triangles[triangleIndex + 3] = lowerLeftIndex;
data.triangles[triangleIndex + 4] = upperRightIndex;
data.triangles[triangleIndex + 5] = lowerRightIndex;
}
}
}
// uvs
{
data.uv = new Vector2[data.vertices.Length];
int vertexIndex = 0;
for (int row = 0; row < MeshDimension; ++row)
{
for (int column = 0; column < MeshDimension; ++column, ++vertexIndex)
{
data.uv[vertexIndex] = new Vector2((float)column / (MeshDimension - 1), (float)row / (MeshDimension - 1));
}
}
}
}
