public void ValidateAsProtoMessageLite_ShouldReturnInvalidArgument_When_ValueIsBool()
{
using (var packet = new BoolPacket(true))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, packet.ValidateAsProtoMessageLite().Code());
}
}
public void RegisteredTypeName_ShouldReturnEmptyString()
{
using (var packet = new BoolPacket())
{
Assert.AreEqual("", packet.RegisteredTypeName());
}
}
public override Status StartRun()
{
handLandmarksStreamPoller = graph.AddOutputStreamPoller <List <NormalizedLandmarkList> >(handLandmarksStream).ConsumeValueOrDie();
handLandmarksPacket = new NormalizedLandmarkListVectorPacket();
handednessStreamPoller = graph.AddOutputStreamPoller <List <ClassificationList> >(handednessStream).ConsumeValueOrDie();
handednessPacket = new ClassificationListVectorPacket();
palmDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(palmDetectionsStream).ConsumeValueOrDie();
palmDetectionsPacket = new DetectionVectorPacket();
palmRectsStreamPoller = graph.AddOutputStreamPoller <List <NormalizedRect> >(palmRectsStream).ConsumeValueOrDie();
palmRectsPacket = new NormalizedRectVectorPacket();
handLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(handLandmarksPresenceStream).ConsumeValueOrDie();
handLandmarksPresencePacket = new BoolPacket();
palmDetectionsPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(palmDetectionsPresenceStream).ConsumeValueOrDie();
palmDetectionsPresencePacket = new BoolPacket();
sidePacket = new SidePacket();
sidePacket.Emplace("num_hands", new IntPacket(2));
return(graph.StartRun(sidePacket));
}
public void DebugString_ShouldReturnDebugString_When_InstantiatedWithDefaultConstructor()
{
using (var packet = new BoolPacket())
{
Assert.AreEqual("mediapipe::Packet with timestamp: Timestamp::Unset() and no data", packet.DebugString());
}
}
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new BoolPacket())
{
Assert.False(packet.isDisposed);
}
}
public void DebugTypeName_ShouldReturnTypeName_When_ValueIsNotSet()
{
using (var packet = new BoolPacket())
{
Assert.AreEqual("{empty}", packet.DebugTypeName());
}
}
public void DebugTypeName_ShouldReturnBool_When_ValueIsSet()
{
using (var packet = new BoolPacket(true))
{
Assert.AreEqual("bool", packet.DebugTypeName());
}
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
var packet = new BoolPacket();
Assert.AreEqual(packet.ValidateAsType().code, Status.StatusCode.Internal);
Assert.Throws <MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(packet.Timestamp(), Timestamp.Unset());
}
public void isDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new BoolPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithFalse()
{
var packet = new BoolPacket(false);
Assert.True(packet.ValidateAsType().ok);
Assert.False(packet.Get());
Assert.AreEqual(packet.Timestamp(), Timestamp.Unset());
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithValueAndTimestamp()
{
var timestamp = new Timestamp(1);
var packet = new BoolPacket(true, timestamp);
Assert.True(packet.ValidateAsType().ok);
Assert.True(packet.Get());
Assert.AreEqual(packet.Timestamp(), timestamp);
}
// GET: api/Gateway
public GatewayStatus Get()
{
Gateway gw = GatewayPersistence.Instance.Current;
GatewayStatus gws = new GatewayStatus(gw);
BoolPacket bp = GatewayLinker.Instance.GetValue <BoolPacket>(new CodePacket(MessageCode.IsServerStarted));
gws.IsStarted = bp == null ? false : bp.Value;
return(gws);
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithTrue()
{
using (var packet = new BoolPacket(true))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.True(packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
public void Consume_ShouldThrowNotSupportedException()
{
using (var packet = new BoolPacket())
{
#pragma warning disable IDE0058
Assert.Throws <NotSupportedException>(() => { packet.Consume(); });
#pragma warning restore IDE0058
}
}
public override Status StartRun(SidePacket sidePacket)
{
landmarkStreamPoller = graph.AddOutputStreamPoller <List <Landmark[]> >(landmarkStream).ConsumeValue();
landmarkPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(landmarkPresenceStream).ConsumeValue();
landmarkListPacket = new NormalizedLandmarkListVectorPacket();
landmarkPresencePacket = new BoolPacket();
return(graph.StartRun(sidePacket));
}
public override Status StartRun()
{
faceDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(faceDetectionsStream).ConsumeValueOrDie();
faceDetectionsPacket = new DetectionVectorPacket();
faceDetectionsPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(faceDetectionsPresenceStream).ConsumeValueOrDie();
faceDetectionsPresencePacket = new BoolPacket();
return(graph.StartRun());
}
public void size_ShouldReturnSize_When_AfterPacketsAreEmplaced()
{
var sidePacket = new SidePacket();
var flagPacket = new BoolPacket(true);
var valuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("flag", flagPacket);
sidePacket.Emplace("value", valuePacket);
Assert.AreEqual(sidePacket.size, 2);
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new BoolPacket())
{
#pragma warning disable IDE0058
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.Throws <MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
#pragma warning restore IDE0058
}
}
public void TestBoolPacket()
{
BoolPacket v1 = new BoolPacket(true);
var buffer = ByteBufferAllocator.Instance.Allocate(sizeof(bool));
Serializer.Serialize(buffer, v1);
Assert.AreEqual(sizeof(bool), buffer.Position);
buffer.Rewind();
BoolPacket v2 = Serializer.Deserialize<BoolPacket>(buffer);
Assert.AreEqual(v1, v2);
Assert.AreEqual(sizeof(bool), buffer.Position);
}
public void Size_ShouldReturnSize_When_AfterPacketsAreEmplaced()
{
using (var sidePacket = new SidePacket())
{
var flagPacket = new BoolPacket(true);
var valuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("flag", flagPacket);
sidePacket.Emplace("value", valuePacket);
Assert.AreEqual(2, sidePacket.size);
Assert.True(flagPacket.isDisposed);
Assert.True(valuePacket.isDisposed);
}
}
public void TestBoolPacketLE()
{
BoolPacket v1 = new BoolPacket(true);
int bufferSize = sizeof(bool) + CDRHeaderSize;
var buffer = ByteBufferAllocator.Instance.Allocate(bufferSize);
CDREncapsulation.Serialize(buffer, v1, ByteOrder.LittleEndian);
Assert.AreEqual(bufferSize, buffer.Position);
buffer.Rewind();
Assert.AreEqual("00 01 00 00 01", buffer.GetHexDump());
BoolPacket v2 = CDREncapsulation.Deserialize<BoolPacket>(buffer);
Assert.AreEqual(v1, v2);
Assert.AreEqual(bufferSize, buffer.Position);
}
// POST: api/Gateway
public IHttpActionResult Post([FromBody] Gateway plat)
{
if (plat == null)
{
return(BadRequest("提交的网关数据是一个空值"));
}
GatewayPersistence.Instance.Put(Gateway.Key, plat);
BoolPacket bp = GatewayLinker.Instance.GetValue <BoolPacket>(new CodePacket(MessageCode.IsServerStarted));
if (bp != null && bp.Value)
{
GatewayLinker.Instance.SendCommand(new CodePacket(MessageCode.StartServer));
}
return(Ok("配置网关信息成功"));
}
public override Status StartRun(SidePacket sidePacket)
{
multiHandLandmarksStreamPoller = graph.AddOutputStreamPoller <List <NormalizedLandmarkList> >(multiHandLandmarksStream).ConsumeValue();
multiHandLandmarksPacket = new NormalizedLandmarkListVectorPacket();
multiPalmDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(multiPalmDetectionsStream).ConsumeValue();
multiPalmDetectionsPacket = new DetectionVectorPacket();
multiPalmRectsStreamPoller = graph.AddOutputStreamPoller <List <NormalizedRect> >(multiPalmRectsStream).ConsumeValue();
multiPalmRectsPacket = new NormalizedRectVectorPacket();
multiPalmDetectionsPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(multiPalmDetectionsPresenceStream).ConsumeValue();
multiPalmDetectionsPresencePacket = new BoolPacket();
return(graph.StartRun(sidePacket));
}
public override Status StartRun()
{
poseLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(poseLandmarksStream).ConsumeValueOrDie();
poseLandmarksPacket = new NormalizedLandmarkListPacket();
poseDetectionStreamPoller = graph.AddOutputStreamPoller <Detection>(poseDetectionStream).ConsumeValueOrDie();
poseDetectionPacket = new DetectionPacket();
poseLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseLandmarksPresenceStream).ConsumeValueOrDie();
poseLandmarksPresencePacket = new BoolPacket();
poseDetectionPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseDetectionPresenceStream).ConsumeValueOrDie();
poseDetectionPresencePacket = new BoolPacket();
return(graph.StartRun());
}
public void TestBoolPacketLE()
{
BoolPacket v1 = new BoolPacket(true);
int expectedSize = headerSize + paramHeaderSize + byteBoundary + paramSentinelSize;
string expectedRst = "00 03 00 00 0C 00 00 00 " + // Header
"00 80 04 00 01 00 00 00 " + // Parameter
"01 00 00 00"; // Sentinel
var buffer = ByteBufferAllocator.Instance.Allocate(expectedSize);
ParameterListEncapsulation.Serialize(buffer, v1, ByteOrder.LittleEndian);
Assert.AreEqual(expectedSize, buffer.Position);
buffer.Rewind();
Assert.AreEqual(expectedRst, buffer.GetHexDump(expectedSize));
BoolPacket v2 = ParameterListEncapsulation.Deserialize<BoolPacket>(buffer);
Assert.AreEqual(v1, v2);
Assert.AreEqual(expectedSize, buffer.Position);
}
public override Status StartRun()
{
poseLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(poseLandmarksStream).Value();
poseLandmarksPacket = new NormalizedLandmarkListPacket();
poseRoiStreamPoller = graph.AddOutputStreamPoller <NormalizedRect>(poseRoiStream).Value();
poseRoiPacket = new NormalizedRectPacket();
poseDetectionStreamPoller = graph.AddOutputStreamPoller <Detection>(poseDetectionStream).Value();
poseDetectionPacket = new DetectionPacket();
faceLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(faceLandmarksStream).Value();
faceLandmarksPacket = new NormalizedLandmarkListPacket();
leftHandLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(leftHandLandmarksStream).Value();
leftHandLandmarksPacket = new NormalizedLandmarkListPacket();
rightHandLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(rightHandLandmarksStream).Value();
rightHandLandmarksPacket = new NormalizedLandmarkListPacket();
poseLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseLandmarksPresenceStream).Value();
poseLandmarksPresencePacket = new BoolPacket();
poseRoiPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseRoiPresenceStream).Value();
poseRoiPresencePacket = new BoolPacket();
poseDetectionPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseDetectionPresenceStream).Value();
poseDetectionPresencePacket = new BoolPacket();
faceLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(faceLandmarksPresenceStream).Value();
faceLandmarksPresencePacket = new BoolPacket();
leftHandLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(leftHandLandmarksPresenceStream).Value();
leftHandLandmarksPresencePacket = new BoolPacket();
rightHandLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(rightHandLandmarksPresenceStream).Value();
rightHandLandmarksPresencePacket = new BoolPacket();
sidePacket = new SidePacket();
sidePacket.Emplace("enable_iris_detection", new BoolPacket(detectIris));
sidePacket.Emplace("model_complexity", new IntPacket((int)modelComplexity));
sidePacket.Emplace("smooth_landmarks", new BoolPacket(smoothLandmarks));
return(graph.StartRun(sidePacket));
}
public override Status StartRun()
{
poseLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(poseLandmarksStream).ConsumeValueOrDie();
poseLandmarksPacket = new NormalizedLandmarkListPacket();
poseRoiStreamPoller = graph.AddOutputStreamPoller <NormalizedRect>(poseRoiStream).ConsumeValueOrDie();
poseRoiPacket = new NormalizedRectPacket();
poseDetectionStreamPoller = graph.AddOutputStreamPoller <Detection>(poseDetectionStream).ConsumeValueOrDie();
poseDetectionPacket = new DetectionPacket();
faceLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(faceLandmarksStream).ConsumeValueOrDie();
faceLandmarksPacket = new NormalizedLandmarkListPacket();
leftHandLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(leftHandLandmarksStream).ConsumeValueOrDie();
leftHandLandmarksPacket = new NormalizedLandmarkListPacket();
rightHandLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(rightHandLandmarksStream).ConsumeValueOrDie();
rightHandLandmarksPacket = new NormalizedLandmarkListPacket();
poseLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseLandmarksPresenceStream).ConsumeValueOrDie();
poseLandmarksPresencePacket = new BoolPacket();
poseRoiPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseRoiPresenceStream).ConsumeValueOrDie();
poseRoiPresencePacket = new BoolPacket();
poseDetectionPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(poseDetectionPresenceStream).ConsumeValueOrDie();
poseDetectionPresencePacket = new BoolPacket();
faceLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(faceLandmarksPresenceStream).ConsumeValueOrDie();
faceLandmarksPresencePacket = new BoolPacket();
leftHandLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(leftHandLandmarksPresenceStream).ConsumeValueOrDie();
leftHandLandmarksPresencePacket = new BoolPacket();
rightHandLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(rightHandLandmarksPresenceStream).ConsumeValueOrDie();
rightHandLandmarksPresencePacket = new BoolPacket();
sidePacket = new SidePacket();
var irisFlag = new BoolPacket(detectIris);
sidePacket.Emplace("enable_iris_detection", irisFlag);
return(graph.StartRun(sidePacket));
}
public IEnumerable <PlatformStatus> GetPlatformWithStatus()
{
IEnumerable <Platform> plats = getAllLowerPlats();
if (plats != null)
{
List <PlatformStatus> pStatus = new List <PlatformStatus>();
foreach (Platform p in plats)
{
PlatformStatus pfs = new PlatformStatus(p);
BoolPacket bp = GatewayLinker.Instance.GetValue <BoolPacket>(new StringPacket(MessageCode.IsLowerOnline, p.Id));
pfs.Online = bp == null ? false : bp.Value; //获取状态。
pStatus.Add(pfs);
}
return(pStatus);
}
return(null);
}
public void At_ShouldReturnNewPacketWithTimestamp()
{
var timestamp = new Timestamp(1);
var packet = new BoolPacket(true).At(timestamp);
Assert.True(packet.Get());
Assert.AreEqual(packet.Timestamp(), timestamp);
var newTimestamp = new Timestamp(2);
var newPacket = packet.At(newTimestamp);
Assert.IsInstanceOf <BoolPacket>(newPacket);
Assert.True(newPacket.Get());
Assert.AreEqual(newPacket.Timestamp(), newTimestamp);
Assert.True(packet.Get());
Assert.AreEqual(packet.Timestamp(), timestamp);
}
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var packet = new BoolPacket(true).At(timestamp);
Assert.True(packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.True(newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
public override Status StartRun(SidePacket sidePacket)
{
handednessStreamPoller = graph.AddOutputStreamPoller <ClassificationList>(handednessStream).ConsumeValue();
handednessPacket = new ClassificationListPacket();
handRectStreamPoller = graph.AddOutputStreamPoller <NormalizedRect>(handRectStream).ConsumeValue();
handRectPacket = new NormalizedRectPacket();
handLandmarksStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(handLandmarksStream).ConsumeValue();
handLandmarksPacket = new NormalizedLandmarkListPacket();
palmDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(palmDetectionsStream).ConsumeValue();
palmDetectionsPacket = new DetectionVectorPacket();
palmDetectionsPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(palmDetectionsPresenceStream).ConsumeValue();
palmDetectionsPresencePacket = new BoolPacket();
return(graph.StartRun(sidePacket));
}
public override Status StartRun(SidePacket sidePacket)
{
faceLandmarksWithIrisStreamPoller = graph.AddOutputStreamPoller <NormalizedLandmarkList>(faceLandmarksWithIrisStream).ConsumeValue();
faceLandmarksWithIrisPacket = new NormalizedLandmarkListPacket();
faceRectStreamPoller = graph.AddOutputStreamPoller <NormalizedRect>(faceRectStream).ConsumeValue();
faceRectPacket = new NormalizedRectPacket();
faceDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(faceDetectionsStream).ConsumeValue();
faceDetectionsPacket = new DetectionVectorPacket();
faceLandmarksWithIrisPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(faceLandmarksWithIrisPresenceStream).ConsumeValue();
faceLandmarksWithIrisPresencePacket = new BoolPacket();
faceDetectionsPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(faceDetectionsPresenceStream).ConsumeValue();
faceDetectionsPresencePacket = new BoolPacket();
return(graph.StartRun(sidePacket));
}
public override Status StartRun()
{
multiFaceLandmarksStreamPoller = graph.AddOutputStreamPoller <List <NormalizedLandmarkList> >(multiFaceLandmarksStream).ConsumeValueOrDie();
multiFaceLandmarksPacket = new NormalizedLandmarkListVectorPacket();
faceRectsFromLandmarksStreamPoller = graph.AddOutputStreamPoller <List <NormalizedRect> >(faceRectsFromLandmarksStream).ConsumeValueOrDie();
faceRectsFromLandmarksPacket = new NormalizedRectVectorPacket();
faceDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(faceDetectionsStream).ConsumeValueOrDie();
faceDetectionsPacket = new DetectionVectorPacket();
multiFacelandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(multiFaceLandmarksPresenceStream).ConsumeValueOrDie();
multiFaceLandmarksPresencePacket = new BoolPacket();
faceDetectionsPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(faceDetectionsPresenceStream).ConsumeValueOrDie();
faceDetectionsPresencePacket = new BoolPacket();
sidePacket = new SidePacket();
sidePacket.Emplace("num_faces", new IntPacket(numFaces));
return(graph.StartRun(sidePacket));
}
