北国风光，千里冰封，万里雪飘

Console in a window, Halflife like console system

2012-01-31T01:34:00.001-08:00

Adding Console I/O to a Win32 GUI App
Windows Developer Journal, December 1997
One of the common misconceptions surrounding Win32 programming is that you must decide early in the design process whether your application will be a console or GUI application. In reality, console applications can create windows and have a message loop just like a GUI application (see "Adding Graphics to Console Applications" by Michael Covington, Visual Developer, June/July 1997). Alternatively, graphical applications can create and use a console. Although Win32 provides functions for communicating with a console, they are a little clumsy to use and require parameters that are unnecessary for simple text I/O. This article shows how to use standard C/C++ I/O with consoles, and how to work around specific problems in the Visual C++ I/O library.
Win32 Handles versus RTL HandlesThe standard C I/O package operates on top of whatever I/O services the local operating system provides. Your C program then manipulates handles of type FILE*, no matter what the actual details of the physical file I/O are. The file I/O package that Win32 provides uses handles of type HANDLE, so Win32 C implementations of the standard I/O functions must internally associate a HANDLE with eachFILE*, and eventually call the Win32 API to perform the I/O.
C predefines the meaning of three handles: stdin, stdout, and stderr. These names refer to FILE* handles that refer to standard input, output, and error output. Win32 provides a similar concept; it provides a function called GetStdHandle(), and you can pass that function one of three constants (STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, or STD_ERROR_HANDLE) to obtain the HANDLE associated with standard input, standard output, or the standard error output. Exactly what these handles refer to depends on how your Win32 program was built and marked. These handles could be redirected to files, or they could be associated with a console window. If you launch a program from a DOS box (which is basically a console window), it may end up using that DOS box as its console window by default (that is, writing to standard output produces output in the DOS box window).
Win32 GUI applications do not, by default, have an associated console window. However, it is possible for your GUI application to explicitly create a console window and then manually associate standard C I/O handles (FILE*) with the appropriate Win32 handles (HANDLE) so that ordinary C runtime functions can operate on the console. To associate a C file handle with a Win32 file handle, the Visual C++ runtime library provides _open_osfhandle(). Given a valid Win32 handle, this function returns an RTL handle that internally operates on the given Win32 handle. This lets you transform the three console handles into compatible C file handles that you can use to redirect stdin, stdout, andstderr to the console.
C++ I/OOnce stdin, stdout, and stderr are redirected, standard C functions such as printf() and gets() can be used, without change, to communicate with the Win32 console. But what about C++ I/O streams? Since cin, cout, cerr, and clog are closely tied to C’s stdin, stdout, and stderr, you would expect them to behave similarly. This is half right.
C++ I/O streams actually come in two flavors: template and non- template. The older non-template version of I/O streams is slowly being replaced by a newer template style of streams first defined by the Standard Template Library (STL) and which are now being absorbed into the ANSI C++ standard. Visual C++ v5 provides both types and allows you to choose between the two by including different header files. STL I/O streams work as you would expect, automatically using any newly redirected stdio handles. Non-template I/O streams, however, do not work as expected. To discover why, I looked at the source code, conveniently provided on the Visual C++ CD-ROM.
The problem is that the older I/O streams were designed to use UNIX-style "file descriptors," where integers are used instead of handles (0 for stdin, 1 for stdout, and so on). That’s convenient for UNIX implementations, but Win32 C compilers have to provide yet another I/O layer to represent that style of I/O, since Win32 does not provide a compatible set of functions. In any case, when you call _open_osfhandle() to associate a new Win32 handle with (for example) stdout, it has no effect on the other layer of I/O code. Hence, file descriptor 1 will continue using the same underlying Win32 handle as before, and sending output to cout will not produce the desired effect.
Fortunately, the designers of the original I/O stream package foresaw this problem and provided a clean and useful solution. The base classios provides a static function, sync_with_stdio(), that causes the library to change its underlying file descriptors to reflect any changes in the standard I/O layer. Though this is not strictly necessary for STL I/O streams, it does no harm and lets me write code that works correctly with either the new or old form of I/O streams.
A Redirect Functionguicon.cpp (Listing 1) and guicon.h (Listing 2) provide code for redirecting C and C++ I/O to a Win32 console. RedirectIOToConsole() does all the work, creating a console and increasing the number of lines buffered with calls to AllocConsole() and SetConsoleScreenBufferSize()respectively. Each process is allowed only one console, so calling AllocConsole() multiple times will not produce multiple consoles. Increasing the screen buffer size allows you to scroll back and look at a history of up to MAX_CONSOLE_LINES of text. The code then creates a new FILE* handle for STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, and STD_ERROR_HANDLE, and the existing stdin, stdout, and stderr are replaced. setvbuf() is then called to turn off input and output buffering, effectively flushing the data with each read and write. Last, but not least, a call to ios::sync_with_stdio() ensures that cin, cout, cerr, and clog are associated with the new stdin, stdout, and stderr. The code is wrapped in preprocessor conditionals to allow it to be easily compiled out for release applications.
The code in test.cpp (Listing 3) is a sample of using RedirectIOToConsole(). It outputs text using the C stdio and C++ I/O streams and uses a simple integer to test input. Additionally, if you are using STL streams it tests the wide character versions of cin, cout, cerr, and clog. The rest of the code demonstrates how the Visual C++ C runtime debug functions can be used to output useful debugging information to the console. Since Win32 destroys the console when the application exits, I pause for two seconds before exiting so that you can see the last few pieces of output.
Overall, having a console associated with a Win32 GUI application is a very useful tool. Though similar debug text output can be achieved using Win32’s OutputDebugString() and DBWin32 (see "A DBWin32 Debugger for Windows" by Andrew Tucker, C/C++ Users Journal, October 1996), this console technique is much more portable between the Win32 API flavors (namely Windows 95 and NT) and it provides a method of input as well as output. Another application might be to use the console as a simple debugger that allows you to print out crucial data structures and inspect and change variables without the use of a full-blown interactive debugger. Finally, for those applications whose user interface makes sense as both a console app and a GUI, a command-line switch could allow the user to choose which is appropriate for their situation — something that is not as readily available when using a GUI from a console application.
ReferencesCovington, Michael. "Adding Graphics to Console Applications," Visual Developer, June/July 1997.
Tucker, Andrew. "A DBWin32 Debugger for Windows," C/C++ Users Journal, October 1996.
Andrew Tucker (ast@halcyon.com) is a software engineer in Seatte, WA. His programming interests include compilers, debuggers, and other areas of systems programming.
Listing 1: guicon.cpp -- A console redirection function#include
#include
#include
#include #include
#include #ifndef _USE_OLD_IOSTREAMS
using namespace std;
#endif// maximum mumber of lines the output console should have
static const WORD MAX_CONSOLE_LINES = 500;#ifdef _DEBUGvoid RedirectIOToConsole()
{
int hConHandle;
long lStdHandle;
CONSOLE_SCREEN_BUFFER_INFO coninfo;
FILE *fp;// allocate a console for this app
AllocConsole();// set the screen buffer to be big enough to let us scroll text
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
&coninfo);
coninfo.dwSize.Y = MAX_CONSOLE_LINES;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE),
coninfo.dwSize);// redirect unbuffered STDOUT to the console
lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "w" );
*stdout = *fp;
setvbuf( stdout, NULL, _IONBF, 0 );// redirect unbuffered STDIN to the console
lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "r" );
*stdin = *fp;
setvbuf( stdin, NULL, _IONBF, 0 );// redirect unbuffered STDERR to the console
lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "w" );
*stderr = *fp;
setvbuf( stderr, NULL, _IONBF, 0 );

