public static void Main(string[] args)
{
ColoredPoint obj = new ColoredPoint(2, 3, "black");
ColoredLine obj1 = new ColoredLine(1, 2, 3, 4, "red");
Line obj2 = new Line(1, 2, 3, 4);
PolyLine obj3 = new PolyLine(1, 2, 3, 4, 5, 6, 7, 8);
}
public bool AddObject(ColoredPoint octreePoint)
{
if (octreePoint == null)
{
throw new NullReferenceException("octreePoint");
}
if (!CanContainOrIntersect(octreePoint))
{
return(false);
}
if (!HasChildren() || IsNeedForSplit())
{
AddObjectHere(octreePoint);
if (IsNeedForSplit())
{
CreateChildren();
DistributeObjectsToChildren();
}
}
else
{
if (!AddObjectToChildren(octreePoint))
{
AddObjectHere(octreePoint);
}
}
return(true);
}
public bool RemoveObject(ColoredPoint octreePoint)
{
if (octreePoint == null)
{
throw new NullReferenceException("octreePoint");
}
if (!CanContain(octreePoint))
{
return(false);
}
if (RemoveObjectHere(octreePoint))
{
return(true);
}
else
{
if (!_children.Any())
{
return(false);
}
foreach (var child in _children)
{
if (child.RemoveObject(octreePoint))
{
return(true);
}
}
}
return(false);
}
Dictionary <string, int> GetColumnAndRowCounts(List <ColoredPoint> data)
{
ColoredPoint p = new ColoredPoint(new System.Drawing.Point(-1, -1), Color.Black);
int rowCount = 0;
int ColCount = 0;
data.ForEach(pnt =>
{
if (pnt.X != p.X && p.X < pnt.X)
{
ColCount++;
p.X = pnt.X;
}
if (pnt.Y != p.Y && p.Y < pnt.Y)
{
rowCount++;
p.Y = pnt.Y;
}
});
return(new Dictionary <string, int>()
{
{ "rows", rowCount }, { "cols", ColCount }
});
}
public void BuildTriangle(ColoredPoint v0, ColoredPoint v1, ColoredPoint v2, Vector3 normal)
{
int v0Index = verts.Count;
int v1Index = verts.Count + 1;
int v2Index = verts.Count + 2;
// add vertices
verts.Add(v0.pos);
verts.Add(v1.pos);
verts.Add(v2.pos);
// add a surface normal for each vertex
normals.Add(normal);
normals.Add(normal);
normals.Add(normal);
// add uvs
uvs.Add(new Vector2(0, 0));
uvs.Add(new Vector2(0, 1));
uvs.Add(new Vector2(1, 1));
// add colors
colors.Add(v0.color);
colors.Add(v1.color);
colors.Add(v2.color);
// add indices that point to vertices
triangleIndices.Add(v0Index);
triangleIndices.Add(v1Index);
triangleIndices.Add(v2Index);
}
public bool intersect(ColoredPoint p1, ColoredPoint p2, ColoredPoint p3, ColoredPoint p4)
{
if (intersectProp(p1, p2, p3, p4))
return true;
else if (isBetween(p1, p2, p3) || isBetween(p1, p2, p4) || isBetween(p3, p4, p1) || isBetween(p3, p4, p2))
return true;
else return false;
}
public void add(ColoredPoint p)
{
if (p.IsDuplicate == false)
{
vertexColors[(int)p.vertexColor]++;
size++;
}
}
private void AddObjectHere(ColoredPoint octreePoint)
{
if (!_pointsDic.ContainsKey(octreePoint.CurrentlyUsedColor))
{
_pointsDic.Add(octreePoint.CurrentlyUsedColor, new List <ColoredPoint>());
}
_points.Add(octreePoint);
_pointsDic[octreePoint.CurrentlyUsedColor].Add(octreePoint);
_modelsInNodes++;
}
void Update()
{
mc.Clear();
// add vertices
for (int i = 0; i <= width; i++)
{
float x = i * squareSize;
for (int j = 0; j <= depth; j++)
{
float z = j * squareSize;
// compute noise at given space time point
float noiseOut = Perlin.Noise(noiseScale.x * i, noiseScale.y * Time.time, noiseScale.z * j);
// normalize noise
noiseOut += 1;
noiseOut /= 2;
// compute y-value from noise
float y = noiseOut * maxHeight;
// compute uv
float u = (float)i / width;
float v = (float)j / depth;
// compute color from noise
Color color = minColor + noiseOut * (maxColor - minColor);
// add the vertex
vertices[i, j] = new ColoredPoint(x, y, z, color.r, color.g, color.b);
}
}
// build triangles out of those vertices
for (int i = 0; i < width; i++)
{
for (int j = 0; j < depth; j++)
{
ColoredPoint a = vertices[i, j];
ColoredPoint b = vertices[i + 1, j];
ColoredPoint c = vertices[i, j + 1];
ColoredPoint d = vertices[i + 1, j + 1];
mc.BuildTriangle(d, b, a);
mc.BuildTriangle(c, d, a);
}
}
meshFilter.mesh = mc.CreateMesh();
}
private void InitializePoints(ColoredPoint[] points)
{
uint[] args = new uint[5] {
0, 0, 0, 0, 0
};
args[0] = (uint)entityMesh.GetIndexCount(0);
args[1] = (uint)points.Length;
args[2] = (uint)entityMesh.GetIndexStart(0);
args[3] = (uint)entityMesh.GetBaseVertex(0);
entityArgsBuffer = new ComputeBuffer(1, args.Length * sizeof(uint), ComputeBufferType.IndirectArguments);
entityArgsBuffer.SetData(args);
entityMeshPropertiesBuffer = new ComputeBuffer(points.Length, ColoredPoint.Size());
entityMeshPropertiesBuffer.SetData(points);
entityMat.SetBuffer("_Properties", entityMeshPropertiesBuffer);
}
public int isInDiagSet2(ColoredPoint a, ColoredPoint b)
{
for (int i = 1; i < diagonalSet.Count; i++)
{
if (((diagonalSet[i].Start.point.X == a.point.X) &&
(diagonalSet[i].Start.point.Y == a.point.Y) &&
(diagonalSet[i].End.point.X == b.point.X) &&
(diagonalSet[i].End.point.Y == b.point.Y))
||
((diagonalSet[i].End.point.X == a.point.X) &&
(diagonalSet[i].End.point.Y == a.point.Y) &&
(diagonalSet[i].Start.point.X == b.point.X) &&
(diagonalSet[i].Start.point.Y == b.point.Y)))
return i;
}
return -1;
}
public int isInDiagSet(ColoredPoint a, ColoredPoint b)
{
for (int i = 0; i < diagonalSet.Count; i++)
{
if (((diagonalSet[i].getStart().point.X == a.point.X) &&
(diagonalSet[i].getStart().point.Y == a.point.Y) &&
(diagonalSet[i].getEnd().point.X == b.point.X) &&
(diagonalSet[i].getEnd().point.Y == b.point.Y))
||
((diagonalSet[i].getEnd().point.X == a.point.X) &&
(diagonalSet[i].getEnd().point.Y == a.point.Y) &&
(diagonalSet[i].getStart().point.X == b.point.X) &&
(diagonalSet[i].getStart().point.Y == b.point.Y)))
return i;
}
return -1;
}
private Octree FindObjectParent(ColoredPoint point)
{
Octree toReturn = null;
if (_points.Any(x => x == point))
{
return(this);
}
int child = 0;
while ((toReturn == null) && (child < _children.Count))
{
toReturn = _children[child++].FindObjectParent(point);
}
return(toReturn);
}
private bool RemoveObjectHere(ColoredPoint octreePoint, bool merge = true)
{
if (!_points.Any())
{
return(false);
}
int index = _points.IndexOf(octreePoint);
if (index == -1)
{
return(false);
}
_pointsDic[octreePoint.CurrentlyUsedColor].Remove(octreePoint);
RemoveObject(index, merge);
return(true);
}
private ColoredPoint[] PointsFromEntityCollection(EntityCollection entities, float height, Vector3 pos)
{
if (entities.EntityCount == 0)
{
Debug.LogWarning("Trying to draw empty entity collection...");
}
ColoredPoint[] points = new ColoredPoint[entities.EntityCount];
int index = 0;
foreach (IEntity entity in entities.AllEntities)
{
points[index].matrix = Matrix4x4.TRS(new Vector3(entity.Position.x - pos.x, height - pos.y, entity.Position.y - pos.z), Quaternion.identity, Vector3.one * entity.Visualization.Size);
//Debug.Log($"POINT {points[index].matrix}");
points[index].color = entity.Visualization.Color;
index++;
}
return(points);
}
private bool AddObjectToChildren(ColoredPoint point)
{
if (_children.Any())
{
for (int i = 0; i < _children.Count; i++)
{
if (_children[i].CanContain(point))
{
_children[i].AddObject(point);
return(true);
}
}
var added = false;
var counter = 0;
for (int index = 0; index < _children.Count; index++)
{
if (_children[index].CanContain(point))
{
counter++;
}
}
if (counter == _children.Count)
{
return(false);
}
for (int index = 0; index < _children.Count; index++)
{
if (_children[index].CanContain(point))
{
_children[index].AddObject(point);
added = true;
}
}
return(added);
}
return(false);
}
bool LeftOn(ColoredPoint p1, ColoredPoint p2, ColoredPoint p3)
{
return Area2(p1, p2, p3) >= 0;
}
bool isCollinear(ColoredPoint p1, ColoredPoint p2, ColoredPoint p3)
{
return Area2(p1, p2, p3) == 0;
}
bool isBetween(ColoredPoint p1, ColoredPoint p2, ColoredPoint p3)
{
if (!isCollinear(p1, p2, p3)) return false;
if (p1.point.X != p2.point.X)
return ((p1.point.X <= p3.point.X) && (p3.point.X <= p2.point.X) ||
((p1.point.X >= p3.point.X) && (p3.point.X >= p2.point.X)));
else return ((p1.point.Y <= p3.point.Y) && (p3.point.Y <= p2.point.Y) ||
((p1.point.Y >= p3.point.Y) && (p3.point.Y >= p2.point.Y)));
}
bool intersectProp(ColoredPoint p1, ColoredPoint p2, ColoredPoint p3, ColoredPoint p4)
{
if (isCollinear(p1, p2, p3) || isCollinear(p1, p2, p4) || isCollinear(p3, p4, p1) || isCollinear(p3, p4, p2))
return false;
return Xor(Left(p1, p2, p3), Left(p1, p2, p4)) && Xor(Left(p3, p4, p1), Left(p3, p4, p2));
}
double Area2(ColoredPoint p1, ColoredPoint p2, ColoredPoint p3)
{
return (p2.point.X - p1.point.X) * (p3.point.Y - p1.point.Y) -
(p3.point.X - p1.point.X) * (p2.point.Y - p1.point.Y);
}
public void BuildTriangle(ColoredPoint v0, ColoredPoint v1, ColoredPoint v2)
{
Vector3 normal = Vector3.Cross(v1 - v0, v2 - v0).normalized;
BuildTriangle(v0, v1, v2, normal);
}
public Edge(ColoredPoint p1, ColoredPoint p2, ColoredPoint cut)
{
start = p1;
end = p2;
cutoff = cut;
}
public static UIElement GetColoredDataLabel(ColoredPoint cPoint)
{
StackPanel root = new StackPanel();
root.Orientation = Orientation.Horizontal;
root.Margin = new Thickness(2, 0, 2, 0);
Ellipse legend = new Ellipse();
legend.Width = legend.Height = 12;
legend.Fill = new SolidColorBrush(cPoint.pointColor);
TextBlock block = new TextBlock();
block.Text = cPoint.name + ": " + cPoint.pointData.Y.ToString("#0.00");
block.Margin = new Thickness(2, 0, 0, 0);
root.Children.Add(legend);
root.Children.Add(block);
return root;
}
private bool CanContain(ColoredPoint point)
{
return(_bbox.Value.Contains(point.Position) == ContainmentType.Contains);
}
public void add(ColoredPoint p)
{
vertexColors[(int)p.vertexColor]++;
}
public bool noIntersection(double x1, double y1, double x2, double y2, Polygon p1)
{
ColoredPoint p2, p3;
p2 = new ColoredPoint(x1, y1);
p3 = new ColoredPoint(x2, y2);
if (p1.vertices.Count <= 1) return true;
if (p1.clockwise)
for (int i = 1; i < p1.vertices.Count - 2; i++)
{
if (intersect(p2, p3, p1.vertices[i], p1.vertices[i + 1]))
{
return false;
}
}
else
for (int i = p1.vertices.Count - 1; i > 1; i--)
{
if (intersect(p2, p3, p1.vertices[i - 1], p1.vertices[i]))
{
return false;
}
}
return true;
}
public void addDiagonal(ColoredPoint i, ColoredPoint j, ColoredPoint cutOff)
{
diagonalSet.Add(new Edge(i, j, cutOff));
}
public Edge(ColoredPoint p1, ColoredPoint p2)
{
start = p1;
end = p2;
}
private bool CanContainOrIntersect(ColoredPoint octreePoint)
{
return(CanContain(octreePoint));
}
