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);
}