// make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
// point to console as well
ios::sync_with_stdio();
}#endif
//End of File
Listing 2: guicon.h -- Interface to console redirection function#ifndef __GUICON_H__
#define __GUICON_H__#ifdef _DEBUG
void RedirectIOToConsole();
#endif#endif
/* End of File */Listing 3: test.cpp -- Demonstrating console redirection#include #include
#include
#include
#include #ifndef _USE_OLD_OSTREAMS
using namespace std;
#endif#include "guicon.h"
#include int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{#ifdef _DEBUG
RedirectIOToConsole();
#endif
int iVar;// test stdio
fprintf(stdout, "Test output to stdout\n");
fprintf(stderr, "Test output to stderr\n");
fprintf(stdout, "Enter an integer to test stdin: ");
scanf("%d", &iVar);
printf("You entered %d\n", iVar);//test iostreams
cout << "Test output to cout" << endl;
cerr << "Test output to cerr" << endl;
clog << "Test output to clog" << endl;
cout << "Enter an integer to test cin: ";
cin >> iVar;
cout << "You entered " << iVar << endl;#ifndef _USE_OLD_IOSTREAMS
// test wide iostreams
wcout << L"Test output to wcout" << endl;
wcerr << L"Test output to wcerr" << endl;
wclog << L"Test output to wclog" << endl;
wcout << L"Enter an integer to test wcin: ";
wcin >> iVar;
wcout << L"You entered " << iVar << endl;
#endif// test CrtDbg output
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR);
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR);_RPT0(_CRT_WARN, "This is testing _CRT_WARN output\n");
_RPT0(_CRT_ERROR, "This is testing _CRT_ERROR output\n");_ASSERT( 0 && "testing _ASSERT" );
_ASSERTE( 0 && "testing _ASSERTE" );Sleep(2000);return 0;
}
//End of File

Quaternion

2012-01-31T00:38:00.001-08:00

