private void timerCapture_Tick(object sender, EventArgs e) { string path = _classifyMode ? _savePath : $@"{_savePath}\{DateTime.Now:yyyyMMddHHmmss.fff}.jpg"; //_bmp.Save(path); SaveResizedBitmap(path, 0.5f); if (_classifyMode) { Cursor = Cursors.WaitCursor; // predict the webcam image. var predictionResult = ImageClassification.Predictor.ClassifySingleImage(_pipelineZip, _modelZip, path); // overray //_frame.PutText($"{predictionResult.PredictedLabel} {predictionResult.Score:P}", new OpenCvSharp.Point(10, 10), HersheyFonts.HersheyPlain, 10, new Scalar(0), 2); lblClassify.Text = $"{predictionResult.PredictedLabel} {predictionResult.Score:P}"; if (predictionResult.Score >= 0.9f) { lblClassify.ForeColor = Color.Red; } else { lblClassify.ForeColor = Color.Black; } Cursor = Cursors.Default; } _count++; Captured?.Invoke(this, new CapturedInfo(_count, path)); }
public void ForceCapture(int newTeam) { captured = true; currentTeam = newTeam; Captured?.Invoke(currentTeam); }
void DrawToWindow() { while (_queue.Count != 0) { if (_queue.TryTake(out SharpDX.Direct2D1.Bitmap bitmap) == true) { if (_lastBitmap != null) { _lastBitmap.Dispose(); } _lastBitmap = bitmap; } if (_lastBitmap == null) { return; } _renderTarget.Render( (renderer) => { renderer.DrawBitmap(_lastBitmap, 1.0f, BitmapInterpolationMode.Linear); }); Captured?.Invoke(this, new CapturedEventArgs(_lastBitmap, _dataStream)); } }
void OnCaptured(int newTeam) { int oldTeam = Team; Team = newTeam; currentState = ResourceNodeState.Mining; Captured?.Invoke(newTeam, oldTeam, ResourceNodeData); if (StartCaptured) { capturable.Captured -= OnCaptured; capturable.Disable(); } setMaterialProperties.SetMaterial(1f, TeamColors.Hues[Team], ResourceNodeData.sprite); uiController.Store["SpecialResources"][Team].AddRange(ResourceNodeData.resourceFlags); if (oldTeam != 2) { foreach (string resource in ResourceNodeData.resourceFlags) { uiController.Store["SpecialResources"][oldTeam].Remove(resource); } } uiController.UpdateValue("SpecialResources"); }
private void Slider_PointerPressed(object sender, PointerRoutedEventArgs e) { startPosition = e.GetCurrentPoint(Base).Position; startPosition.X -= sliderPosition.X; startPosition.Y -= sliderPosition.Y; Captured?.Invoke(this, EventArgs.Empty); pointerCaptured = Slider.CapturePointer(e.Pointer); }
//Опрацьовує юніта, який зайшов у місто public void GetUnits(BasicUnit unit) { bool needResend = false; if (PlayerId == unit.PlayerId) { if (unit.planedDestination != this) { needResend = true; } else { this.currWarriors += unit.warriorsCnt; if (!saveOvercapedUnits && currWarriors > maxWarriors) { currWarriors = maxWarriors; } } } else { unit.warriorsCnt = (ushort)Math.Round((2 - this.defPersent) * unit.warriorsCnt); if (currWarriors > unit.warriorsCnt) { currWarriors -= unit.warriorsCnt; } else if ( (currWarriors < unit.warriorsCnt) || ( currWarriors == unit.warriorsCnt && ((PlayerId == 0 && equalsMeanCapturedForNeutral) || (equalsMeanCaptured)) ) ) { CityCaptureEvent captureCityEvent = new CityCaptureEvent(basicCityEvent, PlayerId, unit.PlayerId); currWarriors = (ushort)(unit.warriorsCnt - currWarriors); PlayerId = unit.PlayerId; Captured?.Invoke(captureCityEvent); } else if (currWarriors == unit.warriorsCnt) { currWarriors = 0; } } if (needResend) { ResendUnit(unit.planedDestination, unit); } else { gameMap.Units.Remove(unit); UnitGet?.Invoke(new CityUnitsEvent(basicCityEvent, unit)); } }
private void Knob_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { _startPos = e.GetPosition(Base); _prevAileron = _prevElevator = 0; canvasWidth = Base.ActualWidth - KnobBase.ActualWidth; canvasHeight = Base.ActualHeight - KnobBase.ActualHeight; Captured?.Invoke(this); Knob.CaptureMouse(); centerKnob.Stop(); }
private void Knob_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { _startPos = e.GetPosition(Base); _prevAngle = _prevDistance = 0; Captured?.Invoke(this); Knob.CaptureMouse(); centerKnob.Stop(); }
private void Knob_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { knob_point = e.GetPosition(this.Base); knob_first_point = e.GetPosition(this.Base); canvasWidth = Base.ActualWidth - KnobBase.ActualWidth; canvasHeight = Base.ActualHeight - KnobBase.ActualHeight; Captured?.Invoke(this); Knob.CaptureMouse(); centerKnob.Stop(); }
private void Knob_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { StartPos = e.GetPosition(Base); CanvasWidth = Base.ActualWidth; CanvasHeight = Base.ActualHeight; Captured?.Invoke(this); Knob.CaptureMouse(); CenterKnob.Stop(); }
void RecognizeQR(Mat img) { qrbox.ImageIpl = img; var res = reader.Decode(img); if (res != null) { resultT.Text = res.Text; Captured?.Invoke(res); } }
private void Knob_MouseDown(object sender, MouseButtonEventArgs e) { // Checks if the joystick was pressed. if (e.ChangedButton == MouseButton.Left) { // Update control point. startlPoint = e.GetPosition(this); Captured?.Invoke(this); Knob.CaptureMouse(); centerknob.Stop(); } }
void Start() { currentState = ResourceNodeState.Idle; Captured?.Invoke(Team, Team, ResourceNodeData); if (StartCaptured) { capturable.ForceCapture(Team); } else { setMaterialProperties.SetMaterial(0f, TeamColors.Hues[Team], ResourceNodeData.sprite); } }
public override void Update(GameTime gameTime) { if (this.Carrier != null) { this.Position = this.Carrier.Position; Vector2 otherTeamsBase = this.Carrier.Team.Base; if (Vector2.DistanceSquared(this.Position, otherTeamsBase) < this.CapturedRange * this.CapturedRange) { Captured?.Invoke(this); this.Carrier = null; } } }
void Start() { currentState = ProductionNodeState.Idle; mapRoot = GameObject.Find("MapRoot"); Captured?.Invoke(Team, Team); if (StartCaptured) { capturable.ForceCapture(Team); } else { setMaterialProperties.SetMaterial(0f, TeamColors.Hues[Team], ProductionNodeData.sprite); } }
private void timerCapture_Tick(object sender, EventArgs e) { string path = _classifyMode ? _savePath : $@"{_savePath}\{DateTime.Now:yyyyMMddHHmmss.fff}.jpg"; //_bmp.Save(path); SaveResizedBitmap(path, 0.5f); if (_classifyMode) { System.Threading.Tasks.Task.Run(() => { // predict the webcam image. MLContext mlContext = new MLContext(seed: 1); var predictionResult = Classifier.GetSingleImagePrediction(mlContext, ImageClassification.IO.DataLoader.GetPipeline(mlContext, _pipelineZip), ImageClassification.IO.DataLoader.GetModel(mlContext, _modelZip), _savePath); Classified?.Invoke(this, predictionResult); // overray //_frame.PutText($"{predictionResult.PredictedLabel} {predictionResult.Score:P}", new OpenCvSharp.Point(10, 10), HersheyFonts.HersheyPlain, 10, new Scalar(0), 2); }); } _count++; Captured?.Invoke(this, new CapturedInfo(_count, path)); }
void Update() { timeToTestCapture -= Time.deltaTime; if (timeToTestCapture <= 0) { circleCollider2D.GetContacts(colliderContacts); Collider2D[] capturingShips = colliderContacts .Select(collider => collider) .Where(collider => collider != null && collider.name == "Health") .ToArray(); captureNumbers[0] = 0; captureNumbers[1] = 0; for (int i = 0; i < capturingShips.Length; i++) { Ship capturingShip = capturingShips[i].GetComponentInParent <Ship>(); captureNumbers[capturingShip.Team] += 1; } if (captureNumbers[0] > captureNumbers[1] && (currentTeam == 1 || !captured)) { captured = true; currentTeam = 0; Captured?.Invoke(currentTeam); } if (captureNumbers[1] > captureNumbers[0] && (currentTeam == 0 || !captured)) { captured = true; currentTeam = 1; Captured?.Invoke(currentTeam); } timeToTestCapture = captureInterval; } }
void OnCaptured(int newTeam) { int oldTeam = Team; Team = newTeam; BuildProgress = 0; currentState = ProductionNodeState.Building; Captured?.Invoke(Team, oldTeam); if (StartCaptured) { capturable.Captured -= OnCaptured; capturable.Disable(); } if (!selectable.gameObject.activeSelf) { selectable.gameObject.SetActive(true); } setMaterialProperties.SetMaterial(1f, TeamColors.Hues[Team], ProductionNodeData.sprite); }
static void OnCaptured(FileData args) { Captured?.Invoke(null, args); }
public void CaptureMouse() { Captured?.Invoke(); }
private void Btn_Capture_Click(object sender, RoutedEventArgs e) { Captured?.Invoke(sender, EventArgs.Empty); }
public void Start(int index) { Stop(); if (SetPoint == null) { throw new ArgumentNullException(nameof(SetPoint)); } capture = Capture.New(index); capture.FrameReady += Capture_FrameReady; capture.Start(); tokenSource = new CancellationTokenSource(); CancellationToken tk = tokenSource.Token; recThread = new Task(() => { while (!tk.IsCancellationRequested) { if (IsPaused) { Core.Sleep(1); continue; } Random rnd = new Random(); Point pt = new Point(rnd.NextDouble(0, ScreenSize.Width), rnd.NextDouble(0, ScreenSize.Height)); SetPoint.Invoke(this, new EyeGazePointArg(pt, Scalar.BgrRed, 700)); Core.Sleep(700); if (tk.IsCancellationRequested) { return; } SetPoint.Invoke(this, new EyeGazePointArg(pt, Scalar.BgrYellow, 500)); Core.Sleep(500); if (tk.IsCancellationRequested) { return; } SetPoint.Invoke(this, new EyeGazePointArg(pt, Scalar.BgrGreen, 100)); while (mat == null) { Core.Sleep(1); if (tk.IsCancellationRequested) { return; } } lock (matLocker) { if (mat != null && !mat.IsEmpty) { if (!IsPaused) { FileNode node = Parent.GetFile($"{captureCount},{Math.Round(pt.X)},{Math.Round(pt.Y)}.jpg"); Core.Cv.ImgWrite(node, mat, 95); captureCount++; if (captureCount > 1 && captureCount % 20 == 0) { rnd = new Random(); } Captured?.Invoke(this, pt); Logger.Log($"ImageCaptured. [{pt.ToString()}]"); } } else { Logger.Error(this, "frame is nulled or empty"); } } Core.Sleep(100); } }, tk); IsRecording = true; recThread.Start(); }
private void onCapture() { Captured?.Invoke(this, new CapturedEventArgs { Bitmap = image }); }
private static bool OnKeyInternal(WM ev, VK vk, SC sc, LLKHF flags) { bool is_keydown = (ev == WM.KEYDOWN || ev == WM.SYSKEYDOWN); bool is_keyup = !is_keydown; bool add_to_sequence = is_keydown; bool is_capslock_hack = false; bool has_shift = (NativeMethods.GetKeyState(VK.SHIFT) & 0x80) != 0; bool has_altgr = (NativeMethods.GetKeyState(VK.LCONTROL) & NativeMethods.GetKeyState(VK.RMENU) & 0x80) != 0; bool has_lrshift = (NativeMethods.GetKeyState(VK.LSHIFT) & NativeMethods.GetKeyState(VK.RSHIFT) & 0x80) != 0; bool has_capslock = NativeMethods.GetKeyState(VK.CAPITAL) != 0; // Guess what the system would print if we weren’t interfering. If // a printable representation exists, use that. Otherwise, default // to its virtual key code. Key key = KeyboardLayout.VkToKey(vk, sc, flags, has_shift, has_altgr, has_capslock); // If Caps Lock is on, and the Caps Lock hack is enabled, we check // whether this key without Caps Lock gives a non-ASCII alphabetical // character. If so, we replace “result” with the lowercase or // uppercase variant of that character. if (has_capslock && Settings.CapsLockCapitalizes.Value) { Key alt_key = KeyboardLayout.VkToKey(vk, sc, flags, has_shift, has_altgr, false); if (alt_key.IsPrintable && alt_key.ToString()[0] > 0x7f) { string str_upper = alt_key.ToString().ToUpper(); string str_lower = alt_key.ToString().ToLower(); // Hack for German keyboards: it seems that ToUpper() does // not properly change ß into ẞ. if (str_lower == "ß") { str_upper = "ẞ"; } if (str_upper != str_lower) { key = new Key(has_shift ? str_lower : str_upper); is_capslock_hack = true; } } } // If we are being used to capture a key, send the resulting key if (Captured != null) { if (!is_keydown) { Captured.Invoke(key); } return(true); } // Update statistics if (is_keydown) { // Update single key statistics Stats.AddKey(key); // Update key pair statistics if applicable if (DateTime.Now < m_last_key_time.AddMilliseconds(2000) && m_last_key != null) { Stats.AddPair(m_last_key, key); } // Remember when we pressed a key for the last time m_last_key_time = DateTime.Now; m_last_key = key; } // If the special Synergy window has focus, we’re actually sending // keystrokes to another computer; disable WinCompose. Same if it is // a Cygwin X window. if (KeyboardLayout.Window.IsOtherDesktop) { return(false); } // Sanity check in case the configuration changed between two // key events. if (m_current_compose_key.VirtualKey != VK.NONE && !Settings.ComposeKeys.Value.Contains(m_current_compose_key)) { CurrentState = State.Idle; m_current_compose_key = new Key(VK.NONE); } // If we receive a keyup for the compose key while in emulation // mode, we’re done. Send a KeyUp event and exit emulation mode. if (is_keyup && CurrentState == State.KeyCombination && key == m_current_compose_key) { bool compose_key_was_altgr = m_compose_key_is_altgr; Key old_compose_key = m_current_compose_key; CurrentState = State.Idle; m_current_compose_key = new Key(VK.NONE); m_compose_key_is_altgr = false; m_compose_counter = 0; Log.Debug("KeyCombination ended (state: {0})", m_state); // If relevant, send an additional KeyUp for the opposite // key; experience indicates that it helps unstick some // applications such as mintty.exe. switch (old_compose_key.VirtualKey) { case VK.LMENU: SendKeyUp(VK.RMENU); break; case VK.RMENU: SendKeyUp(VK.LMENU); // If keyup is RMENU and we have AltGr on this // keyboard layout, send LCONTROL up too. if (compose_key_was_altgr) { SendKeyUp(VK.LCONTROL); } break; case VK.LSHIFT: SendKeyUp(VK.RSHIFT); break; case VK.RSHIFT: SendKeyUp(VK.LSHIFT); break; case VK.LCONTROL: SendKeyUp(VK.RCONTROL); break; case VK.RCONTROL: SendKeyUp(VK.LCONTROL); break; } return(false); } // If this is the compose key and we’re idle, enter Sequence mode if (is_keydown && Settings.ComposeKeys.Value.Contains(key) && m_compose_counter == 0 && CurrentState == State.Idle) { CurrentState = State.Sequence; m_current_compose_key = key; m_compose_key_is_altgr = key.VirtualKey == VK.RMENU && KeyboardLayout.HasAltGr; ++m_compose_counter; Log.Debug("Now composing (state: {0}) (altgr: {1})", m_state, m_compose_key_is_altgr); // Lauch the sequence reset expiration timer if (Settings.ResetDelay.Value > 0) { m_timeout.Change(TimeSpan.FromMilliseconds(Settings.ResetDelay.Value), NEVER); } return(true); } // If this is a compose key KeyDown event and it’s already down, or it’s // a KeyUp and it’s already up, eat this event without forwarding it. if (key == m_current_compose_key && is_keydown == ((m_compose_counter & 1) != 0)) { return(true); } // Escape and backspace cancel the current sequence if (is_keydown && CurrentState == State.Sequence && (key.VirtualKey == VK.ESCAPE || key.VirtualKey == VK.BACK)) { // FIXME: if a sequence was in progress, maybe print it! ResetSequence(); Log.Debug("No longer composing (state: {0})", m_state); return(true); } // Feature: emulate capslock key with both shift keys, and optionally // disable capslock using only one shift key. if (key.VirtualKey == VK.LSHIFT || key.VirtualKey == VK.RSHIFT) { if (is_keyup && has_lrshift && Settings.EmulateCapsLock.Value) { SendKeyPress(VK.CAPITAL); return(false); } if (is_keydown && has_capslock && Settings.ShiftDisablesCapsLock.Value) { SendKeyPress(VK.CAPITAL); return(false); } } // If we are not currently composing a sequence, do nothing unless // one of our hacks forces us to send the key as a string (for // instance the Caps Lock capitalisation feature). if (CurrentState != State.Sequence) { if (is_capslock_hack && is_keydown) { SendString(key.ToString()); return(true); } // If this was a dead key, it will be completely ignored. But // it’s okay since we stored it. Log.Debug("Forwarding {0} “{1}” to system (state: {2})", is_keydown ? "⭝" : "⭜", key.FriendlyName, m_state); return(false); } // // From this point we know we are composing // // If the compose key is down and the user pressed a new key, maybe // instead of composing they want to do a key combination, such as // Alt+Tab or Windows+Up. So we abort composing and send the KeyDown // event for the Compose key that we previously discarded. The same // goes for characters that need AltGr when AltGr is the compose key. // // Never do this if the event is KeyUp. // Never do this if we already started a sequence // Never do this if the key is a modifier key such as shift or alt. if (m_compose_counter == 1 && is_keydown && m_sequence.Count == 0 && !key.IsModifier()) { bool keep_original = Settings.KeepOriginalKey.Value; bool key_unusable = !key.IsUsable(); bool altgr_combination = m_compose_key_is_altgr && KeyboardLayout.KeyToAltGrVariant(key) != null; if (keep_original || key_unusable || altgr_combination) { bool compose_key_was_altgr = m_compose_key_is_altgr; ResetSequence(); if (compose_key_was_altgr) { // It’s necessary to use KEYEVENTF_EXTENDEDKEY otherwise the system // does not understand that we’re sending AltGr. SendKeyDown(VK.LCONTROL); SendKeyDown(VK.RMENU, KEYEVENTF.EXTENDEDKEY); } else { SendKeyDown(m_current_compose_key.VirtualKey); } CurrentState = State.KeyCombination; Log.Debug("KeyCombination started (state: {0})", m_state); return(false); } } // If this is the compose key again, use our custom virtual key // FIXME: we don’t properly support compose keys that also normally // print stuff, such as `. if (key == m_current_compose_key) { ++m_compose_counter; key = new Key(VK.COMPOSE); // If the compose key is AltGr, we only add it to the sequence when // it’s a KeyUp event, otherwise we may be adding Multi_key to the // sequence while the user actually wants to enter an AltGr char. if (m_compose_key_is_altgr && m_compose_counter > 2) { add_to_sequence = is_keyup; } } // If the compose key is AltGr and it’s down, check whether the current // key needs translating. if (m_compose_key_is_altgr && (m_compose_counter & 1) != 0) { Key altgr_variant = KeyboardLayout.KeyToAltGrVariant(key); if (altgr_variant != null) { key = altgr_variant; // Do as if we already released Compose, otherwise the next KeyUp // event will cause VK.COMPOSE to be added to the sequence… ++m_compose_counter; } } // If the key can't be used in a sequence, just ignore it. if (!key.IsUsable()) { Log.Debug("Forwarding unusable {0} “{1}” to system (state: {2})", is_keydown ? "⭝" : "⭜", key.FriendlyName, m_state); return(false); } // If we reached this point, everything else ignored this key, so it // is a key we must add to the current sequence. if (add_to_sequence) { Log.Debug("Adding to sequence: {0}", key.FriendlyName); return(AddToSequence(key)); } return(true); }