public static INewGraph KruskalMST(INewGraph graph)
{
LogTool.AssertIsTrue(graph.Edges.First() is IWeightedEdge);
var ret = graph.Factory.CreateGraph();
var edges = graph.Edges.OrderBy(e => (e as IWeightedEdge).Weight);
var currentEdges = new List <IEdge>();
foreach (var e in edges)
{
currentEdges.Add(e);
if (GraphTools.HasCircle(currentEdges))
{
currentEdges.RemoveAt(currentEdges.Count - 1);
}
else
{
var nv1 = ret.AddVertex(e.Vertex.Clone() as IVertex);
var nv2 = ret.AddVertex(e.OtherVertex.Clone() as IVertex);
ret.AddEdge(nv1, nv2);
}
}
return(ret);
}
public void RunTest()
{
var p1 = new Point()
{
Position = new float3(0, 0, 0)
};
var p2 = new Point()
{
Position = new float3(1, 1, 0)
};
var p3 = new Point()
{
Position = new float3(0, 1, 0)
};
var p4 = new Point()
{
Position = new float3(1, 0, 0)
};
var p5 = new Point()
{
Position = new float3(1, 0, 0)
};
var p6 = new Point()
{
Position = new float3(2, 0, 0)
};
LogTool.AssertIsTrue(GeometryTools.IsLineSegmentIntersection(p1, p2, p3, p4));
LogTool.AssertIsFalse(GeometryTools.IsLineSegmentIntersection(p1, p2, p5, p6));
}
public static bool IsLineSegmentIntersection(IPoint a1, IPoint a2, IPoint b1, IPoint b2)
{
LogTool.AssertIsTrue(a1 != a2);
LogTool.AssertIsTrue(b1 != b2);
LogTool.AssertIsFalse(a1 == b1 && a2 == b2);
var da = a2.Position - a1.Position;
var db = b2.Position - b1.Position;
var dc = b1.Position - a1.Position;
if (math.dot(dc, math.cross(da, db)) != 0)
{
return(false);
}
var n2 = Norm2(math.cross(da, db));
var s = math.dot(math.cross(dc, db), math.cross(da, db)) / n2;
var t = math.dot(math.cross(dc, da), math.cross(da, db)) / n2;
if (s >= 0 && s <= 1 && t >= 0 && t <= 1)
{
return(true);
}
return(false);
}
public int Random()
{
LogTool.AssertIsTrue(this.sum.Count > 0);
var total = this.sum.Last();
var rand = UnityEngine.Random.Range(0, total);
var l = 0;
var r = this.sum.Count;
while (l < r)
{
var mid = l + (r - l) / 2;
if (this.sum[mid] < rand)
{
l = mid + 1;
}
else
{
r = mid;
}
}
return(r);
}
protected void UpdateReductionBuffer(Texture source)
{
LogTool.AssertIsTrue(Mathf.IsPowerOfTwo(source.width));
LogTool.AssertIsTrue(Mathf.IsPowerOfTwo(source.height));
this.CleanUp();
var w = source.width;
var h = source.height;
for (; w > 0 || h > 0; w = w >> 1, h = h >> 1)
{
// Debug.Log(w + " " + h);
var tw = math.max(1, w);
var th = math.max(1, h);
var p = math.max(w, h);
// Debug.Log(p + " with " + tw + "x" + th);
var desc = new RenderTextureDescriptor(tw, th, RenderTextureFormat.ARGBFloat);
desc.enableRandomWrite = true;
var tex = TextureManager.Create(desc);
this.reductionBuffer.Add(p, tex);
}
Graphics.CopyTexture(source, this.reductionBuffer[math.max(source.width, source.height)]);
this.resultBuffer.InitBuffer(1, true, false);
}
public override void InitBuffer(GPUBufferVariable <T> other)
{
LogTool.Log("Use InitAppendBuffer(GPUBufferAppendConsume<T> other)", LogLevel.Warning);
LogTool.AssertIsTrue(other is GPUBufferAppendConsume <T>);
this.InitAppendBuffer(other as GPUBufferAppendConsume <T>);
}
public void ResetCounter(uint counter = 0)
{
LogTool.AssertIsTrue(this.Size > 0);
this.Data.SetCounterValue(counter);
this.CounterBuffer.ClearData();
}
public Intension Generate(Perception perception, Habits habits, MentalState mental, PhysicalState ps, float t)
{
Intension intension = default;
var sensorData = perception.GetSensorData();
var distance = sensorData.closestDangerObj == null ? -1 : sensorData.closestDangerObj.distance;
if (distance > 0)
{
var mono = sensorData.closestDangerObj.obj as MonoBehaviour;
intension = new AvoidIntension(mono.gameObject);
if (this.intensionStack.Count == 0 || this.intensionStack.Last.Value.IntensionType != Intension.Type.Avoid)
{
this.intensionStack.AddLast(intension);
}
}
else
{
//fear of most dangerous predator m
var p = sensorData.GetClosestByType(ObjectType.Predator);
var Fm = p != null?ps.Fi(p.distance) : 0;
var F = mental.fear;
if (F > this.f0)
{
if (Fm < this.f1 && habits.schooling)
{
intension = new SchoolIntension();
}
else
{
var mono = p.obj as MonoBehaviour;
intension = new EscapedIntension(mono.gameObject);
}
}
else
{
if (this.IsLastEatOrMate())
{
intension = this.intensionStack.Last.Value;
this.intensionStack.RemoveLast();
}
else
{
intension = this.GenerateNewIntension(perception, habits, mental, ps, t);
}
}
}
if (this.intensionStack.Count > 1)
{
this.intensionStack.RemoveFirst();
}
LogTool.AssertIsTrue(intension != null);
return(intension);
}
protected void OnEnable()
{
LogTool.AssertIsTrue(this.computeShader != null);
this.dispatcher = new ComputeShaderDispatcher(this.computeShader);
this.dispatcher.AddParameter(WindowKernel, this.data);
this.dispatcher.AddParameter(MaxKernel, this.data);
}
public void InitAppendBuffer(int size, bool autoSet = false)
{
LogTool.AssertIsTrue(size > 0);
//no cpu data for append buffer
base.InitBuffer(size, false, autoSet, ComputeBufferType.Append);
this.ResetCounter();
}
public void InitAppendBuffer(GPUBufferAppendConsume <T> other)
{
LogTool.AssertIsTrue(other.Size > 0);
//no cpu data for append buffer
base.InitBuffer(other);
this.ResetCounter();
}
public static void CalculateVerticeWeight(INewGraph graph)
{
debug.Clear();
foreach (var v in graph.Vertices)
{
LogTool.AssertIsTrue(v is IVertex);
UpdateEdgeCost(graph, v as IVertex);
}
}
public static int2 SpaceToPixelSize(ISpace space, int pixelSize)
{
LogTool.AssertIsTrue(space.Scale.x > 0);
LogTool.AssertIsTrue(pixelSize > 2);
var aspect = space.Scale.y / space.Scale.x;
return(new int2(pixelSize, Mathf.CeilToInt(pixelSize * aspect)));
}
public WeightRandom(List <int> weights)
{
this.sum.Clear();
foreach (var i in Enumerable.Range(0, weights.Count))
{
LogTool.AssertIsTrue(weights[i] > 0);
var s = weights[i] + (i > 0 ? this.sum[i - 1] : 0);
this.sum.Add(s);
}
}
protected const int MIN_INDIRECT_BUFFER_SIZE = 5;//5 ints
public static void SwapBuffer(GPUBufferVariable <T> lhs, GPUBufferVariable <T> rhs)
{
LogTool.AssertIsTrue(lhs.Size == rhs.Size);
LogTool.AssertIsTrue(lhs.type == rhs.type);
var temp = lhs.gpuBuffer;
lhs.gpuBuffer = rhs.gpuBuffer;
rhs.gpuBuffer = temp;
}
public void Scan(SensorData sensorData)
{
var from = this as ISensorableObject;
var o = new float3(this.Position);
var dir = new float3(this.transform.forward);
var minDis = new Dictionary <ObjectType, float>();
foreach (ObjectType t in Enum.GetValues(typeof(ObjectType)))
{
minDis.Add(t, this.Or);
}
var minDangerDis = this.Dr;
LogTool.AssertIsTrue(this.Manager != null);
foreach (var f in this.Manager.SensorableObjects)
{
if (from == f)
{
continue;
}
var distance = from.GetDistance(f);
if (distance < this.Or)
{
sensorData.AddSensorable(f, distance);
var p = f.Position;
var angle = math.dot(math.normalize(p - o), math.normalize(dir));
if (distance < this.Vr && angle > math.cos(math.radians(this.angle / 2)))
{
sensorData.AddVisiable(f, distance);
if (distance < this.Dr)
{
sensorData.AddDanger(f, distance);
if (distance < minDangerDis)
{
minDangerDis = distance;
sensorData.closestDangerObj = new SensorObject()
{
obj = f, distance = distance
};
}
}
}
}
if (distance < minDis[f.ObjType])
{
minDis[f.ObjType] = distance;
sensorData.SetClosest(f, distance);
}
}
}
public float4 GetReductionResult()
{
LogTool.AssertIsTrue(this.Inited);
if (!this.Inited)
{
return(0);
}
this.DoReduction(this.source, this.reductionBuffer);
this.resultBuffer.GetToCPUData();
return(this.resultBuffer.CPUData[0]);
}
public virtual void InitBuffer(int size, bool cpuData = false, bool autoSet = true, ComputeBufferType type = ComputeBufferType.Default)
{
LogTool.AssertIsTrue(size > 0);
this.Release();
this.size = size;
this.type = type;
this.autoSet = autoSet;
this.cpuData = cpuData ? new T[this.size] : null;
this.inited = true;
}
protected void Start()
{
this.source.InitBuffer(1024 * 512, true);
foreach (var i in Enumerable.Range(0, this.source.Size))
{
this.source.CPUData[i] = Random.Range(-this.source.Size, this.source.Size);
// this.source.CPUData[i] = (uint)(this.source.Size - i);
}
this.source.SetToGPUBuffer();
this.Sort(ref this.source);
this.source.GetToCPUData();
foreach (var i in Enumerable.Range(0, this.source.Size - 1))
{
LogTool.AssertIsTrue(this.source.CPUData[i] <= this.source.CPUData[i + 1]);
}
}
// Start is called before the first frame update
void Start()
{
graph = new HGraph();
var v1 = graph.Factory.CreateVertex();
var v2 = graph.Factory.CreateVertex();
var v3 = graph.Factory.CreateVertex();
v1 = graph.AddVertex(v1);
v2 = graph.AddVertex(v2);
v3 = graph.AddVertex(v3);
var e1 = graph.AddEdge(v1, v2);
var e2 = graph.AddEdge(v2, v3);
var e3 = graph.AddEdge(v3, v1);
var f = graph.GetFace(e1);
LogTool.AssertIsTrue(f != NoneHalfEdgeObject.None);
}
/// <summary>
/// This function will get all ComputeShaderParameterBase parameters
/// Stores them into list and used to update GPU data
/// </summary>
protected void InitVariableList()
{
if (this.inited)
{
return;
}
LogTool.AssertIsTrue(this.variableList == null);
var bindingFlags = BindingFlags.Instance |
BindingFlags.NonPublic |
BindingFlags.Public;
this.variableList = this.GetType()
.GetFields(bindingFlags)
.Where(field
=> typeof(IComputeShaderParameter).IsAssignableFrom(field.FieldType) &&
!Attribute.IsDefined(field, typeof(NoneGPUAttribute)))
.Select(field => field.GetValue(this) as IComputeShaderParameter)
.ToList();
var noneCSParameter = this.GetType()
.GetFields(bindingFlags)
.Where(field => !field.FieldType.IsSubclassOf(typeof(IComputeShaderParameter)) &&
!Attribute.IsDefined(field, typeof(NoneGPUAttribute)))
.ToList();
foreach (var p in noneCSParameter)
{
var csp = this.CreateParameter(p);
if (csp == default)
{
continue;
}
this.noneCSVariables.Add(p, csp);
}
LogTool.AssertIsTrue(this.variableList != null);
this.inited = true;
}
static public void UpdateGradientTexture(Texture2D tex, List <Gradient> from, int size = 128)
{
var w = size;
var h = from.Count;
LogTool.AssertNotNull(tex);
LogTool.AssertIsTrue(w == tex.width);
LogTool.AssertIsTrue(h == tex.height);
foreach (var y in Enumerable.Range(0, h))
{
foreach (var x in Enumerable.Range(0, w))
{
var key = x * 1f / (w - 1);
var color = from[y].Evaluate(key);
tex.SetPixel(x, y, color);
}
}
tex.Apply();
}
protected void DoReduction(Texture source, Dictionary <int, Texture> reductionBuffer)
{
LogTool.AssertNotNull(source);
LogTool.AssertNotNull(reductionBuffer);
Graphics.CopyTexture(source, this.reductionBuffer[math.max(source.width, source.height)]);
var w = source.width;
var h = source.height;
for (; w > 0 || h > 0; w = w >> 1, h = h >> 1)
{
var k = this.computeShader.FindKernel(ReductionKernelName);
var p = math.max(w, h);
if (p > 1)
{
var from = p;
var to = p >> 1;
var tw = math.max(1, w >> 1);
var th = math.max(1, h >> 1);
// Debug.Log("from " + from + " with " + reductionBuffer[from].width + "x" + reductionBuffer[from].height);
// Debug.Log("to " + to + " with " + reductionBuffer[to].width + "x" + reductionBuffer[to].height);
// Debug.Log("Dispatch " + tw + "x" + th);
this.computeShader.SetTexture(k, "_From", reductionBuffer[from]);
this.computeShader.SetTexture(k, "_To", reductionBuffer[to]);
this.computeShader.Dispatch(k, tw, th, 1);
}
else
{
LogTool.AssertIsTrue(p == 1);
k = this.computeShader.FindKernel(ResultKernelName);
this.computeShader.SetTexture(k, "_From", reductionBuffer[p]);
this.computeShader.SetBuffer(k, this.resultBuffer.ShaderName, this.resultBuffer);
this.computeShader.Dispatch(k, 1, 1, 1);
}
}
}
public virtual void InitBuffer(GPUBufferVariable <T> other)
{
LogTool.AssertIsTrue(other.Size > 0);
LogTool.AssertIsTrue(this != other);//self assignment is dangerous
this.Release();
this.size = other.Size;
this.type = other.type;
this.autoSet = other.autoSet;
if (other.cpuData != null)
{
if (this.cpuData == null || this.cpuData.Length != other.cpuData.Length)
{
this.cpuData = new T[this.size];
}
Array.Copy(other.cpuData, this.cpuData, this.size);
}
this.gpuBuffer = other.Data;
this.inited = true;
}
protected void CheckFace(IHalfEdge edge)
{
var e = edge.Next;
var ecount = 0;
while (e != edge)
{
if (e.Face != NoneHalfEdgeObject.None)
{
edge.Face = e.Face;
return;
}
e = e.Next;
ecount++;
if (ecount > 100000)
{
LogTool.Log("Error loop for edge " + edge, LogLevel.Error);
return;
}
}
if (ecount >= 3)
{
var newFace = (this.Factory as IHalfEdgeFactory).CreateFace();
newFace.HalfEdge = edge;
edge.Face = newFace;
var ret = this.faces.Add(newFace);
LogTool.AssertIsTrue(ret);
e = newFace.HalfEdge.Next;
var str = " ";
while (e != edge)
{
str += " " + e.ToString();
e = e.Next;
}
LogTool.Log("Add face " + str);
}
}
protected void TestNewGraph(NewGraph <IndexVertex, DefaultEdge, IndexGraphFactory> graph)
{
foreach (var e in Enumerable.Range(0, 20))
{
graph.Add(graph.Factory.CreateVertex());
}
var nodes = graph.Vertices.OrderBy(v => v.index).ToList();
var e01 = graph.AddEdge(nodes[0], nodes[1]);
var e02 = graph.Factory.CreateEdge(nodes[3], nodes[4]);
var e56 = graph.AddEdge(nodes[5], nodes[6]);
graph.AddEdge(nodes[5], nodes[7]);
graph.AddEdge(nodes[5], nodes[8]);
graph.AddEdge(nodes[5], nodes[5]);
graph.AddEdge(nodes[5], nodes[1]);
graph.AddEdge(nodes[5], nodes[11], true);
graph.AddEdge(nodes[1], nodes[15]);
LogTool.AssertIsTrue(graph.Contains(e01));
LogTool.AssertIsFalse(graph.Contains(e02));
LogTool.AssertIsTrue(e56 == graph.GetEdge(nodes[5], nodes[6]));
LogTool.AssertIsTrue(e56 == graph.GetEdge(nodes[6], nodes[5]));
LogTool.AssertIsFalse(e56 == graph.GetEdge(nodes[5], nodes[5]));
foreach (var e in graph.Edges)
{
LogTool.Log(e.ToString());
}
LogTool.Log("Neighbor 5");
foreach (var e in graph.GetNeighborVertices(nodes[5]))
{
LogTool.Log(e.ToString());
}
}
public void GenerateFFTData()
{
var vector = this.sourceFunction.ToYVector();
var array = vector.Select(s => (double)s).ToArray();
var dft = new DFT();
dft.Initialize((uint)array.Length);
Complex[] cSpectrum = dft.Execute(array);
var An = DSP.ConvertComplex.ToMagnitude(cSpectrum);
var Pn = DSP.ConvertComplex.ToPhaseRadians(cSpectrum);
LogTool.AssertIsTrue(An.Length == Pn.Length);
this.cosData.Clear();
for (var i = 0; i < An.Length; ++i)
{
this.cosData.Add(new CosData()
{
amplitude = (float)An[i], frequency = i, phase = (float)Pn[i]
});
}
}
public void Resize(int x, int y)
{
LogTool.AssertIsTrue(x >= 0 && y >= 0);
this.Init(x, y);
}
public void Resize(int size)
{
LogTool.AssertIsTrue(size >= 0);
this.data = new T[size];
}
public override IEdge AddEdge(IVertex v1, IVertex v2, bool isDirectional = false)
{
if (this.GetEdge(v1, v2) != default)
{
return(this.GetEdge(v1, v2));
}
//Half edge is always directional
isDirectional = true;
var v12Edge = base.AddEdge(v1, v2, isDirectional) as IHalfEdge;
var v21Edge = base.AddEdge(v2, v1, isDirectional) as IHalfEdge;
var from = v1 as IHalfEdgeVertex;
var to = v2 as IHalfEdgeVertex;
if (from.Outgoing == null)
{
from.Outgoing = NoneHalfEdgeObject.None;
}
if (to.Outgoing == null)
{
to.Outgoing = NoneHalfEdgeObject.None;
}
if (v12Edge.Face == null)
{
v12Edge.Face = NoneHalfEdgeObject.None;
}
if (v12Edge.Next == null)
{
v12Edge.Next = v21Edge;
}
if (v12Edge.Opposite == null)
{
v12Edge.Opposite = v21Edge;
}
if (v12Edge.Previous == null)
{
v12Edge.Previous = v21Edge;
}
if (v21Edge.Face == null)
{
v21Edge.Face = NoneHalfEdgeObject.None;
}
if (v21Edge.Next == null)
{
v21Edge.Next = v12Edge;
}
if (v21Edge.Opposite == null)
{
v21Edge.Opposite = v12Edge;
}
if (v21Edge.Previous == null)
{
v21Edge.Previous = v12Edge;
}
if (from.Outgoing != NoneHalfEdgeObject.None)
{
LogTool.AssertIsTrue(from.Outgoing != null);
LogTool.AssertIsTrue(v21Edge.Vertex == to);
LogTool.AssertIsTrue(v21Edge.OtherVertex == from);
var prev = from.Outgoing.Previous;
var next = from.Outgoing.Previous.Next;
prev.Next = v12Edge;
v12Edge.Previous = prev;
next.Previous = v21Edge;
v21Edge.Next = next;
}
if (to.Outgoing != NoneHalfEdgeObject.None)
{
LogTool.AssertIsTrue(to.Outgoing != null);
LogTool.AssertIsTrue(v12Edge.Vertex == from);
LogTool.AssertIsTrue(v12Edge.OtherVertex == to);
var prev = to.Outgoing.Previous;
var next = to.Outgoing.Previous.Next;
prev.Next = v21Edge;
v21Edge.Previous = prev;
next.Previous = v12Edge;
v12Edge.Next = next;
}
from.Outgoing = v12Edge;
to.Outgoing = v21Edge;
this.CheckFace(v12Edge);
this.CheckFace(v21Edge);
LogTool.AssertIsTrue(v12Edge.Opposite == v21Edge);
LogTool.AssertIsTrue(v21Edge.Opposite == v12Edge);
LogTool.AssertNotNull(v12Edge.Face);
LogTool.AssertNotNull(v21Edge.Face);
return(v12Edge);
}