←BackUnder Construction...Related Topics: Euler's Equation Quaternion is a geometrical operator to represent the relationship (relative length and relative orientation) between two vectors in 3D space. William Hamilton invented Quaternion and completed the calculus of Quaternions to generalize complex numbers in 4 dimension (one real part and 3 imaginary numbers). In this article, we focus on rotations of 3D vectors because Quaternion implementation for 3D rotation is usually simpler, cheaper and better behaved than other methods.Background of QuaternionUnderstanding of QuaternionQuaternion Algebra3D Rotation with QuaternionSlerpBackground of QuaternionEuler's equation (formula) can be used to represent a 2D point with a length and angle on a complex plane. Multiplication of 2 complex numbers implies a rotation in 2D. One may think instantly it can be extended to 3D rotation by adding additional dimension. William Hamilton initially studied it by adding an additional imaginary number, j to generalize complex numbers to 3D. However, the set of 3 dimensional complex numbers is not closed under multiplication. For example, the multiplication of i and j cannot be represented as the form of a+ib+jc. If multiplication is closed, then there exist a, b, c ∈ R that satisfies ij=a+ib+jc. The equation c2+1=0 gives the contradiction. There is no real number c to satisfy c2+1=0.Later, Hamilton realized 4 dimensional complex numbers are required for multiplication to be closed. And, he denoted this 4D complex number set as Quaternion. (In mathematics, each algebra has twice the dimension of the previous one. Therefore, the higher number set of complex number is quaternion, and the next number set is octonion.)Now, the above example now satisfies as ij=0+i0+j0+k1. The condition of 3 imaginary numbers is explained later, in Quadrantal vectors.Understanding of QuaternionDefinition Definition of Quaternion operatorHamilton's motivation was to create a geometrical operator to transform from a vector to the other in 3D space. This operator is the geometric quotient (ratio) between two vectors that changes the length and the orientation, and it is called a Quaternion because the operation is required 4 parameters. , or, (Note that this notation is not same as numerical division nor multiplication. Instead, it is translated as "the quaternion operator q on to produce , or the operator q to convert into ".)Tensor and VersorWhen is transformed to vector , quaternion operator performs 2 distinct operations: 1. Tensor: scaling the length of , so as to make it of the same length as . 2. Versor: rotating , so as to cause it to coincide with in direction. These 2 opearions can be symbolically represented (tensor of q) and (versor of q) respectively. The order of these two operations does not make any difference of the result. The combined tensor and versor operation requires 4 numbers; 1 for scaling, 1 for rotation angle, 2 additional angles to determine the orientation of the rotation plane. For example, a xy-plane is rotated about x and y axis. But, rotation along z axis does not change the orientation of the xy plane. Tensor operatorTensor Tensor of q is the geometric quotient (ratio) between the lengths of 2 parallel vectors. It changes the scale of the vector, but, keeps the orientation of the vector unchanged. Versor operatorVersor Versor of q is the geometric quotient of 2 non-parallel vectors of equal length. It represents the relative orientation of one vector with respect to the other vector, but, it does not change the length of the vector.Expression with unit vectors Quaternion with unit vectorsTo investigate the quaternion operator deeper, let and as unit vectors along and . so that And, draw AC perpendicular to , and let the unit vector along be . Therefore, becomes and . Since , we substitute and in the above equation, then we have a quaternion, ; Vector of Rotation axisThe last term contains the geometric quotient of two unit vectors at right angles (90 degree) to each other. This quotient represents a unit vector perpendicular to the plane of and . (Think of cross product of 2 vectors) This unit vector is indicating the rotation axis of the plane and the direction of rotation. If we define it , the above equation becomes From this equation, A/B is tensor (scaling) operation of a quaternion, and is versor (rotation) operator of a quaternion. Note that versor of q is very similar to Euler's equation. Euler's equation contains an imaginary number i, but a quaternion has a vector instead, which is the rotation axis perpendicular to its rotation plane.Thus, a quaternion is also expressed as the sum of scalar S(q) and vector parts U(q); Quaternion can be also written as a 2-tuple form, [s, v]. A unit quaternion can be represented as , because tensor of q is 1 (no scaling).Quadrantal vectors, i j k Quadrantal vectorsLet i, j, k represent unit vectors orthogonal (perpendicular) each other. We define multiplications and divisions as rotating a unit vector to another at right angle. Note that, this multiplication and division is not numeric algebra. This kind of multiplication and quotient is called geometric. Thus, production or quotient of two unit vectors at right angles to each other produces a unit vector, perpendicular to their plane. And, it reads as i operating on j (or, rotating from i to j) produces k. In same manner, we can write other multiplications and divisions; The square of a unit vector can be defined from above equations; In same manner, Also, ijk can be defined as -1 using above multiplication table and square of unit vector. Quaternion AlgebraHere, the basic quaternion mathematics is described. These algebraic definitions and properties are specially required for rotation in 3D space, which describe in the next section. You may skip this section and move on the next section. And, come back later if you need to review a specific definition or property.1. Addition2. MultiplicationNote that quaternion multiplication is not commutative, however, multiplication is associative and distributive across addition. 3. Scalar MultiplicationUnlike quaternion multiplication, scalar multiplication is commutative.4. SubtractionQuaternion subtraction can be derived from scalar multiplication and quaternion addition. 5. ConjugateQuaternion congugate is defined by negating the vector part of the quaternion. Note that the multiplication of a quaternion and its conjugate is commutative.6. NormThe norm of a quaternion is defined by; The norm of quaternion is multiplicative meaning that the norm of the multiplication of multiple quaternions equals to the multiplication of the norms of quaternions. 7. InverseThe inverse of a quaternion is defined to be; The quaternion inverse makes it possible to divide two quaternions.8. Unit Quaternion Note that the inverse of a unit quaternion equals to the conjugate of the unit quaternion.3D Rotation with QuaternionIn 2D, the multiplication of two complex numbers implies 2D rotation. When z=x+iy is multiplied by , the length of z' remains same (|z|=|z'|), but the angle of z' is added by θ. (See details in Euler's equation.)However, multiplying a quaternion p by a unit quaternion q does not conserve the length (norm) of the vector part of the quaternion p. For example; Thus, we need a special multiplication for 3D rotations that is length-conserving transformation. For this reason, we multiply the unit quaternion q at the front of p and multiplying q-1 at the back of p, in order to cancel out the length changes. This special double multiplication is called "conjugation by q".If q is a unit quaternion and p = [s, v], then the scalar (s) and the length of v, |v| are unchanged after conjugation by q. For the above example; ProofIf p = [s, v] and p' = qpq-1, then p' = [s, v'] where |v| = |v'|The proof takes 3 steps. First, we show S(p)=S(p') for p=[s, 0], then for p=[0, v]. Finally, both results are used to show S(p)=S(p') for p=[s, v]=[s, 0]+[0, v].1. If p has a scalar part only p = [s, 0], then 2. If p has a vector part only p = [0, v], then the scalar part of qpq-1 can be computed by 2S(q)=q+q*. 3. If p = [s, v] = [s, 0] + [0, v], then Since we found that the scalar parts of p and p' are same, the norm of p' is; © 2008 Song Ho Ahn ←Back

Convolution

2012-01-31T00:36:00.003-08:00

←BackConvolutionConvolution is the most important and fundamental concept in signal processing and analysis. By using convolution, we can construct the output of system for any arbitrary input signal, if we know the impulse response of system. How is it possible that knowing only impulse response of system can determine the output for any given input signal? We will find out the meaning of convolution.Related Topics: Window Filters Download: conv1d.zip, conv2d.zipDefinitionImpulse Function DecompositionImpulse ResponseBack to the DefinitionConvolution in 1DC++ Implementation for Convolution 1DConvolution in 2DSeparable Convolution 2DC++ Algorithm for Convolution 2DDefinitionFirst, let's see the mathematical definition of convolution in discrete time domain. Later we will walk through what this equation tells us. (We will discuss in discrete time domain only.) where x[n] is input signal, h[n] is impulse response, and y[n] is output. * denotes convolution. Notice that we multiply the terms of x[k] by the terms of a time-shifted h[n] and add them up. The keystone of understanding convolution is laid behind impulse response and impulse decomposition.Impulse Function DecompositionIn order to understand the meaning of convolution, we are going to start from the concept of signal decomposition. The input signal is decomposed into simple additive components, and the system response of the input signal results in by adding the output of these components passed through the system.In general, a signal can be decomposed as a weighted sum of basis signals. For example, in Fourier Series, any periodic signal (even rectangular pulse signal) can be represented by a sum of sine and cosine functions. But here, we use impulse (delta) functions for the basis signals, instead of sine and cosine.Examine the following example how a signal is decomposed into a set of impulse (delta) functions. Since the impulse function, δ[n] is 1 at n=0, and zeros at n ≠ 0. x[0] can be written to 2·δ[n]. And, x[1] will be 3·δ[n-1], because δ[n-1] is 1 at n=1 and zeros at others. In same way, we can write x[2] by shifting δ[n] by 2, x[2] = 1·δ[n-2]. Therefore, the signal, x[n] can be represented by adding 3 shifted and scaled impulse functions. In general, a signal can be written as sum of scaled and shifted delta functions; Impulse ResponseImpulse response is the output of a system resulting from an impulse function as input. And it is denoted as h[n]. If the system is time-invariant, the response of a time-shifted impulse function is also shifted as same amount of time. For example, the impulse response of δ[n-1] is h[n-1]. If we know the impulse response h[n], then we can immediately get the impulse response h[n-1] by shifting h[n] by +1. Consequently, h[n-2] results from shifting h[n] by +2.If the system is linear (especially scalar rule), a scaled in input signal causes an identical scaling in the output signal. For instance, the impulse response of 3·δ[n] is just multiplying by 3 to h[n].If the input has 3 components, for example, a·δ[n] + b·δ[n-1] + c·δ[n-2], then the output is simply a·h[n] + b·h[n-1] + c·h[n-2]. This is called additive property of linear system, thus, it is valid only on the linear system. Back to the DefinitionBy combining the properties of impulse response and impulse decomposition, we can finally construct the equation of convolution. In linear and time-invariant system, the response resulting from several inputs can be computed as the sum of the responses each input acting alone. For example, if input signal is x[n] = 2·δ[n] + 3·δ[n-1] + 1·δ[n-2], then the output is simply y[n] = 2·h[n] + 3·h[n-1] + 1·h[n-2]. Therefore, we now clearly see that if the input signal is , then the output will be . Note one condition; convolution works on the linear and time invariant system.To summarize, a signal is decomposed into a set of impulses and the output signal can be computed by adding the scaled and shifted impulse responses.Furthermore, there is an important fact under convolution; the only thing we need to know about the system's characteristics is the impulse response of the system, h[n]. If we know a system's impulse response, then we can easily find out how the system reacts for any input signal.Convolution in 1DLet's start with an example of convolution of 1 dimensional signal, then find out how to implement into computer programming algorithm.x[n] = { 3, 4, 5 } h[n] = { 2, 1 }x[n] has only non-zero values at n=0,1,2, and impulse response, h[n] is not zero at n=0,1. Others which are not listed are all zeros. Input: x[n] Impulse Response: h[n]One thing to note before we move on: Try to figure out yourself how this system behaves, by only looking at the impulse response of the system. When the impulse signal is entered the system, the output of the system looks like amplifier and echoing. At the time is 0, the intensity was increased (amplified) by double and gradually decreased while the time is passed.From the equation of convolution, the output signal y[n] will be . Let's compute manually each value of y[0], y[1], y[2], y[3], ... Output: y[n]Notice that y[0] has only one component, x[0]h[0], and others are omitted, because others are all zeros at k ≠ 0. In other words, x[1]h[-1] = x[2]h[-2] = 0. The above equations also omit the terms if they are obviously zeros. If n is larger than and equal to 4, y[n] will be zeros. So we stop here to compute y[n] and adding these 4 signals (y[0], y[1], y[2], y[3]) produces the output signal y[n] = {6, 11, 14, 5}.Let's look more closely the each output. In order to see a pattern clearly, the order of addition is swapped. The last term comes first and the first term goes to the last. And, all zero terms are ignored.y[0] = x[0]·h[0] y[1] = x[1]·h[0] + x[0]·h[1] y[2] = x[2]·h[0] + x[1]·h[1] y[3] = x[3]·h[0] + x[2]·h[1]Can you see the pattern? For example, y[2] is calculated from 2 input samples; x[2] and x[1], and 2 impulse response samples; h[0] and h[1]. The input sample starts from 2, which is same as the sample point of output, and decreased. The impulse response sample starts from 0 and increased.Based on the pattern that we found, we can write an equation for any sample of the output; where i is any sample point and k is the number of samples in impulse response. For instance, if an impulse response has 4 samples, the sample of output signal at 9 is; y[9] = x[9]·h[0] + x[8]·h[1] + x[7]·h[2] + x[6]·h[3] Notice the first sample, y[0] has only one term. Based on the pattern that we found, y[0] is calculated as: y[0] = x[0]·h[0] + x[-1]·h[1]. Because x[-1] is not defined, we simply pad it to zero.C++ Implementation for Convolution 1DImplementing the convolution algorithm is quite simple. The code snippet is following;for ( i = 0; i < sampleCount; i++ ){ y[i] = 0; // set to zero before sum for ( j = 0; j < kernelCount; j++ ) { y[i] += x[i - j] * h[j]; // convolve: multiply and accumulate }}However, you should concern several things in the implementation. Watch out the range of input signal. You may be out of bound of input signal, for example, x[-1], x[-2], and so on. You can pad zeros for those undefined samples, or simply skip the convolution at the boundary. The results at the both the beginning and end edges cannot be accurate anyway. Second, you need rounding the output values, if the output data type is integer and impulse response is floating point number. And, the output value may be exceeded the maximum or minimum value. If you have unsigned 8-bit integer data type for output signal, the range of output should be between 0 and 255. You must check the value is greater than the minimum and less than the maximum value. Download the 1D convolution routine and test program. conv1d.zipConvolution in 2D2D convolution is just extension of previous 1D convolution by convolving both horizontal and vertical directions in 2 dimensional spatial domain. Convolution is frequently used for image processing, such as smoothing, sharpening, and edge detection of images. The impulse (delta) function is also in 2D space, so δ[m, n] has 1 where m and n is zero and zeros at m,n ≠ 0. The impulse response in 2D is usually called "kernel" or "filter" in image processing. The second image is 2D matrix representation of impulse function. The shaded center point is the origin where m=n=0.Once again, a signal can be decomposed into a sum of scaled and shifted impulse (delta) functions; For example, x[0, 0] is x[0, 0]·δ[m, n], x[1, 2] is x[1, 2]·δ[m-1, n-2], and so on. Note that the matrices are referenced here as [column, row], not [row, column]. M is horizontal (column) direction and N is vertical (row) direction.And, the output of linear and time invariant system can be written by convolution of input signal x[m, n], and impulse response, h[m, n]; Notice that the kernel (impulse response) in 2D is center originated in most cases, which means the center point of a kernel is h[0, 0]. For example, if the kernel size is 5, then the array index of 5 elements will be -2, -1, 0, 1, and 2. The origin is located at the middle of kernel.Examine an example to clarify how to convolve in 2D space. Let's say that the size of impulse response (kernel) is 3x3, and it's values are a, b, c, d,... Notice the origin (0,0) is located in the center of kernel. Let's pick a simplest sample and compute convolution, for instance, the output at (1, 1) will be; It results in sum of 9 elements of scaled and shifted impulse responses. The following image shows the graphical representation of 2D convolution. 2D ConvolutionNotice that the kernel matrix is flipped both horizontal and vertical direction before multiplying the overlapped input data, because x[0,0] is multiplied by the last sample of impulse response, h[1,1]. And x[2,2] is multiplied by the first sample, h[-1,-1].Exercise a little more about 2D convolution with another example. Suppose we have 3x3 kernel and 3x3 input matrix. Input Kernel OutputThe complete solution for this example is here; Example of 2D ConvolutionBy the way, the kernel in this example is called Sobel filter, which is used to detect the horizontal edge lines in an image. See more details in the window filters.Separable Convolution 2DIn convolution 2D with M×N kernel, it requires M×N multiplications for each sample. For example, if the kernel size is 3x3, then, 9 multiplications and accumulations are necessary for each sample. Thus, convolution 2D is very expensive to perform multiply and accumulate operation. However, if the kernel is separable, then the computation can be reduced to M + N multiplications. A matrix is separable if it can be decomposed into (M×1) and (1×N) matrices. For example; And, convolution with this separable kernel is equivalent to; (Proof of Separable Convolution 2D)As a result, in order to reduce the computation, we perform 1D convolution twice instead of 2D convolution; convolve with the input and M×1 kernel in vertical direction, then convolve again horizontal direction with the result from the previous convolution and 1×N kernel. The first vertical 1D convolution requires M times of multiplications and the horizontal convolution needs N times of multiplications, altogether, M+N products. However, the separable 2D convolution requires additional storage (buffer) to keep intermediate computations. That is, if you do vertical 1D convolution first, you must preserve the results in a temporary buffer in order to use them for horizontal convolution subsequently. Notice that convolution is associative; the result is same, even if the order of convolution is changed. So, you may convolve horizontal direction first then vertical direction later. Gaussian smoothing filter is a well-known separable matrix. For example, 3x3 Gaussian filter is; 3x3 Gaussian Kernel C++ Algorithm for Convolution 2DWe need 4 nested loops for 2D convolution instead of 2 loops in 1D convolution. // find center position of kernel (half of kernel size)kCenterX = kCols / 2;kCenterY = kRows / 2;for(i=0; i < rows; ++i) // rows{ for(j=0; j < cols; ++j) // columns { sum = 0; // init to 0 before sum for(m=0; m < kRows; ++m) // kernel rows { mm = kRows - 1 - m; // row index of flipped kernel for(n=0; n < kCols; ++n) // kernel columns { nn = kCols - 1 - n; // column index of flipped kernel // index of input signal, used for checking boundary ii = i + (m - kCenterY); jj = j + (n - kCenterX); // ignore input samples which are out of bound if( ii >= 0 && ii < rows && jj >= 0 && jj < cols ) out[i][j] += in[ii][jj] * kernel[mm][nn]; } } }}The above snippet code is simple and easiest way to understand how convolution works in 2D. But it may be the slowest implementation.Take a look at a real example; convolution with 256x256 image and 5x5 Gaussian filter. The source image is uncompressed raw, 8-bit (unsigned char) grayscale image. And again, Gaussian kernel is separable; 5x5 Gaussian KernelOn my system (AMD 64 3200+ 2GHz), normal convolution took about 10.3 ms and separable convolution took only 3.2 ms. You can see how much separable convolution is faster compared to normal convolution.Download 2D convolution application and source code here: conv2d.zip The program uses OpenGL to render images on the screen.© 2005 Song Ho Ahn ←Back

Variety of Systems

2012-01-31T00:36:00.001-08:00

Linear SystemTime-Invariant SystemCausal SystemLinear SystemSystems that satisfy both homogeneity and additivity are considered to be linear system.Homogeneity (scalar rule) means that as the strength of input signal is increased (scaled), then the strength of output signal will be also increased (scaled) with same amount. Additivity denotes that the output of system can be computed as sum of the responses resulting from each input signal acting alone. Taking these two rules together is called the principle of superposition. Therefore, the linear system can be presented as; If input signal can be decomposed as a weighted sum of basis signals, the output of linear system is; ExamplesDetermine if it is linear. 1) sol> ∴ linear system2) sol> ∴ non-linear system Time-Invariant SystemA system is time-invariant if a time shift in input signal causes an identical time shift in output signal. ExamplesDetermine Time-Invariant. 1) sol> 2) sol> Causal SystemA system is causal if the output at any time depends on values of the input at only the present and past times. In other words, the causal system does not anticipate future values of input. For example, the output y(t0) depends on input x(t) for t ≤ t0. Non-Causal SystemThis is an example of non-causal system, because the output responds ahead at t = t0 before input is defined. A causal system is characterized by an impulse response h(t) that is zeros for t < 0.Examples1) Causal, because t ≥ t-22) Non-Causal, because t t+1 © 2005 Song Ho Ahn ←Back

