public void CheckWithLinq(int channelCount, int sourceLength, int windowLength, int position)
{
var random = new Random(57);
var source = new double[channelCount][];
for (var ch = 0; ch < channelCount; ch++)
{
source[ch] = Enumerable.Range(0, sourceLength).Select(t => random.NextDouble()).ToArray();
}
var window = WindowFunctions.Hann(windowLength);
var expected = new double[channelCount][];
for (var ch = 0; ch < channelCount; ch++)
{
expected[ch] = source[ch].Skip(position).Take(windowLength).ToArray();
for (var t = 0; t < expected.Length; t++)
{
expected[ch][t] *= window[t];
}
}
var actual = Framing.GetFrame(source, window, position);
for (var ch = 0; ch < channelCount; ch++)
{
for (var t = 0; t < actual.Length; t++)
{
Assert.AreEqual(expected[ch][t], actual[ch][t], 1.0E-9);
}
}
}
/// <summary>
/// Waits for an instance of the game window to spawn (searches window by name).
/// Proceeds to wait until said window is visible to the end user.
/// </summary>
/// <param name="gameWindowName">The name of the game window to find the handle for.</param>
private static async Task <IntPtr> FindWindowHandleByName(string gameWindowName)
{
// Provide our own interactive timeout.
int attempts = 0;
int threadSleepTime = 16;
int timeoutMilliseconds = 1000;
// Handle of the game window
IntPtr windowHandle = (IntPtr)0;
// Wait for Game Window to spawn.
while (true)
{
// Increase attempts.
attempts++;
// Get the handle for the Sonic_Heroes Window
windowHandle = WindowFunctions.FindWindow(null, gameWindowName);
// If handle successfully acquired.
if (windowHandle != (IntPtr)0)
{
return(windowHandle);
}
// Check timeout
if (attempts > timeoutMilliseconds / threadSleepTime)
{
return((IntPtr)0);
}
// Sleep to reduce CPU load.
await Task.Delay(threadSleepTime);
}
}
/// <summary>
/// Class constructor. Instantiates both the overlay and DirectX Stuff.
/// </summary>
/// <param name="gameWindowName">
/// The name of the window to be overlayed.
/// The window may be the game window or another window elsewhere.
/// </param>
/// <param name="renderDelegate">
/// The user delegate which you may use for rendering to the external overlay
/// window with Direct2D.
/// </param>
/// <param name="hookDelay">
/// Specifies the amount of time to wait until the hook is instantiation begins.
/// Some games are known to crash if DirectX is hooked too early.
/// </param>
/// <returns>
/// 1. True if the window has been found and overlay has been instantiated, else false.
/// 2. An instance of self (ExternalWindowOverlay) with the overlay enabled and running.
/// </returns>
public static async Task <(bool success, D2DOverlay overlay)> CreateExternalWindowOverlay(string gameWindowName, D2DWindowRenderer.DelegateRenderDirect2D renderDelegate, int hookDelay)
{
// Apply hook delay
await Task.Delay(hookDelay);
// Create self.
D2DOverlay externalWindowOverlay = new D2DOverlay();
// Wait for and find the game window.
IntPtr windowHandle = await FindWindowHandleByName(gameWindowName);
// If the handle has been acquired.
if (windowHandle != (IntPtr)0)
{
// Wait for the Window to show itself to screen before configuring.
while (WindowFunctions.IsWindowVisible(windowHandle) == false)
{
await Task.Delay(32);
}
// Enable the overlay.
externalWindowOverlay.EnableOverlay(renderDelegate, windowHandle);
// Returns true.
return(true, externalWindowOverlay);
}
// Return false, window was not found.
return(false, externalWindowOverlay);
}
/// <summary>
/// Class constructor. Instantiates both the overlay and DirectX Stuff.
/// Note: This method is blocking and Reloaded mods are required to return in order
/// to boot up the games, please do not assign this statically - instead assign it in a background thread!
/// </summary>
/// <param name="renderDelegate">
/// The user delegate which you may use for rendering to the external overlay
/// window with Direct2D.
/// </param>
/// <param name="hookDelay">
/// Specifies the amount of time to wait until the hook is instantiation begins.
/// Some games are known to crash if DirectX is hooked too early.
/// </param>
/// <returns>An instance of self (ExternalWindowOverlay) with the overlay enabled and running.</returns>
public static async Task <D2DOverlay> CreateExternalWindowOverlay(D2DWindowRenderer.DelegateRenderDirect2D renderDelegate, int hookDelay)
{
// Apply hook delay
await Task.Delay(hookDelay);
// Game process
System.Diagnostics.Process gameProcess = Bindings.TargetProcess.GetProcessFromReloadedProcess();
// Try to get game window handle.
while (gameProcess.MainWindowHandle == IntPtr.Zero)
{
await Task.Delay(32);
}
// Wait for the Window to show itself to screen before configuring.
while (WindowFunctions.IsWindowVisible(gameProcess.MainWindowHandle) == false)
{
await Task.Delay(32);
}
// Create self.
D2DOverlay externalWindowOverlay = new D2DOverlay();
// Enable the overlay.
externalWindowOverlay.EnableOverlay(renderDelegate, gameProcess.MainWindowHandle);
// Return self
return(externalWindowOverlay);
}
/// <summary>
/// FFT 演算をおこないます。
/// </summary>
/// <param name="source">フーリエ変換をおこなうデータ配列 (要素数は 2 の累乗であること)</param>
/// <param name="windowFunction">窓関数を指定する (デフォルトは矩形窓)</param>
/// <returns>フーリエ変換後のデータ配列</returns>
public static Complex[] FFT(this IEnumerable <Complex> source, WindowFunctions windowFunction)
{
var array = source != null?source.ToArray() : null;
int length = array != null ? array.Length : 0;
if (length <= 0)
{
return(null);
}
// 2 の累乗かどうかを確認する
if ((length & (length - 1)) != 0)
{
return(null);
}
var data = array.Clone() as Complex[];
var win = GetWindowFunction(windowFunction, length);
for (int i = 0; i < length; i++)
{
data[i] *= win[i];
}
return(FFTCalculation(data, false));
}
/// <summary>
/// Called when [click].
/// </summary>
protected override void OnClick()
{
ArcMap.Application.CurrentTool = null;
try
{
UID uid = new UIDClass();
uid.Value = "{82B9951B-DD63-11D1-AA7F-00C04FA37860}"; // Select By Location Command
ICommandItem commandItem = ArcMap.Application.Document.CommandBars.Find(uid, false, false);
// open the Select By Location dialog (in case it isn't already open)
if (commandItem != null)
{
commandItem.Execute();
}
IntPtr selectwindow = this.FindSelectByLocationWindow();
if (!selectwindow.Equals(IntPtr.Zero))
{
WindowFunctions.BringWindowToTop(selectwindow);
}
}
catch (Exception e)
{
Trace.WriteLine(e.StackTrace);
throw;
}
}
/// <summary>
/// Attaches a Windows Forms window to the overlay.
/// </summary>
public static void AttachWinForm(IntPtr yourFormHandle, IntPtr targetFormHandle)
{
// Set parent form.
WindowFunctions.SetParent(yourFormHandle, targetFormHandle);
// Bring the user's form to front.
WindowFunctions.SetForegroundWindow(yourFormHandle);
}
/// <summary>
/// Returns the coordinates of the edges of a specific window relative to the desktop the window is presented on.
/// </summary>
/// <param name="windowHandle">Handle to the window of which the window rectangle should be obtained.</param>
/// <returns></returns>
public static Structures.WinapiRectangle GetWindowRectangle(IntPtr windowHandle)
{
// Obtains the coordinates of the edges of the window.
WindowFunctions.GetWindowRect(windowHandle, out Structures.WinapiRectangle gameWindowRectangle);
// Return
return(gameWindowRectangle);
}
/// <summary>
/// Returns the coordinates of the edges of a specific window in terms of
/// X from the left and Y from the top of the window.
/// </summary>
/// <param name="windowHandle">Handle to the window of which the client area rectangle should be obtained.</param>
/// <returns></returns>
public static Structures.WinapiRectangle GetClientAreaSize(IntPtr windowHandle)
{
// Obtains the size of the client area.
WindowFunctions.GetClientRect(windowHandle, out Structures.WinapiRectangle clientAreaRectangle);
// Return
return(clientAreaRectangle);
}
public FilterWindow()
{
DataContext = this;
WindowFunctions.Add(new RectangleWindowFunction());
WindowFunctions.Add(new HanningWindowFunction());
Filters.Add(new LowPassFilter());
Filters.Add(new HighPassFilter());
InitializeComponent();
}
protected virtual void VisitWindowFunction(IWindowFunctionBuilder expression)
{
var handler = default(SqlQueryWriterVisitorHandler);
if (!WindowFunctions.TryGetValue(expression.Function, out handler))
{
throw new NotImplementedException();
}
handler(this, expression);
}
public void SqrtHann()
{
var hann = WindowFunctions.Hann(256);
var sqrtHann = WindowFunctions.SqrtHann(256);
for (var t = 0; t < 256; t++)
{
Assert.AreEqual(Math.Sqrt(hann[t]), sqrtHann[t], 1.0E-6);
}
}
/// <summary>
/// Attaches a Windows Forms window to the overlay.
/// </summary>
/// <param name="yourForm">Your windows form.</param>
public void AttachWinForm(Form yourForm)
{
// Define handle to your own Windows form.
IntPtr yourFormHandle = yourForm.Handle;
// Set parent form.
WindowFunctions.SetParent(yourFormHandle, OverlayForm.Handle);
// Bring the user's form to front.
yourForm.BringToFront();
}
public void GoPoint(Point newpoint)
{
Control cWnd;
IntPtr hWnd = WindowFunctions.GetWindowAtPoint(newpoint, out cWnd);
Rectangle WindowLoc = WindowFunctions.GetRectFromHwnd(hWnd);
this.Location = new Point(WindowLoc.Left, WindowLoc.Top);
this.Size = new Size(WindowLoc.Width, WindowLoc.Height);
this.TrackedWindow = hWnd;
//Console.WriteLine(this.Location.ToString() + " " + WindowFunctions.GetWindowText(hWnd));
this.Invalidate();
}
/// <summary>
/// Your own user code starts here.
/// If this is your first time, do consider reading the notice above.
/// It contains some very useful information.
/// </summary>
public static void Init()
{
/*
* Reloaded Mod Loader Sample: Universal Borderless Windowed
* Architectures supported: X86, X64
*
* Waits until the game or process spawns off its initial border and then changes the
* window border style of the application to borderless using the Windows API.
*/
/*
* We create our own thread and run it in the background because Reloaded-Loader explicitly waits
* for the mod's thread to return before continuing to load other mods and ultimately the game.
*
* For anything we want to do in the background during initialization with Reloaded or you need to wait
* for the process/game for some reason, you are requires to start a background thread.
*/
Thread setBorderlessThread = new Thread
(
() =>
{
// Loop infinitely until a window handle is found.
while (GameProcess.Process.MainWindowHandle == IntPtr.Zero)
{
// Sleep the thread for a sensible amount of time.
Thread.Sleep(2000);
}
// Get the window size.
Point windowSize = WindowProperties.GetWindowSize(GameProcess.Process.MainWindowHandle);
Structures.WinapiRectangle windowLocation = WindowProperties.GetWindowRectangle(GameProcess.Process.MainWindowHandle);
// Get the game's Window Style.
uint windowStyle = (uint)GetWindowLongPtr(GameProcess.Process.MainWindowHandle, GWL_STYLE);
// Change the window style.
windowStyle &= ~WS_BORDER;
windowStyle &= ~WS_CAPTION;
windowStyle &= ~WS_MAXIMIZEBOX;
windowStyle &= ~WS_MINIMIZEBOX;
// Set the window style.
SetWindowLongPtr(GameProcess.Process.MainWindowHandle, GWL_STYLE, (IntPtr)windowStyle);
// Set the window size.
WindowFunctions.MoveWindow(GameProcess.Process.MainWindowHandle, windowLocation.LeftBorder,
windowLocation.TopBorder, windowSize.X, windowSize.Y, true);
}
);
setBorderlessThread.Start();
}
// Finish drawing/dragging
private void pbxDisplay_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right) // Right click
{
// Summon a context menu
SelectedRect = GetPhraseAtPoint(e.Location); // Find all selected phrases
if (PhraseRects.FindAll(x => x.Selected == true).Count() < 1)
{
return; // Don't display menu if nothing's selected
}
ctxPhrase.Show(MousePosition); // Display menu
}
else // Left click
{
if (Marking == true) // We were drawing a bounding box
{
// Create a phrase box
Rectangle TestRect = MouseStart.RectTo(MouseEnd);
if (TestRect.Width > 25 && TestRect.Height > 15)
{
ChangeState(State.translated);
PhraseRect NewPRect = new PhraseRect(TestRect, OCRResult, this, AsyncTranslation_callback);
PhraseRects.Add(NewPRect);
}
Marking = false;
}
else
{ // We were selecting/dragging
PhraseRect PRect = GetPhraseAtPoint(e.Location);
if (PRect != null)
{
PhraseRects.FindAll(x => x.Selected == true).ForEach(x => x.UpdateText(OCRResult, AsyncTranslation_callback));
}
PhraseRects.ForEach(x => x.Clicked = false);
}
if (!Dragging && !StartingDrag)
{
// If the user wasn't holding shift, clear all other selections
if (!WindowFunctions.IsPressed((int)WindowFunctions.VirtualKeyStates.VK_LSHIFT))
{
PhraseRects.ForEach(x => { x.Clicked = false; x.Selected = false; });
}
}
}
Dragging = false;
StartingDrag = false;
pbxDisplay.Invalidate();
}
/// <summary>
/// This variant of IsWindowActivated simply checks whether a specified window handle
/// is currently focused rather than whether any window belonging to the current process
/// is focused.
/// </summary>
/// <returns>Returns true if the specified handle has focus, else false.</returns>
public static bool IsWindowActivated(IntPtr windowHandle)
{
// Obtain the active window handle.
IntPtr activatedHandle = WindowFunctions.GetForegroundWindow();
// Check if any window is active.
if (activatedHandle == IntPtr.Zero)
{
return(false);
}
// Compare the process identifiers of active window and our process.
return(activatedHandle == windowHandle);
}
/// <summary>
/// Expands the Frame Border Effect to the whole form.
/// Normally, without background rendering and a border, a window should technically
/// be invisible. However, this unfortunately is not the case as compositing does not default
/// apply to the client area of the window. Well, let's just make it apply and see the windows
/// underneath, sounds good?
/// </summary>
private void ExtendFrameToClientArea()
{
// Instantiate a new instance of the margins class.
Structures.WinapiRectangle formMargins = new Structures.WinapiRectangle
{
LeftBorder = 0,
TopBorder = 0,
RightBorder = Width,
BottomBorder = Height
};
// Extend the frame into client area.
WindowFunctions.DwmExtendFrameIntoClientArea(Handle, ref formMargins);
}
private void TopClick(object sender, MouseEventArgs e)
{
if (e.Clicks == 2)
{
WindowFunctions.ToggleMaximize(_skinWindow.Parent);
}
else if (_skinWindow.Maximized)
{
_skinWindow.Parent.Activate();
}
else
{
ForceParentCommand(SystemCommands.DragMove);
}
}
[DataRow(10, 30, -20)] // Source is shorter than frame
public void CheckWithNaiveImplementation(int sourceLength, int windowLength, int position)
{
var random = new Random(57);
var source = Enumerable.Range(0, sourceLength).Select(t => random.NextDouble()).ToArray();
var window = WindowFunctions.Hann(windowLength);
var expected = GetFrame_Naive(source, window, position);
var actual = Framing.GetFrame(source, window, position);
for (var t = 0; t < actual.Length; t++)
{
Assert.AreEqual(expected[t], actual[t], 1.0E-9);
}
}
public void Hann()
{
var hann = WindowFunctions.Hann(256);
Assert.AreEqual(256, hann.Length);
Assert.AreEqual(0.0, hann.First(), 1.0E-6);
Assert.AreEqual(0.0, hann.Last(), 0.001);
Assert.AreEqual(1.0, hann[128], 1.0E-6);
Assert.AreEqual(0.5, hann[64], 1.0E-6);
Assert.AreEqual(0.5, hann[192], 1.0E-6);
Assert.AreEqual(0.0, hann.Min(), 1.0E-6);
Assert.AreEqual(1.0, hann.Max(), 1.0E-6);
Assert.AreEqual(0.5, hann.Average(), 1.0E-6);
}
/// <summary>
/// FFT 演算をおこないます。
/// </summary>
/// <param name="source">フーリエ変換をおこなうデータ配列 (要素数は 2 の累乗であること)</param>
/// <param name="windowFunction">窓関数を指定する (デフォルトは矩形窓)</param>
/// <returns>フーリエ変換後のデータ配列</returns>
public static Complex[] FFT(this Complex[] source, WindowFunctions windowFunction)
{
int length = source != null ? source.Length : 0;
if (length <= 0)
return null;
// 2 の累乗かどうかを確認する
if ((length & (length - 1)) != 0)
return null;
var data = source.Clone() as Complex[];
var win = GetWindowFunction(windowFunction, length);
for (int i = 0; i < length; i++)
{
data[i] *= win[i];
}
return FFTCalculation(data, false);
}
[DataRow(10, 30, -20)] // Source is shorter than frame
public void CheckWithNaiveImplementation(int destinationLength, int windowLength, int position)
{
var random = new Random(57);
var destination = Enumerable.Range(0, destinationLength).Select(t => random.NextDouble()).ToArray();
var frame = Enumerable.Range(0, windowLength).Select(t => (Complex)random.NextDouble()).ToArray();
var window = WindowFunctions.Hann(windowLength);
var expected = destination.ToArray();
OverlapAdd_Naive(expected, frame, window, position);
var actual = destination.ToArray();
Framing.OverlapAdd(actual, frame, window, position);
for (var t = 0; t < actual.Length; t++)
{
Assert.AreEqual(expected[t], actual[t], 1.0E-9);
}
}
/// <summary>
/// Returns the coordinates of the edges of the client area of a specific window
/// relative to the desktop the window is presented on.
/// </summary>
/// <param name="windowHandle">Handle to the window of which the client area rectangle should be obtained.</param>
/// <returns></returns>
public static Structures.WinapiRectangle GetClientRectangle(IntPtr windowHandle)
{
// Obtains the coordinates of the edges of the window.
WindowFunctions.GetClientRect(windowHandle, out Structures.WinapiRectangle clientAreaRectangle);
// Get the coordinates of the top left point on the screen in client's area.
Structures.WinapiPoint topLeftClientCoordinate = new Structures.WinapiPoint();
WindowFunctions.ClientToScreen(windowHandle, ref topLeftClientCoordinate);
// Calculate each edge.
Structures.WinapiRectangle clientArea = new Structures.WinapiRectangle();
clientArea.LeftBorder = topLeftClientCoordinate.x;
clientArea.TopBorder = topLeftClientCoordinate.y;
clientArea.RightBorder = topLeftClientCoordinate.x + clientAreaRectangle.RightBorder;
clientArea.BottomBorder = topLeftClientCoordinate.y + clientAreaRectangle.BottomBorder;
// Return
return(clientArea);
}
/// <summary>
/// Class constructor. Instantiates both the overlay and DirectX Stuff.
/// Note: This method is blocking and Reloaded mods are required to return in order
/// to boot up the games, please do not assign this statically - instead assign it in a background thread!
/// </summary>
/// <param name="gameWindowHandle">
/// The handle of the game window to be overlayed.
/// The handle may be obtained via ReloadedProcess.GetProcessFromReloadedProcess().MainWindowHandle.
/// </param>
/// <param name="renderDelegate">
/// The user delegate which you may use for rendering to the external overlay
/// window with Direct2D.
/// </param>
/// <param name="hookDelay">
/// Specifies the amount of time to wait until the hook is instantiation begins.
/// Some games are known to crash if DirectX is hooked too early.
/// </param>
/// <returns>An instance of self (ExternalWindowOverlay) with the overlay enabled and running.</returns>
public static async Task <D2DOverlay> CreateExternalWindowOverlay(IntPtr gameWindowHandle, D2DWindowRenderer.DelegateRenderDirect2D renderDelegate, int hookDelay)
{
// Apply hook delay
await Task.Delay(hookDelay);
// Wait for the Window to show itself to screen before configuring.
while (WindowFunctions.IsWindowVisible(gameWindowHandle) == false)
{
await Task.Delay(32);
}
// Create self.
D2DOverlay externalWindowOverlay = new D2DOverlay();
// Enable the overlay.
externalWindowOverlay.EnableOverlay(renderDelegate, gameWindowHandle);
// Return self
return(externalWindowOverlay);
}
/// <summary>
/// Checks whether the current application is activated.
/// The method compares the current active foreground window to the
/// window thread of the current caller.
///
/// The function is not specific
/// to any technology and works for both child windows and the current window,
/// also independently of the thread which owns a specific window.
/// </summary>
/// <returns>Returns true if the current application has focus/is foreground/is activated. Else false.</returns>
public static bool IsWindowActivated()
{
// Obtain the active window handle.
IntPtr activatedHandle = WindowFunctions.GetForegroundWindow();
// Check if any window is active.
if (activatedHandle == IntPtr.Zero)
{
return(false);
}
// Retrieve unique identifier for this process.
int currentProcessIdentifier = System.Diagnostics.Process.GetCurrentProcess().Id;
// Retrieve the process identifier for the active window.
WindowFunctions.GetWindowThreadProcessId(activatedHandle, out int activeProcessIdentifier);
// Compare the process identifiers of active window and our process.
return(activeProcessIdentifier == currentProcessIdentifier);
}
/* GenerateWindow: generate the taper window, if `scaling_psd` = false then set `psd_scale` = 1 */
private void GenerateWindow(WindowType win_type, bool scaling_psd)
{
string win_name = win_type.ToString();
WindowFunctions wf = new WindowFunctions();
MethodInfo method = wf.function(win_name);
window = new double[n_epoch];
psd_scale = 0;
for (int i = 0; i < n_epoch; i++)
{
window[i] = Convert.ToDouble(method.Invoke(wf, new object[] { i, n_epoch }));
psd_scale += window[i] * window[i];
}
psd_scale = 1 / (psd_scale * Rate);
if (!scaling_psd)
{
psd_scale = 1.0;
}
}
/// <summary>
/// A crashfix for running Heroes at extreme resolutions, patches the resolution the rasters are created at.
/// </summary>
/// <returns></returns>
private static int TObjCameraInitHook(int *thisPointer, int cameraLimit)
{
int resolutionXBackup = *_resolutionX;
int resolutionYBackup = *_resolutionY;
int greaterResolution = resolutionXBackup > resolutionYBackup ? resolutionXBackup : resolutionYBackup;
// Get the window size.
Structures.WinapiRectangle windowLocation = WindowProperties.GetWindowRectangle(GameProcess.Process.MainWindowHandle);
// Set the window size.
WindowFunctions.MoveWindow(GameProcess.Process.MainWindowHandle, windowLocation.LeftBorder,
windowLocation.TopBorder, greaterResolution, (int)(greaterResolution / OriginalAspectRatio), false);
int result = _someTitlecardCreateHook.OriginalFunction(thisPointer, cameraLimit);
// Re-set the window size.
WindowFunctions.MoveWindow(GameProcess.Process.MainWindowHandle, windowLocation.LeftBorder,
windowLocation.TopBorder, resolutionXBackup, resolutionYBackup, false);
return(result);
}
public void CheckWithLinq(int sourceLength, int windowLength, int position)
{
var random = new Random(57);
var source = Enumerable.Range(0, sourceLength).Select(t => random.NextDouble()).ToArray();
var window = WindowFunctions.Hann(windowLength);
var expected = source.Skip(position).Take(windowLength).Select(value => (Complex)value).ToArray();
for (var t = 0; t < expected.Length; t++)
{
expected[t] *= window[t];
}
var actual = Framing.GetFrameComplex(source, window, position);
for (var t = 0; t < actual.Length; t++)
{
Assert.AreEqual(expected[t].Real, actual[t].Real, 1.0E-9);
Assert.AreEqual(expected[t].Imaginary, actual[t].Imaginary, 1.0E-9);
}
}
/// <summary>
/// 窓関数を取得します。
/// </summary>
/// <param name="windowFunction">窓関数を選択する</param>
/// <param name="length">データ数を指定する</param>
/// <param name="attenuation">(カイザー窓関数選択時のみ)減衰量を指定する</param>
/// <returns>窓関数値配列</returns>
public static double[] GetWindowFunction(WindowFunctions windowFunction, int length, double attenuation)
{
double[] win = null;
switch (windowFunction)
{
default:
case WindowFunctions.Rectangle:
win = RectangleWindowFunction(length);
break;
case WindowFunctions.Hanning:
win = HanningWindowFunction(length, false); // 本当は周期的な窓関数として取得するべきだが
break;
case WindowFunctions.Kaiser:
win = KaiserWindowFunction(length, attenuation);
break;
}
return(win);
}
// Takes a screenshot of the SnapRegion and returns it
private Image Snap()
{
bool VfwWasVisible = vfw.Visible;
if (VfwWasVisible)
{
vfw.Visible = false; // Hide viewfinder if appropriate
}
this.Visible = false; // Hide self (nobody wants to translate Babel)
try
{
if ((int)TrackingWindow != 0)
{
// Put this into a general function later
Rectangle WindowLoc = WindowFunctions.GetRectFromHwnd(TrackingWindow);
vfw.Location = new Point(WindowLoc.Left, WindowLoc.Top);
vfw.Size = new Size(WindowLoc.Width, WindowLoc.Height);
vfw.Flicker();
}
Image result = GDI32.Grab(SnapRegion);
if (VfwWasVisible)
{
vfw.Visible = true; // Reshow viewfinder if appropriate
}
this.Visible = true; // Show self again
this.Focus(); // Return focus to the main form
DebugLog.Log("Took snap");
return(result);
} catch (Exception ex)
{
DebugLog.Log(ex.Message);
return(null);
}
}
/// <summary>
/// 窓関数を取得します。
/// </summary>
/// <param name="windowFunction">窓関数を選択する</param>
/// <param name="length">データ数を指定する</param>
/// <returns>窓関数値配列</returns>
public static double[] GetWindowFunction(WindowFunctions windowFunction, int length)
{
return GetWindowFunction(windowFunction, length, 0);
}
/// <summary>
/// 窓関数を取得します。
/// </summary>
/// <param name="windowFunction">窓関数を選択する</param>
/// <param name="length">データ数を指定する</param>
/// <param name="attenuation">(カイザー窓関数選択時のみ)減衰量を指定する</param>
/// <returns>窓関数値配列</returns>
public static double[] GetWindowFunction(WindowFunctions windowFunction, int length, double attenuation)
{
double[] win = null;
switch (windowFunction)
{
default:
case WindowFunctions.Rectangle:
win = RectangleWindowFunction(length);
break;
case WindowFunctions.Hanning:
win = HanningWindowFunction(length, false); // 本当は周期的な窓関数として取得するべきだが
break;
case WindowFunctions.Kaiser:
win = KaiserWindowFunction(length, attenuation);
break;
}
return win;
}
/// <summary>
/// FFT 演算をおこないます。
/// </summary>
/// <param name="source">フーリエ変換をおこなうデータ配列 (要素数は 2 の累乗であること)</param>
/// <param name="windowFunction">窓関数を選択する</param>
/// <returns>フーリエ変換後のデータ配列</returns>
public static Complex[] FFT(this double[] source, WindowFunctions windowFunction)
{
return FFT(source.Select(i => new Complex(i)).ToArray(), windowFunction);
}
