private void TestFlip(List <Vector3> points, Triangles triangles, WorkBuffer <Int2> stack, int a, int b, int x)
{
var y = triangles.Opposite(a, b);
//Test boundary edge
if (y < 0)
{
return;
}
//Swap edge if order flipped
if (b < a)
{
var tmp = a;
a = b;
b = tmp;
tmp = x;
x = y;
y = tmp;
}
//Test if edge is constrained
if (triangles.IsConstraint(a, b))
{
return;
}
//Test if edge is delaunay
if (Robust.InSphere(points[a], points[b], points[x], points[y]) < 0f)
{
var v = new Int2(a, b);
stack.Push(ref v);
}
}
protected virtual async Task ReadSegmentAsync(ISegmentReader segmentReader, CancellationToken cancellationToken)
{
WorkBuffer buffer = (WorkBuffer)null;
try
{
while (!segmentReader.IsEof)
{
if (null == buffer)
{
buffer = await this._bufferPool.AllocateAsync(cancellationToken).ConfigureAwait(false);
}
Debug.Assert(null != buffer);
WorkBuffer localBuffer = buffer;
int length = await segmentReader.ReadAsync(buffer.Buffer, 0, buffer.Buffer.Length, (Action <ISegmentMetadata>)(metadata => localBuffer.Metadata = metadata), cancellationToken).ConfigureAwait(false);
buffer.Length = length;
buffer.ReadCount = ++this._readCount;
if (buffer.Length > 0)
{
this._total += (long)buffer.Length;
this._enqueue(buffer);
buffer = (WorkBuffer)null;
}
}
}
finally
{
if (null != buffer)
{
this._bufferPool.Free(buffer);
}
}
}
private void SplitHulls(WorkBuffer <PartialHull> hulls, Event e)
{
var splitIdx = BinarySearch.LE(hulls.Data, e, FindSplit.Default, 0, hulls.UsedSize - 1);
var hull = hulls.Data[splitIdx];
var upperIds = hull.UpperIds;
var x = upperIds.Data[upperIds.UsedSize - 1];
hull.UpperIds = new WorkBuffer <int>(8);
hull.UpperIds.Push(ref x);
var h = hulls.Insert(splitIdx + 1);
h.A = e.A;
h.B = e.B;
h.Index = e.Index;
h.LowerIds.Clear();
h.LowerIds.Push(ref x);
h.UpperIds = upperIds;
if (Verbose)
{
Debug.Log("Split: " + splitIdx);
DumpHulls(hulls);
hulls.Dump();
}
}
public PacketLocation(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
VerPack = WorkBuffer.GetByte(ref data);
Packet_Time = WorkBuffer.GetUInt64(ref data);
Latitude = WorkBuffer.GetFloat(ref data);
Longitude = WorkBuffer.GetFloat(ref data);
Altitude = WorkBuffer.GetUInt16(ref data);
Fix = WorkBuffer.GetByte(ref data);
Hdop = WorkBuffer.GetByte(ref data);
Num = WorkBuffer.GetByte(ref data);
Num &= 0x7F;
PLMN = WorkBuffer.GetUInt32(ref data);
for (int i = 0; i < CCID.Length; i++)
{
CCID[i] = WorkBuffer.GetByte(ref data);
}
for (int i = 0; i < (Num); i++)
{
cellInfo.Add(new CellInfo(data));
}
CRC32 = WorkBuffer.GetUInt32(ref data);
}
private int Locate(WorkBuffer <Int3> cells, int a, int b, int c)
{
var x = a;
var y = b;
var z = c;
if (b < c)
{
if (b < a)
{
x = b;
y = c;
z = a;
}
}
else if (c < a)
{
x = c;
y = a;
z = b;
}
if (x < 0)
{
return(-1);
}
return(BinarySearch.EQ(cells.Data, new Int3(x, y, z), 0, cells.UsedSize - 1));
}
private void AddPoint(List <int> cells, WorkBuffer <PartialHull> hulls, List <Vector3> points, Vector2 p, int idx)
{
var lo = BinarySearch.LT(hulls.Data, p, TestPoint.Default, 0, hulls.UsedSize - 1);
var hi = BinarySearch.GT(hulls.Data, p, TestPoint.Default, 0, hulls.UsedSize - 1);
for (var i = lo; i < hi; ++i)
{
var hull = hulls.Data[i];
//Insert p into lower hull
{
var lowerIds = hull.LowerIds;
var m = lowerIds.UsedSize;
var lowerIdsData = lowerIds.Data;
while (m > 1 && Robust.Orientation(points[lowerIdsData[m - 2]], points[lowerIdsData[m - 1]], p) > 0f)
{
cells.Add(lowerIdsData[m - 1]);
cells.Add(lowerIdsData[m - 2]);
cells.Add(idx);
m -= 1;
}
if (m < lowerIds.UsedSize)
{
lowerIds.RemoveLast(lowerIds.UsedSize - m);
}
lowerIds.Push(ref idx);
}
//Insert p into upper hull
{
var upperIds = hull.UpperIds;
var m = upperIds.UsedSize;
var upperIdsData = upperIds.Data;
while (m > 1 && Robust.Orientation(points[upperIdsData[m - 2]], points[upperIdsData[m - 1]], p) < 0f)
{
cells.Add(upperIdsData[m - 2]);
cells.Add(upperIdsData[m - 1]);
cells.Add(idx);
m -= 1;
}
if (m < upperIds.UsedSize)
{
upperIds.RemoveLast(upperIds.UsedSize - m);
}
upperIds.Push(ref idx);
}
}
if (Verbose)
{
Debug.Log("Add");
DumpHulls(hulls);
hulls.Dump();
}
}
private void CreateStars(int n)
{
var stars = new WorkBuffer <Int2> [n];
for (var i = 0; i < n; ++i)
{
stars[i] = new WorkBuffer <Int2>(16);
}
PrivateStars = stars;
}
public PacketGenericResponse(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
ComServer = new CommandFromServer(data);
CRC32 = WorkBuffer.GetUInt32(ref data);
}
public bool Parsing(ref List <byte> data)
{
int length = data.Count;
Type.Check(WorkBuffer.GetByte(ref data));
if (Type.type == PacketType.TypePacket.Null)
{
return(false);
}
Seq = WorkBuffer.GetUInt32(ref data);
return(true);
}
private byte[] CCID = new byte[20]; // CCID of device
public PacketRequestOptions(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
Packet_Time = WorkBuffer.GetUInt64(ref data);
for (int i = 0; i < CCID.Length; i++)
{
CCID[i] = WorkBuffer.GetByte(ref data);
}
CRC32 = WorkBuffer.GetUInt32(ref data);
}
private void RemovePair(WorkBuffer <Int2> list, int j, int k)
{
var n = list.UsedSize;
var data = list.Data;
for (var i = 0; i < n; ++i)
{
var s = data[i];
if (s.x == j && s.y == k)
{
data[i] = data[n - 1];
list.RemoveLast(1);
return;
}
}
}
private void FilterCells(WorkBuffer <Int3> cells, WorkBuffer <int> flags)
{
var ptr = 0;
var n = cells.UsedSize;
var cellsData = cells.Data;
var flagsData = flags.Data;
for (var i = 0; i < n; ++i)
{
if (flagsData[i] == Target)
{
cellsData[ptr++] = cellsData[i];
}
}
cells.RemoveLast(n - ptr);
}
public PacketResponseOptions(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
NewTime = WorkBuffer.GetUInt64(ref data);
ActivityPeriod = WorkBuffer.GetByte(ref data);
Indication = WorkBuffer.GetByte(ref data);
TelemetryPeriod = WorkBuffer.GetUInt16(ref data);
ComServer = new CommandFromServer(data);
CRC32 = WorkBuffer.GetUInt32(ref data);
}
private E_Event_Result Update; // State update (#EER_TRUE if update is need, else #EER_FALSE)
public PacketUpdateResponse(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
FileSize = WorkBuffer.GetUInt32(ref data);
FileCRC = WorkBuffer.GetUInt32(ref data);
for (int i = 0; i < Version.Length; i++)
{
Version[i] = WorkBuffer.GetByte(ref data);
}
Update = (E_Event_Result)WorkBuffer.GetByte(ref data);
CRC32 = WorkBuffer.GetUInt32(ref data);
}
private void FillTriangles(WorkBuffer <Int3> from, List <int> to)
{
var n = from.UsedSize;
if (to.Capacity < n * 3)
{
to.Capacity = n * 3;
}
var data = from.Data;
for (var i = 0; i < n; ++i)
{
var v = data[i];
to.Add(v.x);
to.Add(v.y);
to.Add(v.z);
}
}
public TelemetryType(List <byte> data)
{
if (CheckType(data[0]))
{
this.Type = (TypeTel)data[0];
}
else
{
this.Type = TypeTel.NONE;
}
data.RemoveAt(0);
this.Data = WorkBuffer.GetUInt32(ref data);
if (Type != TypeTel.NONE)
{
Parsing();
}
}
private byte[] CCID = new byte[20]; // CCID of device
public PacketActivity(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
Packet_Time = WorkBuffer.GetUInt64(ref data);
Step = WorkBuffer.GetUInt16(ref data);
Hi_Act_Time = WorkBuffer.GetUInt16(ref data);
Low_Act_Time = WorkBuffer.GetUInt16(ref data);
CSQ = WorkBuffer.GetFloat(ref data);
Charge = WorkBuffer.GetByte(ref data);
for (int i = 0; i < CCID.Length; i++)
{
CCID[i] = WorkBuffer.GetByte(ref data);
}
CRC32 = WorkBuffer.GetUInt32(ref data);
}
private byte[] CCID = new byte[20]; // CCID of device
public PacketStatistic(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
Mode = (CommandFromServer.Type)WorkBuffer.GetByte(ref data);
RX_packets = WorkBuffer.GetUInt32(ref data);
TX_packets = WorkBuffer.GetUInt32(ref data);
Out_bytes = WorkBuffer.GetUInt32(ref data);
In_bytes = WorkBuffer.GetUInt32(ref data);
for (int i = 0; i < CCID.Length; i++)
{
CCID[i] = WorkBuffer.GetByte(ref data);
}
CRC32 = WorkBuffer.GetUInt32(ref data);
}
private void MergeHulls(WorkBuffer <PartialHull> hulls, Event e)
{
//Swap pointers for merge search
var tmp = e.A;
e.A = e.B;
e.B = tmp;
var mergeIdx = BinarySearch.EQ(hulls.Data, e, FindSplit.Default, 0, hulls.UsedSize - 1);
var upper = hulls.Data[mergeIdx];
var lower = hulls.Data[mergeIdx - 1];
lower.UpperIds = upper.UpperIds;
hulls.RemoveAt(mergeIdx);
if (Verbose)
{
Debug.Log("Merge: " + mergeIdx);
DumpHulls(hulls);
hulls.Dump();
}
}
private byte[] CCID = new byte[20]; // CCID of device
public PacketDeviceInfo(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
Packet_Time = WorkBuffer.GetUInt64(ref data);
Num = WorkBuffer.GetByte(ref data);
Error = (E_Device_Error)WorkBuffer.GetByte(ref data);
Warning = (E_Device_Warning)WorkBuffer.GetByte(ref data);
Info = (E_Device_Info)WorkBuffer.GetByte(ref data);
for (int i = 0; i < CCID.Length; i++)
{
CCID[i] = WorkBuffer.GetByte(ref data);
}
CRC32 = WorkBuffer.GetUInt32(ref data);
}
private byte[] CCID = new byte[20]; // CCID of device
public PacketResultUpdate(List<byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
Packet_Time = WorkBuffer.GetUInt64(ref data);
for (int i = 0; i < Version.Length; i++)
{
Version[i] = WorkBuffer.GetByte(ref data);
}
Update = (E_Status_Update)WorkBuffer.GetByte(ref data);
for (int i = 0; i < CCID.Length; i++)
{
CCID[i] = WorkBuffer.GetByte(ref data);
}
CRC32 = WorkBuffer.GetUInt32(ref data);
}
public PacketTelemetry(List <byte> data)
{
if (Parsing(ref data) == false)
{
MessageBox.Show("Not correct data", "Warning", MessageBoxButton.OK);
return;
}
Packet_Time = WorkBuffer.GetUInt64(ref data);
Num = WorkBuffer.GetUInt16(ref data);
for (int i = 0; i < CCID.Length; i++)
{
CCID[i] = WorkBuffer.GetByte(ref data);
}
for (int i = 0; i < Num; i++)
{
TMList.Add(new TelemetryType(data));
}
CRC32 = WorkBuffer.GetUInt32(ref data);
}
public void Fill(WorkBuffer <Int3> triangles)
{
var n = PrivateStars.Length;
triangles.Extend(n);
triangles.Clear();
for (var i = 0; i < n; ++i)
{
var list = PrivateStars[i];
var data = list.Data;
var m = list.UsedSize;
for (var j = 0; j < m; ++j)
{
var s = data[j];
if (i < Mathf.Min(s.x, s.y))
{
var v = new Int3(i, s.x, s.y);
triangles.Push(ref v);
}
}
}
}
public void BuildTriangles(MeshData data)
{
var numPoints = data.Vertices.Count;
var numEdges = data.Edges.Count;
data.Triangles.Capacity = numPoints * 3;
var events = WorkBufferPool.Get <Event>();
if (events.NewForClass == null)
{
events.NewForClass = () => new Event();
}
//Create point events
for (var i = 0; i < numPoints; ++i)
{
var e = events.Push();
e.A = data.Vertices[i];
e.B = Vector2.zero;
e.Type = EventType.Point;
e.Index = i;
}
//Create edge events
for (var i = 0; i < numEdges; ++i)
{
var edge = data.Edges[i];
var a = data.Vertices[edge.x];
var b = data.Vertices[edge.y];
if (a.x < b.x)
{
{
var e = events.Push();
e.A = a;
e.B = b;
e.Type = EventType.Start;
e.Index = i;
}
{
var e = events.Push();
e.A = b;
e.B = a;
e.Type = EventType.End;
e.Index = i;
}
}
else if (a.x > b.x)
{
{
var e = events.Push();
e.A = b;
e.B = a;
e.Type = EventType.Start;
e.Index = i;
}
{
var e = events.Push();
e.A = a;
e.B = b;
e.Type = EventType.End;
e.Index = i;
}
}
}
//Sort events
WorkBuffer <Event> .Sort(events);
if (Verbose)
{
DumpEvents(events);
}
//Initialize hull
var minX = events.Data[0].A.x - 1f;
var hulls = WorkBufferPool.Get <PartialHull>();
if (hulls.NewForClass == null)
{
hulls.NewForClass = () => new PartialHull();
}
var h = hulls.Push();
h.A = new Vector2(minX, 1f);
h.B = new Vector2(minX, 0f);
h.Index = -1;
h.LowerIds.Clear();
h.UpperIds.Clear();
//Process events in order
var numEvents = events.UsedSize;
for (var i = 0; i < numEvents; ++i)
{
var e = events.Data[i];
if (Verbose)
{
Debug.Log("");
Debug.Log(i);
DumpEvent(e);
}
switch (e.Type)
{
case EventType.Point:
AddPoint(data.Triangles, hulls, data.Vertices, e.A, e.Index);
break;
case EventType.Start:
SplitHulls(hulls, e);
break;
case EventType.End:
MergeHulls(hulls, e);
break;
}
if (Verbose)
{
Debug.Log("");
}
}
WorkBufferPool.Release(ref hulls);
WorkBufferPool.Release(ref events);
}
private string ToString(WorkBuffer <int> list)
{
return(string.Join(", ", list.Data.Take(list.UsedSize).Select(_ => _.ToString()).ToArray()));
}
private void DumpHulls(WorkBuffer <PartialHull> hulls)
{
Debug.Log(hulls.Data.Take(hulls.UsedSize)
.Select(_ => string.Format("{{ a: {0}, b: {1}, idx: {2}, lowerIds: [ {3} ], upperIds: [ {4} ] }}", _.A, _.B, _.Index, ToString(_.LowerIds), ToString(_.UpperIds)))
.Aggregate("", (_, s) => _ + s + "\n"));
}
private void DumpEvents(WorkBuffer <Event> events)
{
Debug.Log(events.Data.Take(events.UsedSize)
.Select(_ => string.Format("{{ a: {0}, b: {1}, type: {2}, idx: {3} }}", _.A, _.B, _.Type, _.Index))
.Aggregate("", (_, s) => _ + s + "\n"));
}
} /*!< Number of point*/
public GeoFence(List <byte> data)
{
Latitude = WorkBuffer.GetFloat(ref data);
Longitude = WorkBuffer.GetFloat(ref data);
Index = WorkBuffer.GetByte(ref data);
}
} // RSSI base station
public CellInfo(List <byte> data)
{
LAC = WorkBuffer.GetUInt16(ref data);
CELL_ID = WorkBuffer.GetUInt32(ref data);
RSSI = WorkBuffer.GetByte(ref data);
}
private FaceIndex IndexCells(Triangles triangles)
{
var zero = 0;
var fals = false;
var index = new FaceIndex(WorkBufferPool);
triangles.Fill(index.Cells);
//First get cells and canonicalize
var cells = index.Cells;
var nc = cells.UsedSize;
var cellsData = cells.Data;
for (var i = 0; i < nc; ++i)
{
var c = cellsData[i];
var x = c.x;
var y = c.y;
var z = c.z;
if (y < z)
{
if (y < x)
{
c.x = y;
c.y = z;
c.z = x;
cellsData[i] = c;
}
}
else if (z < x)
{
c.x = z;
c.y = x;
c.z = y;
cellsData[i] = c;
}
}
WorkBuffer <Int3> .Sort(cells);
//Initialize flag array
var flags = index.Flags;
flags.Fill(ref zero, nc);
//Build neighbor index, initialize queues
var active = index.Active;
var next = index.Next;
var neighbor = index.Neighbor;
var constraint = index.Constraint;
var boundary = index.Boundary;
neighbor.Fill(ref zero, nc * 3);
constraint.Fill(ref fals, nc * 3);
var flagsData = flags.Data;
var neighborData = neighbor.Data;
var constraintData = constraint.Data;
for (var i = 0; i < nc; ++i)
{
var c = cellsData[i];
for (var j = 0; j < 3; ++j)
{
var x = 0;
var y = 0;
switch (j)
{
case 0:
x = c.x;
y = c.y;
break;
case 1:
x = c.y;
y = c.z;
break;
case 2:
x = c.z;
y = c.x;
break;
}
var a = neighborData[3 * i + j] = Locate(cells, y, x, triangles.Opposite(y, x));
var b = constraintData[3 * i + j] = triangles.IsConstraint(x, y);
if (a < 0)
{
if (b)
{
next.Push(ref i);
}
else
{
active.Push(ref i);
flagsData[i] = 1;
}
if (Infinity)
{
var v = new Int3(y, x, -1);
boundary.Push(ref v);
}
}
}
}
return(index);
}