Types of Signals

2012-01-31T00:35:00.001-08:00

Continuous-Time SignalDiscrete-Time SignalPeriodic SignalOrthogonal SignalEven and Odd SignalEnergy Signal & Power SignalContinuous Time SignalIf the independent variable (t) is continuous, then the corresponding signal is continuous time signal. Discrete Time SignalIf the independent variable (t) takes on only discrete values, for example t = ±1, ±2, ±3, ... Periodic SignalIf the transformed signal is same as x(t), then the signal is periodic. where T is fundamental period (the smallest period) of signal x(t) In discrete-time, the periodic signal is; Orthogonal SignalEach component signal has no relationship with others. Orthogonal signal is denoted as φ(t). Even and Odd SignalOne of characteristics of signal is symmetry that may be useful for signal analysis. Even signals are symmetric around vertical axis, and Odd signals are symmetric about origin. Even Signal: A signal is referred to as an even if it is identical to its time-reversed counterparts; x(t) = x(-t). Odd Signal: A signal is odd if x(t) = -x(-t). An odd signal must be 0 at t=0, in other words, odd signal passes the origin. Using the definition of even and odd signal, any signal may be decomposed into a sum of its even part, xe(t), and its odd part, xo(t), as follows: It is an important fact because it is relative concept of Fourier series. In Fourier series, a periodic signal can be broken into a sum of sine and cosine signals. Notice that sine function is odd signal and cosine function is even signal.Example Energy Signal & Power SignalIn physics, energy is work and power is work per time; Work = Force × Displacement Power = Work / Time For Kinetic energy is given by In an electrical signal, the instantaneous power for the voltage across the resistance R and its energy are defined; In signal processing, total energy of signal x(t) is defined as similar way; (Notice that it is square of absolute value.) where |x(t)| denotes the magnitude of x(t). It is necessary to get a scalar quantity for complex signal, because magnitude of complex number is defined as .And, it is also squared because of common convention to use similar terminology for any signal (look at the definitions of kinetic and electrical signal energy). Therefore, the energy of a signal is defined as a sum of square of magnitude.The average power of signal is defined by; A signal can be categorized into energy signal or power signal: An energy signal has a finite energy, 0 < E < ∞. In other words, energy signals have values only in the limited time duration. For example, a signal having only one square pulse is energy signal. A signal that decays exponentially has finite energy, so, it is also an energy signal. The power of an energy signal is 0, because of dividing finite energy by infinite time (or length).On the contrary, the power signal is not limited in time. It always exists from beginning to end and it never ends. For example, sine wave in infinite length is power signal. Since the energy of a power signal is infinite, it has no meaning to us. Thus, we use power (energy per given time) for power signal, because the power of power signal is finite, 0 < P < ∞.Examples1) E = 1, and , ∴ Energy signal.2) E = ∞ , and , ∴ Power signal.© 2005 Song Ho Ahn ←Back

