/// <summary>
/// Sends the data.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="frame">The base frame.</param>
private void SendFrame(Http2Stream stream, BaseFrame frame)
{
try
{
byte[] frameBinary = this.serializer.Serialize(frame);
frame.Length = frameBinary.Length;
SendMessage(frameBinary);
if (frame.IsFinal)
{
stream.State = Http2StreamState.HalfClosed;
}
if (this.OnFrameSent != null)
{
this.OnFrameSent(this, new FrameEventArgs(frame));
}
}
catch (Exception e)
{
if (this.OnStreamError != null)
{
this.OnStreamError(this, new StreamErrorEventArgs(stream, e));
}
else if (this.OnError != null)
{
this.OnError(this, new ProtocolErrorEventArgs(e));
}
else
{
throw;
}
}
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
if (Group != null)
{
hashCode = hashCode * 59 + Group.GetHashCode();
}
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (Traces != null)
{
hashCode = hashCode * 59 + Traces.GetHashCode();
}
if (BaseFrame != null)
{
hashCode = hashCode * 59 + BaseFrame.GetHashCode();
}
if (Data != null)
{
hashCode = hashCode * 59 + Data.GetHashCode();
}
if (Layout != null)
{
hashCode = hashCode * 59 + Layout.GetHashCode();
}
return(hashCode);
}
}
private void ProcessingThread_DoWork()
{
while (true)
{
BaseFrame frame = imageStream.GetFrame();
try
{
if (frame != null)
{
Bitmap bitmap = frame.GetBMP();
Image <Bgr, Byte> image = new Image <Bgr, byte>(bitmap);
List <DetectedDoor> doors = GetDoors(image);
DoorDetectedEventArgs args = new DoorDetectedEventArgs(doors, DetectedDoor.DetectMethod.COLOR);
if (OnDoorDetected != null)
{
OnDoorDetected(this, args);
}
}
Thread.Sleep(UPDATE_INTERVAL);
}
catch (Exception e)
{
//
}
}
}
public void GetFrameReader(string s, Type t, params int[] p)
{
BaseFrame frame = GameReader.GetFrame(s);
Assert.Equal(t, frame.GetType());
Assert.Equal <int>(p, frame.PinsPerBall);
}
public void VFrameTest_LT_1Sec()
{
string[] files = Directory.GetFiles("C:\\KStudioRepo", "*.xef");
Array.Sort(files);
using (KStudioClient client = KStudio.CreateClient()) {
client.ConnectToService();
var broken = false;
using (KStudioPlayback playback = client.CreatePlayback(files[0])) {
//Console.WriteLine("Playing: {0}", files[0]);
playback.Start();
Stopwatch time = new Stopwatch();
VideoStream stream = VideoStream.Instance;
while (playback.State == KStudioPlaybackState.Playing)
{
time.Start();
BaseFrame frame = stream.GetFrame();
if (time.ElapsedMilliseconds > (1 * 1000))
{
if (frame == null)
{
broken = true;
System.DateTime now = DateTime.Now;
//System.Diagnostics.////Debug.WriteLine("Failed at: {0}:{1}:{2}:{3}", now.Hour, now.Minute, now.Second, now.Millisecond);
}
}
Thread.Sleep(150);
}
}
client.DisconnectFromService();
Assert.IsFalse(broken, "The frame should not be null after 1 second");
}
}
public void RegisterFrame(BaseFrame frame, FlowInformation flowInformation)
{
if (this.FlowInformation.ContainsKey(frame))
{
throw new Exception("This frame has already been registered");
}
this.FlowInformation[frame] = flowInformation;
}
public void DisplayInitialFrame(BaseFrame frame)
{
if (!this.FlowInformation.ContainsKey(frame))
{
throw new Exception("This frame has already not been registered");
}
this.CurrentFrame = frame;
this.FrameStack.Push(frame);
this.UpdateDisplayedFrame();
}
public override bool Equals(object obj)
{
if (!(obj is IFrameTransformation))
{
return(false);
}
IFrameTransformation other = (IFrameTransformation)obj;
return((BaseFrame == other.BaseFrame || BaseFrame.Equals(other.BaseFrame)) &&
(ToFrame == other.ToFrame || ToFrame.Equals(other.ToFrame)));
}
private void button2_Click(object sender, EventArgs e)
{
//string sends = textBox1.Text;
//string result = Send(sends);
//richTextBox1.Text = result;
byte[] bytef = System.Text.Encoding.ASCII.GetBytes(System.DateTime.UtcNow.ToString());
BaseFrame bf = new BaseFrame(Protocol.Test, ProtocolSub.Test, bytef);
byte[] body = Convert.StructToBytes(bf);
byte[] head = BitConverter.GetBytes((short)body.Length);
aSocketClient.Send(head.Concat(body).ToArray());
}
/// <summary>
/// This function iterates over all possible IDs and calls the binding function to get a scalar
/// pattern. If the function return null on a pattern and ignoreNullPatterns is true no binding
/// is done for this ID. If the function return null on a pattern and ignoreNullPatterns is false
/// the ID is un-bound from this multivector pattern
/// </summary>
/// <param name="bindingFunction"></param>
/// <param name="ignoreNullPatterns"></param>
/// <returns></returns>
public GMacMultivectorBinding BindUsing(Func <AstFrameBasisBlade, GMacScalarBinding> bindingFunction, bool ignoreNullPatterns = true)
{
for (var id = 0; id < BaseFrame.GaSpaceDimension; id++)
{
var scalarPattern = bindingFunction(BaseFrame.BasisBlade(id));
if (ignoreNullPatterns == false || scalarPattern != null)
{
BindCoefToPattern(id, scalarPattern);
}
}
return(this);
}
//Render the background
private void UpdateBackground()
{
//const DispatcherPriority priority = DispatcherPriority.Render;
while (true)
{
BaseFrame frame = null;
WriteableBitmap frameBitmap = null;
ColorBasedDoorDetector cDetector = _doorDetector as ColorBasedDoorDetector;
if (cDetector != null)
{
frame = VideoStream.Instance.GetFrame();
if (frame != null)
{
frameBitmap = frame.GetBitmap();
}
}
else
{
DepthBasedDoorDetector dDetector = _doorDetector as DepthBasedDoorDetector;
if (dDetector != null)
{
frame = DepthStream.Instance.GetFrame();
if (frame != null)
{
frameBitmap = frame.GetWriteableBitmapForDoorNavi();
}
}
else
{
InfraredBasedDoorDetector iDetector = _doorDetector as InfraredBasedDoorDetector;
if (iDetector != null)
{
frame = InfraredStream.Instance.GetFrame();
if (frame != null)
{
frameBitmap = frame.GetBitmap();
}
}
}
}
if (frameBitmap != null)
{
RenderImage(frameBitmap, ImageView1);
}
Thread.Sleep(1000 / FRAMERATE);
}
}
private BaseFrame[] createFrames(string[] files)
{
if (files.Length == 0)
{
return(new BaseFrame[1] {
new Frame.Empty(Screen, 1)
});
}
BaseFrame[] frames = new BaseFrame[files.Length];
for (var i = 0; i < files.Length; i++)
{
frames[i] = getFrame(files[i]);
}
return(frames);
}
/// <summary>
/// Serializes the specified frame.
/// </summary>
/// <param name="frame">The frame.</param>
/// <returns>Binary representation of the frame.</returns>
public byte[] Serialize(BaseFrame frame)
{
if (frame is ControlFrame)
{
if (Option.UseCompression)
{
frame.Flags &= (byte)FrameFlags.FlagNormal;
}
else
{
frame.Flags &= (byte)FrameFlags.FlagNoHeaderCompression1;
}
return(SerializeControlFrame(frame as ControlFrame));
}
return(SerializeDataFrame(frame as DataFrame));
}
public int Apply(BaseFrame frame)
{
if (frame.IsFinalFrame)
{
return(frame.Score.TotalScore);
}
else
{
var score = frame.Score.FirstTry + frame.Score.SecondTry;
var nextFrame = (frame as BowlingFrame).NextFrame;
return(nextFrame != null
? score + nextFrame.Score.FirstTry
: score);
}
}
public override Task ReceiveMessageAsync(string message)
{
return(Task.Run(() =>
{
BaseFrame frame = JsonConvert.DeserializeObject <BaseFrame>(message);
switch (frame.Type.ToLower())
{
case StartCameraRequest.Typename:
StartCamera();
break;
case RecognizeImageRequest.Typename:
RecognizeImage(JsonConvert.DeserializeObject <RecognizeImageRequest>(message));
break;
}
}));
}
/// <summary>
/// Calculation
/// </summary>
/// <param name="input">Input</param>
/// <param name="output">Output</param>
void IObjectTransformer.Calculate(object[] input, object[] output)
{
for (int i = 0; i < 3; i++)
{
inpos[i] = (double)input[i];
}
double w = (double)input[3] / (2 * sin);
// 3D to 3D transformation
BaseFrame.GetRelativePosition(inpos, outpos);
// 3D to 2D transformation
double x = Math.Atan2(outpos[0], -outpos[2]) * w;
double y = Math.Atan2(outpos[1], -outpos[2]) * w;
output[0] = x;
output[1] = y;
}
private void ProcessingThread_DoWork()
{
while (true)
{
BaseFrame frame = imageStream.GetFrame();
DFrame dFrame = (DFrame)frame;
if (dFrame != null)
{
List <DetectedDoor> doors = GetDoors(dFrame);
DoorDetectedEventArgs args = new DoorDetectedEventArgs(doors, DetectedDoor.DetectMethod.DEPTH);
if (OnDoorDetected != null)
{
OnDoorDetected(this, args);
}
}
Thread.Sleep(UPDATE_INTERVAL);
}
}
/// <inheritdoc />
public bool Equals([AllowNull] Frames other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Group == other.Group ||
Group != null &&
Group.Equals(other.Group)
) &&
(
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
Traces == other.Traces ||
Traces != null &&
Traces.Equals(other.Traces)
) &&
(
BaseFrame == other.BaseFrame ||
BaseFrame != null &&
BaseFrame.Equals(other.BaseFrame)
) &&
(
Data == other.Data ||
Data != null &&
Data.Equals(other.Data)
) &&
(
Layout == other.Layout ||
Layout != null &&
Layout.Equals(other.Layout)
));
}
/// <summary>
/// Event handler for Http2 data.
/// </summary>
/// <param name="sender">The sender object.</param>
/// <param name="e">Event arguments.</param>
private void OnSocketData(object sender, SocketEventArgs e)
{
try
{
BaseFrame frame = this.serializer.Deserialize(e.BinaryData);
if (this.OnFrameReceived != null)
{
this.OnFrameReceived(this, new FrameEventArgs(frame));
}
try
{
if (frame is DataFrame)
{
this.ProcessDataFrame((DataFrame)frame);
}
else if (frame is ControlFrame)
{
this.ProcessControlFrame((ControlFrame)frame);
}
else
{
throw new InvalidOperationException("Unsupported frame type");
}
}
catch (Exception streamError)
{
if (streamError is ProtocolExeption || this.OnStreamError == null)
{
throw;
}
this.OnStreamError(this, new StreamErrorEventArgs(this.streamsStore.GetStreamById(frame.StreamId), streamError));
}
}
catch (Exception protocolError)
{
if (this.OnError != null)
{
this.OnError(this, new ProtocolErrorEventArgs(protocolError));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FrameLogItem"/> struct.
/// </summary>
/// <param name="frame">The frame.</param>
public FrameLogItem(BaseFrame frame)
{
this.Length = frame.Length;
this.StreamId = frame.StreamId;
if (frame is ControlFrame)
{
this.Type = ((ControlFrame)frame).Type;
this.Headers = ((ControlFrame)frame).Headers.ToString();
this.TimeStamp = DateTime.Now;
this.Duration = TimeSpan.Zero;
}
else
{
this.Type = FrameType.Data;
this.TimeStamp = DateTime.Now;
this.Duration = TimeSpan.Zero;
this.Headers = string.Empty;
}
}
private void UpdateBackgroundFrame()
{
const DispatcherPriority priority = DispatcherPriority.Render;
while (true)
{
BaseFrame frame = Data.BackgroundStream.GetFrame();
WriteableBitmap frameBitmap = null;
if (frame != null)
{
frameBitmap = frame.GetBitmap();
}
if (frameBitmap == null)
{
StreamImage.Dispatcher.Invoke(() =>
{
if (StreamImage.Source == null)
{
//otherwise send a blank frame
StreamImage.Source = new WriteableBitmap(800, 600, 96.0, 96.0, PixelFormats.Pbgra32, null);
}
}, priority);
//otherwise don't update frame
}
else
{
StreamImage.Dispatcher.Invoke(() =>
{
StreamImage.Source = frameBitmap;
}, priority);
OverlayCanvas.Dispatcher.Invoke(() =>
{
overlayRenderer.RenderOverlays(StreamImage.ActualWidth, StreamImage.ActualHeight);
});
}
Thread.Sleep(1000 / FRAMERATE);
}
}
public override float ReadFrame(int currentFrame, int deltaFrames, float deltaTime)
{
var time = 0f;
if (CurrentFrame + 1 == currentFrame)
{
CurrentFrame = currentFrame;
time = ReadFrameTime();
ReadObjectsIdsAndNames();
ReadObservableEntitiesInit(deltaTime);
ReadObservableEntities(true, deltaTime);
}
else
{
deltaTime = 1f / Hz;
CurrentFrame = currentFrame;
// Read BaseFrame
THeader.SetPointerPosition(ReplayReader, currentFrame - deltaFrames);
BaseFrame.ReadDeltaFrameCount();
BaseFrame.ReadFrameTime();
BaseFrame.ReadObjectsIdsAndNames();
// Only construct once
BaseFrame.ReadObservableEntitiesInit(deltaTime);
BaseFrame.ReadObservableEntities(false, deltaTime);
// Read all deltas until currentFrame
for (var i = deltaFrames - 1; i >= 0; i--)
{
THeader.SetPointerPosition(ReplayReader, currentFrame - i);
ReadDeltaFrameCount();
time = ReadFrameTime();
ReadObjectsIdsAndNames();
ReadObservableEntities(i == 0, deltaTime);
}
}
return(time);
}
public override float ReadFrame(int currentFrame, int deltaFrames, float deltaTime)
{
var time = 0f;
if (CurrentFrame + 1 == currentFrame)
{
CurrentFrame = currentFrame;
time = ReadFrameTime();
ReadObjectsIdsAndNames();
// Only construct once, because delta compression method unpacks n deltaFrameCount frames
ReadObservableEntitiesInit(deltaTime);
ReadObservableEntities(true, deltaTime);
}
else
{
deltaTime = 1f / Hz;
CurrentFrame = currentFrame;
// Read BaseFrame
THeader.SetPointerPosition(ReplayReader, currentFrame - deltaFrames);
BaseFrame.ReadDeltaFrameCount();
BaseFrame.ReadFrameTime();
BaseFrame.ReadObjectsIdsAndNames();
// Only construct once, because delta compression method unpacks n deltaFrameCount frames
BaseFrame.ReadObservableEntitiesInit(deltaTime);
BaseFrame.ReadObservableEntities(false, deltaTime);
THeader.SetPointerPosition(ReplayReader, currentFrame);
ReadDeltaFrameCount();
time = ReadFrameTime();
ReadObjectsIdsAndNames();
ReadObservableEntities(true, deltaTime);
}
return(time);
}
public int Apply(BaseFrame frame)
{
if (frame.IsFinalFrame)
{
return(frame.Score.TotalScore);
}
else
{
var score = frame.Score.FirstTry;
var nextFrame = (frame as BowlingFrame).NextFrame;
if (nextFrame == null)
{
return(score);
}
score = score + nextFrame.Score.FirstTry;
if (nextFrame.IsFinalFrame)
{
return(score + nextFrame.Score.SecondTry);
}
if (nextFrame.IsStrike == false)
{
return(score + nextFrame.Score.SecondTry);
}
else
{
var nextToNextFrame = nextFrame.NextFrame;
return(nextToNextFrame != null
? score + nextToNextFrame.Score.FirstTry
: score);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FrameEventArgs"/> class.
/// </summary>
/// <param name="frame">The frame.</param>
public FrameEventArgs(BaseFrame frame)
{
this.Frame = frame;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindow"/> class.
/// </summary>
public MainWindow()
{
this.InitializeComponent();
TitleInfoService.TitleInfoElement = this.ButtonRightTitle;
var frameWelcome = new Welcome();
var framePackageSelect = new PackageSelection();
var frameDevPackageSelect = new DeveloperPackageSelection();
var framePlayerPaths = new PlayerFindPaths();
var frameDevPaths = new DeveloperFindPaths();
var frameEmptyMod = new CreateEmptyMod();
var frameInstall = new Install();
var frameFinished = new Finished();
var frameError = new Error();
var frames = new BaseFrame[]
{
frameWelcome, framePackageSelect, frameDevPackageSelect, framePlayerPaths,
frameDevPaths, frameInstall, frameFinished, frameError, frameEmptyMod
};
this.frameManager.Initialize(this.contentWrapper);
this.frameManager.RegisterFrame(
frameWelcome,
new FlowInformation
{
Element = frameWelcome,
TransitionCommands = new Dictionary <string, BaseFrame>
{
{ Welcome.CommandNext, framePackageSelect }
}
});
this.frameManager.RegisterFrame(
framePackageSelect,
new FlowInformation
{
Element = framePackageSelect,
TransitionCommands = new Dictionary <string, BaseFrame>
{
{ PackageSelection.CommandPlayerPackage, framePlayerPaths },
{ PackageSelection.CommandDeveloperPackage, frameDevPackageSelect }
}
});
this.frameManager.RegisterFrame(
frameDevPackageSelect,
new FlowInformation
{
Element = frameDevPackageSelect,
TransitionCommands = new Dictionary <string, BaseFrame>
{
{ DeveloperPackageSelection.CommandNext, frameDevPaths },
{ DeveloperPackageSelection.CommandCreateEmptyMod, frameEmptyMod },
}
});
this.frameManager.RegisterFrame(
frameEmptyMod,
new FlowInformation
{
Element = frameEmptyMod,
TransitionCommands = new Dictionary <string, BaseFrame>
{
{ CreateEmptyMod.CommandNext, frameDevPaths },
}
});
this.frameManager.RegisterFrame(
frameDevPaths,
new FlowInformation
{
Element = frameDevPaths,
TransitionCommands = new Dictionary <string, BaseFrame>
{
{ DeveloperFindPaths.CommandInstall, frameInstall },
}
});
this.frameManager.RegisterFrame(
framePlayerPaths,
new FlowInformation
{
Element = framePlayerPaths,
TransitionCommands = new Dictionary <string, BaseFrame>
{
{ PlayerFindPaths.CommandInstall, frameInstall },
}
});
this.frameManager.RegisterFrame(
frameInstall,
new FlowInformation
{
Element = frameInstall,
TransitionCommands = new Dictionary <string, BaseFrame>
{
{ Install.CommandFinished, frameFinished },
{ Install.CommandError, frameError }
}
});
foreach (var frame in frames)
{
frame.Navigate += this.Frame_Navigate;
frame.Back += this.Frame_Back;
}
this.frameManager.DisplayInitialFrame(frameWelcome);
}
private void AutoSuggestBox_QuerySubmitted(AutoSuggestBox sender, AutoSuggestBoxQuerySubmittedEventArgs args)
{
BaseFrame.Navigate(typeof(Search), args.QueryText);
}
// Start is called before the first frame update
void Start()
{
_Frame = BaseFrame.Frame;
_Frame.Regist(this.GetType().FullName, this);
StartSet();
}
/// <summary>
/// Selects frame based on type
/// </summary>
/// <param name="frame">The frame.</param>
/// <returns>
/// TRUE if frame is SM control frame of SYNSTREAM or SYNREPLY type
/// </returns>
private bool SessionFramesFilter(BaseFrame frame)
{
var cntrlframe = frame as ControlFrame;
return(cntrlframe != null && (cntrlframe.Type == FrameType.SynStream || cntrlframe.Type == FrameType.SynReply));
}
internal void SetBaseFrame(BaseFrame baseFrame)
{
m_baseFrame = baseFrame;
}