CVSTortoise 避免重复输入密码，并且安全的方法

2011-12-16T01:07:00.000-08:00

Tired of typing your password into SSH all the time? Yes, you can apply common, open-source tools to do this for any application of SSH. Isn't open software cool! Read-on...

General SSH questions, a bit of background on SSH and specifically Public Key Cryptography, and versions of SSH clients can be found in my mini-SSH FAQ.

Creating and Using SSH Identities

The first step in secure, password-free SSH is to create an SSH identity. An SSH identity is a private/public key pair, which are similar in functionality to to PGP keys, or SSL keys and SSL certificates. The public key of the identity pair will be placed on the remote servers to which you wish to connect and the private key will remain on the client or local machine. When you connect from your client, the ssh program will offer to use identity-based authentication for each key it has available. If the server sees a corresponding public key on its end, it tells the client to prove that it has the private key, which is does by a mathematically rigourous means that we can ignore at this time.

We can do this with either OpenSSH or with PuTTY.

Configuring OpenSSH to use Identities

Installing OpenSSH

If you are running on a UNIX box without SSH (many do by default), have your system administrator build and install OpenSSH. A version of this is installed by default on most Linux platforms, but you or your system admistrator should update it as there are often security-related patches made available on the OpenSSH web site.

If you are running on a Windows platform and use CYGWIN, you should already have SSH installed. Again, make sure you keep up with new releases of the SSH package (via the CYGWIN installer) for security.

Configuring OpenSSH

Create the identiy-key pair:
```
cd ~/.ssh
ssh-keygen
```
This creates your private/public key pair: (~/.ssh/id_rsa and ~/.ssh/id_rsa.pub). The program will ask you for a passphrase to encode your private key; be sure to use a good passphrase of more than 10 or so characters. If you choose not to use a passphrase, you will not have to implement the ssh-agent or putty-agent steps below, however I do not recommend this; Without a passphrase, your private key can be easily read by anyone and may be used to impersonate you on any server where you place your public key.
Instead of RSA, you may use DSA (-t dsa) either is fine, though I would not recommend using RSA1 for security reasons.
Copy the public key to the remote server:
```
scp ~/.ssh/id_rsa.pub user@remote.host:pubkey.txt
ssh user@remote.host
mkdir ~/.ssh
chmod 700 .ssh
cat pubkey.txt >> ~/.ssh/authorized_keys
rm ~/pubkey.txt
chmod 600 ~/.ssh/*
exit
```
Be sure to replace user@remote.host with the appropriate username and host. This copies your public key to the remote server machine. Public keys are those with the .pub extension. You need to do this for each server into which you wish to login via SSH without a password. Alternatively, you could now copy the ~/.ssh/authorized_keys file to other systems to allow access from the local system. Also, if you have multiple keys, you can add the public key of each pair to theauthorized_keys file, either by appending to the file or using a text editor. If you use cut and paste to copy the key, make sure each key entry is a single line in the file. Remember, the keys to add are always the public keys (from files with the .pubextension).
Test the remote public key:
```
ssh user@remote.host

exit 
```
This is a test -- This time, instead of your password on the remote host, SSH should prompt you for the passphrase for your private key.
Start the ssh-agent:
Now we get to the meat of this document and figure out how to avoid typing either a password or a passphrase every time...
```
eval `ssh-agent`
```
This starts the ssh-agent, which is a process which runs in the background and listens for "requests" from ssh clients needing your private key. The output of ssh-agent is a set of environment variables which need to be eval-ed in order for futuressh clients to know that there is a server out there. Do not start more than one instance of ssh-agent.
Add your private key to the agent's cache:
```
ssh-add
```
This adds your private key(s) to the list of keys held by ssh-agent. ssh-add will ask you for the passphrase of each key it is adding to the agent's pool. Note that this need only be done once after you start the ssh-agent daemon.
Test the connection again:
```
ssh user@remote.host
exit
```
This is a test -- This time you should not have to type any passwords or passphrases as ssh should get your private key from the agent daemon.

That's all there is to setting up ssh and ssh-agent to use public-key encryption and avoid entering your password multiple times a day. Any application that uses SSH should no longer require passwords. All that remains is to configure CVS to use SSH.

You should know that ssh-agent stores your private key(s) in memory in the clear (read: unencrypted) to give to ssh clients that request it. Note that the mechanisms by which ssh-agent talks to ssh are based upon UNIX sockets and UNIX system permissions protect those against unauthorized access, so you need not worry about this. There is some question about the security of this mechanism under CYGWIN on Win32 platforms, but I feel the risks are not greater than the benefits, especially if you are the only person with access to your Windows box. Just lock your screen when you are not present - common sence.

One other tweak one can make: Realize that by using this "manual" approach of starting the agent and evaluating the results in your shell, only sub-shells of the current shell will know about the running ssh-agent. An alternative approach that I use is to run a short script that starts the agent daemon if it is not already running and sets the appropriate environment variables.

Setup an automated start-agent script:
First, click here for my sssha script. It is a BASH shell script, so if you use a different login shell, you will have to modify it. Once you download it, place it in your ~/.ssh/ directory and add this to your ~/.bashrc configuration script, presumably at or near the end:
```
# setup ssh-agent, if appropriate
if [ -f "$HOME/.ssh/sssha" ]; then
   source $HOME/.ssh/sssha
fi 
```

Finally, if you are truly paranoid, make sure to kill your ssh-agent when you are done using any machine on which you have started one. This can be accomplished most simply with ssh-agent -k.

Configuring PuTTY to use Identities

Installing PuTTY (Windows only)

First, you need to fetch PuTTY which is available from here: http://www.chiark.greenend.org.uk/~sgtatham/putty/ or a Google search on PuTTY should find it too. The installer is a fairly typical windows installer, so just go ahead and run it. The defaults are perfectly acceptable.

Configuring PuTTY

Figure 1: PuTTY ConfigurationOnce you have PuTTY installed, run PuTTY and you will be presented with a PuTTY Configuration window that looks something like that in Figure 1. Adjust each Category of settings as follows:

Session
- Check: SSH
Connection
- Auto-login username: username
  with your username
Connection » SSH
- Preferred SSH protocol version: 2
Connection » SSH » Auth
- Check: allow agent forwarding
- [ you will come back here later to specify your Private key file for authentication ]

Go back to the Session category, click on the Saved Session named Default Settings and click Save. These are now your default PuTTY options.

Test the settings by typing the name of a remote host into the Host Name box and clicking Open. You should be prompted for your remote password and eventually get a shell window.

Go ahead and close that shell by typing exit.

Generating your Public/Private Keys

Figure 2: Generating your keyWith PuTTY configured, you can now generate your public/private key. On the Windows START menu, where PuTTY shortcuts were installed, should be a shortcut for PuTTYgen. You should see a window like that in Figure 2.

Check: SSH2 RSA (or SSH2 DSA, but NOT SSH1 RSA)
Click: Generate
While PuTTYgen is generating your key, create some "entropy" by moving the mouse around in the empty area of the window.
Enter a Key Passphrase
Make sure it is a good passphrase of more than 10 or so characters. If you choose not to use a passphrase, you will not have to use the PuTTY-Agent (below), however I do not recommend this; Without a passphrase, your private key can be easily read by anyone and may be used to impersonate you on any server where you place your public key.
Click: Save Private Key
Select a place to put your keys such as your home directory; name it something like PuTTY-Private.ppk
Click: Save Public Key
Save it to the same directory as the private key, presumably; name it something like PuTTY-Public.pub
Create your authorized_keys file by coping the text from the Public Key for pasting into authorized_keys text-box into a file, again presumably to the same directory, named something like openssh-key.pub

Configure the Server's `~/.ssh/authorized_keys` file

You now need to copy your public key to the remote SSH server and update one setting in your PuTTY configuration:

Store your openssh-key.pub on the remote server in your remote ~/.ssh/authorized_keys file:
1. Open Command/Shell Prompt by typing cmd in the Windows Run dialog or by starting a CYGWIN shell.
2. Copy Public Key to Server: at the command prompt, enter:
```
[ CMD: ]
pscp c:\path\to\openssh-key.pub username@cvs.server.com:openssh-key.pub
or
[ CYGWIN: ]
scp /cygdrive/c/path/to/openssh-key.pub username@cvs.server.com:openssh-key.pub
```
  ...where c:\path\to\openssh-key.pub specifies the location of the key file created in step two, and username@cvs.server specifies your user name on the CVS server and the hostname of the CVS server. You may be prompted to confirm the legitimacy of the host, and you will be prompted to enter your password for the CVS server.
3. Connect using PuTTY: if necessary, run the putty program, entering the name of the remote cvs server.
4. Configure the Key on the CVS Server: after logging into the CVS server, enter the following commands to place your public key into the remote~/.ssh/authorized_keys file:
```
mkdir ~/.ssh
chmod 700 .ssh
cat ~/openssh-key.pub >> ~/.ssh/authorized_keys
rm ~/openssh-key.pub
chmod 600 ~/.ssh/*
exit 
```
  You can also copy/paste, ftp, email or transmit your public key to the remote server by any means you find convenient. Just put the contents in the ~/.ssh/authorized_keys file, ensuring that what you paste is only one (long) line.
Configure PuTTY to use the Private Key: Open PuTTY again; when the configuration window opens:
- Open the Connection » SSH » Auth configuration category
- Set the location of your PuTTY-Private.ppk file in the Private Key File for Authentication box
- Return to the Session configuration category
- Select and save your settings into the Default Settings

Test the settings by typing the name of the remote host into the Host Name box and clicking Open. You should be prompted the passphrase of your private key rather than for your remote password; close the resulting shell window by typing exit.

Starting the PuTTY-Agent (Pageant)

Run the pageant program from the START menu. This will load the PuTTY Authentication Agent into the Windows System Tray; it appears as a little computer with a "secret agent hat". PuTTY-Agent is a process which runs in the background and listens for "requests" from PuTTY clients needing your private key.

When PuTTY-Agent starts, it doesn't know about your private keys by default. Right-click the Pageant icon in the Windows System Tray. Select Add Key. Navigate to the directory where you saved the public and private keys in the previous step, and select the file PuTTY-Private.ppk. Pageant will prompt you for the passphrase of the key.

Now you are basically done. Restart PuTTY again to test the settings one last time; enter the name of the remote host into the Host Name box and clicking Open. You should NOT be prompted the passphrase of your private key nor your remote password; close the resulting shell window by typing exit.

Auto-Start PuTTY-Agent Upon Login

Pageant can automatically load one or more private keys when it starts up, if you provide them on the Pageant command line (i.e. in a shortcut). If you copy the standard Pageant shortcut, append the location of your key(s) to the Target: line. It might look something like this:

C:\PuTTY\pageant.exe d:\main.key d:\secondary.key

If the keys are stored encrypted, Pageant will request the passphrases on startup.

If you place that new shortcut in your Startup folder, it should be loaded automatically when you login to Windows.

Using PuTTY Keys for OpenSSH and vice-versa

If you already have keys used for OpenSSH or for PuTTY, you may use those keys in the other application, but you need to go through an import or export step using PuTTYgen.

First, open PuTTYGen again...

To import a OpenSSH key into PuTTY:

In PuTTYgen, select: Conversions » Import Key
Browse to your private OpenSSH key and select Open.
You should be required to enter your private key passphrase.
Click: Save Private Key
Select a place to put your keys such as your home directory; name it something like PuTTY-Private.ppk
Click: Save Public Key
Save it to the same directory as the private key, presumably; name it something like PuTTY-Public.pub

Everything else should proceed as before, including using PuTTY-Agent (Pageant), but be sure to tell PuTTY about your new Private Key as above.

To export a PuTTY key for OpenSSH:

In PuTTYgen, select: Conversions » Load Private Key
Browse to your private PuTTY key and select Open.
You should be required to enter your private key passphrase.
Select: Conversions » Export OpenSSH Key
Select a place to put your keys such as your home directory; name it something like openssh-key.
To save the public key, follow the same instructions for creating the openssh-key.pub file as above.

Everything else should proceed as before, including using PuTTY-Agent (Pageant), but be sure to copy your openSSH key to the server, as above.

6 ways to get HBRUSH

2011-12-09T03:15:00.001-08:00

HBRUSH hbr;
第一种: hbr= CreateSolidBrush(RGB(255,0,0));    //单色的画刷
第二种: hbr= (HBRUSH)GetStockObject(BLACK_BRUSH);  //只能取特定颜色的画刷,如BLACK_BRUSH,GRAY_BRUSH等刷
第三种: hbr= CreatePatternBrush(HBITMAP hbmp);    //得到位图画刷
第四种: hbr = CreateHatchBrush(int fnStyle, COLORREF clrref)    //创建一种带阴影的画刷
第五种: hbr= CreateBrushIndirect(LOGBRUSH);     //通过LOGBRUSH结构体来取画刷
typedef struct tagLOGBRUSH {     UINT         lbStyle; //画刷类型    COLORREF lbColor; //颜色        LONG         lbHatch; //阴影} LOGBRUSH, *PLOGBRUSH;
第六种: hbr= HBRUSH CreateDIBPatternBrush(       //通过与设备无关位图创建一个画刷        HGLOBAL hglbDIBPacked,      // handle to DIB
     UINT fuColorSpec        // color table data
      );
例如：
HBRUSH CAfdView::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
HBRUSH hbr = CFormView::OnCtlColor(pDC, pWnd, nCtlColor);

// TODO: Change any attributes of the DC here
if (pWnd->GetDlgCtrlID()==IDC_STATIC1)
{
    pDC->SetTextColor(RGB(200,0,0));
    pDC->SetBkColor(RGB(0,0,255));
  static HBRUSH hBrush = CreateSolidBrush(RGB(222,0,255));
  return hBrush;
}
        // TODO: Return a different brush if the default is not desired
else
  return hbr;
}
改变对话框背景色
HBRUSH CDqfDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);

// TODO: Change any attributes of the DC here

// TODO: Return a different brush if the default is not desiredif(nCtlColor == CTLCOLOR_DLG)
   {
   CBrush *brush;
    brush = new CBrush(RGB(221,221,221));
   return (HBRUSH)(brush->m_hObject);
   }
return hbr;
}