4 |47 | 48 | 49 | -------------------------------------------------------------------------------- /Tracke/klt/Klt/Klt.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 14 4 | VisualStudioVersion = 14.0.25420.1 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Klt", "Klt.vcxproj", "{466E641E-CE88-4EED-A37E-53B725C49BC3}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x86 = Debug|x86 11 | Release|x86 = Release|x86 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {466E641E-CE88-4EED-A37E-53B725C49BC3}.Debug|x86.ActiveCfg = Debug|Win32 15 | {466E641E-CE88-4EED-A37E-53B725C49BC3}.Debug|x86.Build.0 = Debug|Win32 16 | {466E641E-CE88-4EED-A37E-53B725C49BC3}.Release|x86.ActiveCfg = Release|Win32 17 | {466E641E-CE88-4EED-A37E-53B725C49BC3}.Release|x86.Build.0 = Release|Win32 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /Tracke/klt/Klt/Klt.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 |Build Log
5 |6 | --------------------Configuration: Klt - Win32 Release-------------------- 7 |
8 |Command Lines
9 | Creating temporary file "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSP102.tmp" with contents 10 | [ 11 | /nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Fo"Release/" /Fd"Release/" /FD /c 12 | "C:\stb\klt\Klt\main.cpp" 13 | ] 14 | Creating command line "cl.exe @C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSP102.tmp" 15 | Creating temporary file "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSP103.tmp" with contents 16 | [ 17 | kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no /pdb:"Release/Klt.pdb" /machine:I386 /out:"Release/Klt.exe" 18 | .\Release\StdAfx.obj 19 | .\Release\Klt.obj 20 | .\Release\convolve.obj 21 | .\Release\error.obj 22 | .\Release\example1.obj 23 | .\Release\example2.obj 24 | .\Release\example3.obj 25 | .\Release\example4.obj 26 | .\Release\example5.obj 27 | .\Release\klt_util.obj 28 | .\Release\pnmio.obj 29 | .\Release\pyramid.obj 30 | .\Release\selectGoodFeatures.obj 31 | .\Release\storeFeatures.obj 32 | .\Release\trackFeatures.obj 33 | .\Release\writeFeatures.obj 34 | .\Release\main.obj 35 | ] 36 | Creating command line "link.exe @C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\RSP103.tmp" 37 |Output Window
38 | Compiling... 39 | main.cpp 40 | Linking... 41 | 42 | 43 | 44 |Results
45 | Klt.exe - 0 error(s), 0 warning(s) 46 |
3 | KLT: An Implementation of the Kanade-Lucas-Tomasi Feature Tracker
4 |5 | 6 | KLT is an implementation, in the C programming language, of a feature 7 | tracker that will hopefully be of interest to the computer vision community. 8 | The tracker is based on the early work of Lucas and 9 | 10 | Kanade 11 | [1] and was developed fully by 12 | 13 | Tomasi 14 | and Kanade [2], but the only 15 | published, readily accessible description is contained in the paper by 16 | 17 | Shi 18 | and Tomasi [3]. 19 | Recently, Tomasi proposed a slight modification which 20 | makes the computation symmetric with respect to the two images; the 21 | resulting equation is fully derived 22 | in the unpublished note by 23 | 24 | Birchfield 25 | [4].
26 | 27 | Briefly, good features are located by examining the minimum 28 | eigenvalue of each 2 by 2 gradient matrix, and features are 29 | tracked using a Newton-Raphson method of minimizing the difference 30 | between the two windows. 31 | Multiresolution tracking allows for even large displacements between 32 | images. 33 | Currently, the affine computation that evaluates the consistency 34 | of features between non-consecutive frames [3] 35 | is not implemented.
36 | 37 |
-
38 |
- Obtaining and Installing the Code 39 |
- Tutorial / User's Manual 40 |
- Reference Manual 41 |
- Log of Changes 42 | 43 |
46 |
References
47 |-
48 |
- [1] Bruce D. Lucas and Takeo Kanade.
49 | An Iterative Image Registration Technique with an
50 | Application to Stereo Vision.
51 | International Joint Conference on Artificial Intelligence,
52 | pages 674-679, 1981.
53 | 54 |
- [2] Carlo Tomasi and Takeo Kanade. 55 | Detection and Tracking of Point Features. 56 | Carnegie Mellon University Technical Report CMU-CS-91-132, 57 | April 1991.
58 | 59 |
- [3] Jianbo Shi and Carlo Tomasi. 60 | 61 | Good Features to Track. 62 | IEEE Conference on Computer Vision and Pattern Recognition, 63 | pages 593-600, 1994.
64 | 65 |
- [4] Stan Birchfield. 66 | 67 | Derivation of Kanade-Lucas-Tomasi Tracking Equation. 68 | Unpublished, May 1996. 69 |
- [2] Carlo Tomasi and Takeo Kanade. 55 | Detection and Tracking of Point Features. 56 | Carnegie Mellon University Technical Report CMU-CS-91-132, 57 | April 1991.
72 | 73 | Last updated by 74 | Stan Birchfield on 75 | March 11, A. D. 1998
76 | 77 | birchfield@cs.stanford.edu 78 | 79 | -------------------------------------------------------------------------------- /Tracke/klt/doc/installation.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 | 8 | 9 |
Obtaining and Installing the Code
10 | 11 | Please follow these steps to obtain and install KLT: 12 |-
13 |
- Choose the version you want to download (You'll probably want
14 | the most recent version):
15 |
-
16 |
- Version 1.1.3 (216 KB -- 3/11/1998) 17 |
- Previous versions 18 |
- Type
gunzip klt.tar.gz21 | - Type
tar xf klt.tar. A directory called "klt" will automatically be 22 | created and all the files will go there. 23 | - Move to the "klt" directory. Type
make.
24 | NOTE: On some systems it may be necessary to manually convert 25 | expf() to exp() and logf() to log(), and/or fsqrt() to sqrtf(). 26 | - That's it. Now try some examples, by typing
example1, etc. 27 | - Notice that, for your convenience, unofficial copies of the
28 | User and Reference Manuals can be found in the
docdirectory. 29 | - To keep the "klt.tar.gz" reasonably sized, only three images are included. 30 | If you want to play with the code even more, grab the 31 | extra images (407 KB). 32 |
36 | 37 | If you download KLT and find it useful for your work, I would like very much to 38 | hear from you. Please send me a short email (to the address below) describing 39 | the application in which you are involved. Such correspondence benefits me 40 | because I am curious to know how this software is being used. But it also 41 | benefits you because (1) the larger the number of people who use the program, 42 | the more I can justify spending time improving it, and (2) when a new version 43 | becomes available, I can notify you by email.
44 | 45 | An acknowledgment in any publication describing work that uses KLT would 46 | be greatly appreciated.
47 | 48 |
49 | Stan Birchfield
50 | 51 | birchfield@cs.stanford.edu 52 | 53 | -------------------------------------------------------------------------------- /Tracke/klt/doc/log.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 | 8 | 9 |
Log of Changes
10 | 11 |-
12 |
13 |
- Version 1.1.5 (7 Oct 1998)
14 |
-
15 |
- In trackFeatures.c, renamed _sumFloatWindow to _sumAbsFloatWindow
16 | (I thought this had been done before in version 1.1.1).
17 | Two bugs in the function were fixed:
18 |
-
19 |
- Now, the absolute value is taken of the individual pixels before 20 | summing them. 21 |
- The 'for' loop over 'width' now works correctly. 22 |
-- Thanks to Pedro Felzenszwalb 26 |
- In trackFeatures.c, renamed _sumFloatWindow to _sumAbsFloatWindow
16 | (I thought this had been done before in version 1.1.1).
17 | Two bugs in the function were fixed:
18 |
- Version 1.1.4 (18 Sep 1998)
29 |
-
30 |
- To make code work for Win32 systems, forced fopen() to
31 | use binary rather than text file. (In Unix, default is
32 | to open as binary, whereas in Win32, default is to open as
33 | text).
34 |
-- Thanks to Johan, Fredje Helderweirt, and LiYunhao 35 | - In convolve.c: Simplified formula for maximum of Gaussian 36 | and Gaussian derivative. 37 |
- In selectFeatures.c, changed the errors to warnings, when 38 | checking window size. 39 |
- Changed indentation for improved readability. 40 |
- Minor changes to eliminate compiler warnings:
41 |
-
42 |
- In selectGoodFeatures.c: Changed _quicksort to return void, 43 | and wrapped _comparePoints() with #ifdef KLT_USE_QSORT. 44 |
- In trackFeatures.c: Changed _computeIntensityDifference 45 | and _computeGradientSum to return void; removed 46 | search_range_max, nlevels, and ixx, which were not being used. 47 |
- In pnmio.c: Type conversion made explicit in malloc(). 48 |
- In selectFeatures.c: moved _quicksort() to top of file to 49 | obviate need for prototype. 50 |
- In writeFeatures.c: _readHeader() now returns a structureType, 51 | instead of an int (A structureType is an int, but some 52 | compilers are really picky). 53 |
- To make code work for Win32 systems, forced fopen() to
31 | use binary rather than text file. (In Unix, default is
32 | to open as binary, whereas in Win32, default is to open as
33 | text).
34 |
- Version 1.1.3 (3 Mar 1998)
57 |
-
58 |
- Fixed bug in
KLTTrackFeatures(). In the 59 | conditional just after the call to_trackFeature(), 60 |KLT_OOBis now properly handled. 61 | - Slightly improved bounds-checking by introducing an epsilon, 62 | and by giving back an extra pixel along the border that had 63 | been taken away unnecessarily. 64 |
- If tc->window_[width,height] is unacceptable, 65 | a warning is now generated and the value is corrected. 66 | Previously an error was generated. 67 |
- In Example 5, changed search range from 20 to 15. As a 68 | result, if the window size is changed to 5 the number of 69 | pyramid levels remains 2, which prevents the border from 70 | increasing dramatically. 71 |
- In Makefile, change example dependencies from lib to libklt.a.
72 | Unfortunately, changing the library source code (such as
73 |
trackFeatures.c) and then calling make 74 | example1 does not work properly, but at least 75 | changing example1.c and then calling make 76 | example1 does work. The latter case is probably more 77 | important, so we will have to live with the current tradeoff. 78 |
- Fixed bug in
- Version 1.1.2 (24 Feb 1998)
81 |
-
82 |
- Fixed major bug: Added an explicit check to ensure that feature
83 | does not drift out of bounds during tracking. This removes the
84 | problem of occasional crashes.
85 |
-- Thanks to Rainer Stiefelhagen 86 | - Speeded up sorting by replacing qsort() with Manolis Lourakis'
87 | _quicksort() function.
88 |
-- Thanks to Manolis Lourakis, Luis Rivera 89 | - Added KLTSetVerbosity() to klt.c (It should have already been there) 90 |
- Changed ppmWriteFile() to ppmWriteFileRGB() 91 |
- Fixed minor bug: assert() statement in line 314 of convolve.c
92 |
-- Thanks to Rainer Stiefelhagen 93 | - In Makefile, change example dependencies from libklt.a to lib 94 |
- Fixed major bug: Added an explicit check to ensure that feature
83 | does not drift out of bounds during tracking. This removes the
84 | problem of occasional crashes.
85 |
- Version 1.1.1 (18 Dec 1997)
97 |
-
98 |
- Fixed minor syntax bug: Changed 'if feof(fp)' to 'if (feof(fp))'
99 | in writeFeatures.c
100 |
-- Thanks to Matt Last 101 | - Fixed major bug: When tracking features, 'max_residue' was not 102 | being computed correctly. Therefore, feature windows that changed 103 | a lot in intensity were not being detected. Specifically, in 104 | trackFeatures.c, I changed _sumFloatWindow to _sumAbsFloatWindow. 105 |
- Fixed minor syntax bug: Changed 'if feof(fp)' to 'if (feof(fp))'
99 | in writeFeatures.c
100 |
- Version 1.1
108 |
-
109 |
- (16 Oct 1997)
110 |
-
111 |
- Fixed bug in pgmReadFile(). It was not skipping over the 112 | last return character. 113 |
- Example 1 was updated to include binary files. 114 |
- Changed KLTWriteFeature...() and KLTReadFeature...() 115 | to allow binary files, as well as text files. 116 |
- (15 Oct 1997)
118 |
-
119 |
- Posted 120 |
- Fixed obscure bug in KLTChangeTCPyramid() and 121 | improved readability of that function 122 |
- Fixed incorrect assert() statement in _interpolate() function 123 |
- (16 Oct 1997)
110 |
- Version 1.1 (beta)
127 |
-
128 |
- (21 Feb 1997)
129 |
-
130 |
- Renamed as Version 1.1 (beta) 131 |
- (15 Feb 1997)
133 |
-
134 |
- Posted as Version 1.2
135 | (This was a mistake; it should have been named Version 1.1 (beta).) 136 | - Fixed obscure bug that sometimes caused infinite loop
137 | (bug was in _enforceMinimumDistance() function of 138 | selectGoodFeatures.c) 139 | - Amended KLTPrintTrackingContext() to print all the new 140 | fields that were added in Version 1.1 141 |
- Posted as Version 1.2
- (21 Feb 1997)
129 |
- Version 1.1 (alpha)
145 |
-
146 |
- (21 Feb 1997)
147 |
- Renamed as Version 1.1 (alpha)
148 |
- (10 Feb 1997)
150 |
-
151 |
- Posted as Version 1.1
152 | (This was a mistake; it should have been named Version 1.1 (alpha).) 153 | - Features are lost when residue exceeded 154 |
- KLTSelectGoodFeatures() only accepts features whose minimum
155 | eigenvalue is at least
tc->min_eigenvalue156 | - User allowed to output internal images 157 |
- comments allowed in data files 158 |
- Default for
tc->smooth_sigma_factchanged from 0.5 to 0.1 159 | - Simplified _minEigenvalue() routine in selectGoodFeatures.c 160 |
- Posted as Version 1.1
- (21 Feb 1997)
147 |
- Version 1.0 (beta)
164 |
-
165 |
- (10 Feb 1997)
166 |
-
167 |
- Posted 168 |
- Print statements are prefaced by "(KLT) " 169 |
- (10 Feb 1997)
166 |
- Version 1.0 (alpha)
173 |
-
174 |
- (28 Jan 1997)
175 |
-
176 |
- Removed '#include "pyramid.h"' from "klt.h" 177 |
- Changed '_KLT_Pyramid' in "klt.h" to 'void *' 178 |
- Forced coercion of 'void *' to '_KLT_Pyramid' in other files 179 |
- (27 Jan 1997)
181 |
-
182 |
- Removed 'makedepend' from Makefile, along with dependencies 183 | below '# DO NOT DELETE' 184 |
- (24 Jan 1997)
186 |
-
187 |
- Posted 188 |
- (28 Jan 1997)
175 |
194 | 195 | -------------------------------------------------------------------------------- /Tracke/klt/doc/next_motif.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WangLCG/Image_Process/e6ada3ee5785b39c97155cde6a8abc1c57cefb05/Tracke/klt/doc/next_motif.gif -------------------------------------------------------------------------------- /Tracke/klt/doc/previous_motif.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WangLCG/Image_Process/e6ada3ee5785b39c97155cde6a8abc1c57cefb05/Tracke/klt/doc/previous_motif.gif -------------------------------------------------------------------------------- /Tracke/klt/doc/previous_versions.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 | 8 | 9 |
Previous Versions of KLT
10 | 11 |-
12 |
- Version 1.1.2 (216 KB -- 2/24/1998) 13 |
- Version 1.1.1 (215 KB -- 12/18/1997) 14 |
- Version 1.1 (212 KB -- 10/16/1997) 15 |
- Version 1.0 beta (228 KB -- 2/10/1997) 16 |
5 |
6 |
7 | 
8 |
9 |
10 | 
11 |
12 |
13 | 
14 |
15 |
16 | 17 | 18 |
KLTChangeTCPyramid()
19 | 20 |
21 |
22 | void KLTChangeTCPyramid(
23 | KLT_TrackingContext tc,
24 | int search_range);
25 |
26 |
27 |
28 | KLTChangeTCPyramid() is a convenience function that
29 | updates the 23 | KLT_TrackingContext tc,
24 | int search_range);
25 |
nPyramidLevels and subsampling
30 | fields of the tc structure, based on the value
31 | of search_range. The function
32 | is designed so that the tracker will be able find displacements up to
33 | search_range. For example, if search_range
34 | is 1 (pixel), then nPyramidLevels
35 | will be one and subsampling will be irrelevant, because there will be no
36 | need for multiresolution tracking. However, if
37 | search_range is 25 (pixels),
38 | then nPyramidLevels will be 2 and subsampling
39 | will be 8. The tracker is not
40 | guaranteed to find all displacements up to search_range
41 | pixels, so it is
42 | probably a good idea to overestimate the value. However, too much
43 | overestimation will make it more likely for ambiguity to confuse the tracker.44 | 45 |
46 | 47 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/count.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTCountRemainingFeatures()
19 | 20 |
21 |
22 | int KLTCountRemainingFeatures(
23 | KLT_FeatureList fl);
24 |
25 |
26 |
27 | KLTCountRemainingFeatures() returns the number of features in
28 | 23 | KLT_FeatureList fl);
24 |
fl whose value is nonnegative (i.e., the number of
29 | features that are not lost.30 | 31 |
32 | 33 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/create.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTCreate...() / KLTFree...()
19 | 20 |21 | 22 |
23 |
24 | KLT_TrackingContext KLTCreateTrackingContext(void);
25 | KLT_FeatureList KLTCreateFeatureList(
26 | int nFeatures);
27 | KLT_FeatureHistory KLTCreateFeatureHistory(
28 | int nFrames);
29 | KLT_FeatureTable KLTCreateFeatureTable(
30 | int nFrames,
31 | int nFeatures);
32 | void KLTFreeTrackingContext(
33 | KLT_TrackingContext tc);
34 | void KLTFreeFeatureList(
35 | KLT_FeatureList fl);
36 | void KLTFreeFeatureHistory(
37 | KLT_FeatureHistory fh);
38 | void KLTFreeFeatureTable(
39 | KLT_FeatureTable ft);
40 |
41 |
42 |
43 | These functions create and free various structures. Technically, it is
44 | good programming practice to free the structures after using them, although
45 | this is not done in any of the example code. 25 | KLT_FeatureList KLTCreateFeatureList(
26 | int nFeatures);
27 | KLT_FeatureHistory KLTCreateFeatureHistory(
28 | int nFrames);
29 | KLT_FeatureTable KLTCreateFeatureTable(
30 | int nFrames,
31 | int nFeatures);
32 | void KLTFreeTrackingContext(
33 | KLT_TrackingContext tc);
34 | void KLTFreeFeatureList(
35 | KLT_FeatureList fl);
36 | void KLTFreeFeatureHistory(
37 | KLT_FeatureHistory fh);
38 | void KLTFreeFeatureTable(
39 | KLT_FeatureTable ft);
40 |
46 |
47 | KLTCreateTrackingContext() is a little different from the other creation
48 | routines in that it uses default values defined
49 | in klt.c to set up the structure.
50 | These values can be changed if desired.
51 |
52 |
53 | 54 | 55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/ref/feature.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLT_Feature
19 | 20 |
21 |
22 | typedef struct {
23 | KLT_locType x;
24 | KLT_locType y;
25 | int val;
26 | } *KLT_Feature;
27 |
28 |
29 |
30 | A KLT_Feature contains an (x,y) location and a value.
31 | (23 | KLT_locType x;
24 | KLT_locType y;
25 | int val;
26 | } *KLT_Feature;
27 |
KLT_locType is equal
32 | to float.) The value is interpreted as follows:
33 | -
34 |
- A positive value means the feature has just been found by 35 | KLTSelectGoodFeatures() or KLTReplaceLostFeatures(). 36 | 37 |
-
KLT_TRACKED(0) means the feature has been successfully tracked. 38 | 39 | -
KLT_NOT_FOUND(-1) means that no feature could be found. For example, 40 | if the user attempts to find 150 features in an image, but only 125 can 41 | be found, then the 42 | remaining 25 will be assigned a value ofKLT_NOT_FOUND. 43 | 44 | -
KLT_SMALL_DET(-2) indicates that the feature has been lost due to 45 | the 2 by 2 gradient matrix having a small determinant. 46 | 47 | -
KLT_MAX_ITERATIONS(-3) means that the feature has been lost 48 | because the number of iterations exceeded the maximum allowable. 49 | 50 | -
KLT_OOB(-4) means that the feature has been lost 51 | because it was out of bounds (i.e., it was too close to the image border). 52 | 53 | -
KLT_LARGE_RESIDUE(-5) means that the feature has been lost 54 | because the residue between the two feature windows was too large. 55 |
58 | 59 | 60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/ref/fh.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLT_FeatureHistory
19 | 20 |
21 |
22 | typedef struct {
23 | int nFrames;
24 | KLT_Feature *feature;
25 | } *KLT_FeatureHistory;
26 |
27 |
28 |
29 | A KLT_FeatureHistory is an array of features. The 23 | int nFrames;
24 | KLT_Feature *feature;
25 | } *KLT_FeatureHistory;
26 |
nFrames field
30 | indicates the number of features allocated, or rather the number of
31 | frames in which the feature's data is given.
32 | It must not be changed manually.33 | 34 | NOTE: Although a feature list and a feature history look similar, the former 35 | is intended to refer to an array of features from a single image, while 36 | the latter refers to the same feature tracked through several images.
37 | 38 | The following code illustrates how to access the data 39 | in a feature history: 40 | 41 |
42 | KLT_FeatureHistory fh;
43 | int frame;
44 |
45 | for (frame = 0 ; frame < fh->nFrames ; frame++) {
46 | printf("(%5.1f,%5.1f) = %d\n",
47 | fh->feature[frame]->x,
48 | fh->feature[frame]->y,
49 | fh->feature[frame]->val);
50 | }
51 |
52 |
53 |
54 | 55 | 56 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/fl.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLT_FeatureList
19 | 20 |
21 |
22 | typedef struct {
23 | int nFeatures;
24 | KLT_Feature *feature;
25 | } *KLT_FeatureList;
26 |
27 |
28 |
29 | A KLT_FeatureList is an array of features. The
30 | 23 | int nFeatures;
24 | KLT_Feature *feature;
25 | } *KLT_FeatureList;
26 |
nFeatures field
31 | indicates the number of features allocated, but not necessarily
32 | the number of non-lost features. It must not be changed manually.33 | 34 | NOTE: Although a feature list and a feature history look similar, the former 35 | is intended to refer to an array of features from a single image, while 36 | the latter refers to the same feature tracked through several images.
37 | 38 | The following code illustrates how to access the data 39 | in a feature list: 40 | 41 |
42 | KLT_FeatureList fl;
43 | int feat;
44 |
45 | for (feat = 0 ; feat < fl->nFeatures ; feat++) {
46 | printf("(%5.1f,%5.1f) = %d\n",
47 | fl->feature[feat]->x,
48 | fl->feature[feat]->y,
49 | fl->feature[feat]->val);
50 | }
51 |
52 |
53 |
54 | 55 | 56 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/ft.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLT_FeatureTable
19 | 20 |
21 |
22 | typedef struct {
23 | int nFrames;
24 | int nFeatures;
25 | KLT_Feature **feature;
26 | } *KLT_FeatureTable;
27 |
28 |
29 |
30 | A KLT_FeatureTable is a two-dimensional array of features with
31 | 23 | int nFrames;
24 | int nFeatures;
25 | KLT_Feature **feature;
26 | } *KLT_FeatureTable;
27 |
nFrames columns and nFeatures rows. It is used
32 | to collect the features tracked through an image sequence.
33 |
34 | Data in a feature table is accessed by indexing the feature number before the
35 | frame number. For example, if ft is a feature table,
36 | the following code prints the data:
37 |
38 |
39 | KLT_FeatureTable ft;
40 | int feat, frame;
41 |
42 | for (feat = 0 ; feat < ft->nFeatures ; feat++)
43 | for (frame = 0 ; frame < ft->nFrames ; frame++) {
44 | printf("(%5.1f,%5.1f) = %d\n",
45 | ft->feature[feat][frame]->x,
46 | ft->feature[feat][frame]->y,
47 | ft->feature[feat][frame]->val);
48 | }
49 |
50 |
51 | 52 | 53 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/index.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
Reference Manual
19 | 20 |-
21 |
22 |
- Functions
23 |
24 |
-
25 |
26 |
- Main functions
27 |
28 |
-
29 |
- KLTSelectGoodFeatures 30 |
- KLTTrackFeatures 31 |
- KLTReplaceLostFeatures 32 |
- Auxiliary functions
35 |
36 |
-
37 |
- KLTCreate.../KLTFree... 38 |
- KLTWrite.../KLTRead... 39 |
- KLTStore.../KLTExtract... 40 |
- KLTCountRemainingFeatures 41 |
- KLTPrintTrackingContext 42 |
- KLTChangeTCPyramid 43 |
- KLTUpdateTCBorder 44 |
- KLTStopSequentialMode 45 |
- KLTSetVerbosity 46 | 47 |
- Main functions
27 |
28 |
- Structures
52 |
53 |
-
54 |
- KLT_TrackingContext 55 |
- KLT_Feature 56 |
- KLT_FeatureList 57 |
- KLT_FeatureHistory 58 |
- KLT_FeatureTable 59 |
64 | 65 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/print_tc.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTPrintTrackingContext()
19 | 20 |
21 |
22 | void KLTPrintTrackingContext(
23 | KLT_TrackingContext tc);
24 |
25 |
26 |
27 | KLTPrintTrackingContext() prints the fields of the tracking
28 | context to 23 | KLT_TrackingContext tc);
24 |
stderr.29 | 30 |
31 | 32 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/replace.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTReplaceLostFeatures()
19 | 20 |
21 |
22 | void KLTReplaceLostFeatures(
23 | KLT_TrackingContext tc,
24 | KLT_PixelType *img,
25 | int ncols,
26 | int nrows,
27 | KLT_FeatureList fl);
28 |
29 |
30 |
31 | KLTReplaceLostFeatures() takes an image pointed to by 23 | KLT_TrackingContext tc,
24 | KLT_PixelType *img,
25 | int ncols,
26 | int nrows,
27 | KLT_FeatureList fl);
28 |
img
32 | and a feature list
33 | fl. (NOTE: KLT_PixelType
34 | is, unless modified by the user, an unsigned char.)
35 | If tc->sequentialMode is
36 | TRUE, and if KLTTrackFeatures() has previously been called,
37 | then img is ignored
38 | and instead the image from
39 | tc->pyramid_last, tc->pyramid_last_gradx,
40 | and tc->pyramid_last_grady is used.
41 | Otherwise, the gradients are computed using a Gaussian of sigma =
42 | tc->grad_sigma, but not before the image is smoothed with a Gaussian of
43 | sigma = (tc->smooth_sigma_fact *
44 | max(tc->window_width, tc->window_height)) if
45 | tc->smoothBeforeSelecting is TRUE.
46 |
47 |
48 | Essentially, the same computation is performed as that of
49 | KLTSelectGoodFeatures(), except that only the lost features are replaced,
50 | rather than all the features. All new features are guaranteed to be at least
51 | tc->mindist pixels away from each other and from all
52 | the existing features.
53 |
54 | Exactly like KLTSelectGoodFeatures(), if tc->writeInternalImages
55 | is TRUE, then
56 | the smoothed image and the image derivatives are written to
57 | "kltimg_sgfrlf.pgm",
58 | "kltimg_sgfrlf_gx.pgm", and
59 | "kltimg_sgfrlf_gy.pgm", respectively.
60 | 61 |
62 | 63 | 64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/ref/select.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTSelectGoodFeatures()
19 | 20 |
21 |
22 | void KLTSelectGoodFeatures(
23 | KLT_TrackingContext tc,
24 | KLT_PixelType *img,
25 | int ncols,
26 | int nrows,
27 | KLT_FeatureList fl);
28 |
29 |
30 |
31 | KLTSelectGoodFeatures() takes an image pointed to by
32 | 23 | KLT_TrackingContext tc,
24 | KLT_PixelType *img,
25 | int ncols,
26 | int nrows,
27 | KLT_FeatureList fl);
28 |
img. (NOTE: KLT_PixelType
33 | is, unless modified by the user, an unsigned char.) If
34 | tc->smoothBeforeSelecting is set to TRUE, then the
35 | image is smoothed by
36 | convolving with a Gaussian of sigma = tc->smooth_sigma_fact *
37 | max(tc->window_width, tc->window_height); otherwise, the image
38 | is not smoothed. In either case,
39 | gradients are computed from the resulting image by convolving with the
40 | derivative of a Gaussian of sigma = tc->grad_sigma. These
41 | gradients (one in
42 | the x direction and the other in the y direction) are used
43 | to select the features.
44 |
45 | Pixels throughout the image are then measured as to their "goodness", which
46 | is a measure of their trackability.
47 | Generally each pixel within the image's interior is considered, where the
48 | interior is defined by tc->borderx and
49 | tc->bordery (i.e., setting these
50 | parameters to zero causes the interior to equal the whole image).
51 | The parameter tc->nSkippedPixels can be used to speed up the process in
52 | the following way: its default value is zero, in which case every pixel within
53 | the interior is considered; if it is set to one,
54 | then every other pixel within the interior is considered; setting
55 | it to two causes every third pixel to be considered; and similarly for
56 | higher values. Since neighboring
57 | pixels generally have similar goodness values, then skipping every
58 | other one will probably not noticeably decrease performance.
59 |
60 | The goodness of each pixel is measured as the minimum eigenvalue of
61 | the 2 by 2 gradient matrix computed from the tc->window_width by
62 | tc->window_height window around the pixel. After all the pixels have been
63 | considered, they are sorted in descending order according to goodness.
64 | Then, one by one the top fl->nFeatures
65 | features (or pixels) whose minimum eigenvalue is at least
66 | tc->min_eigenvalue are selected, ensuring that each new feature is at
67 | least tc->mindist pixels away from all the other features.
68 |
69 | If tc->writeInternalImages is TRUE, then
70 | the smoothed image and the image derivatives are written to
71 | "kltimg_sgfrlf.pgm",
72 | "kltimg_sgfrlf_gx.pgm", and
73 | "kltimg_sgfrlf_gy.pgm", respectively.
74 | This allows the user to more intelligently select the parameters
75 | for smoothing and differentiating.
76 |
77 |
78 |
79 | 80 | 81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/ref/stop.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTStopSequentialMode()
19 | 20 |
21 |
22 | void KLTStopSequentialMode(
23 | KLT_TrackingContext tc);
24 |
25 |
26 |
27 | KLTStopSequentialMode() must be called when it is desired to set
28 | 23 | KLT_TrackingContext tc);
24 |
tc->sequentialMode to FALSE. In addition to
29 | setting this value,
30 | the function frees the memory pointed to by the fields
31 | tc->pyramid_last, tc->pyramid_last_gradx,
32 | and tc->pyramid_last_grady.
33 | This memory is allocated when KLTTrackFeatures() is called with
34 | tc->sequentialMode to TRUE. Without calling
35 | the present function,
36 | KLTTrackFeatures() and KLTReplaceLostFeatures() will continue to use
37 | the old pyramids even though they are no longer valid.38 | 39 |
40 | 41 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/store.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTStore...() / KLTExtract...()
19 | 20 |21 | 22 |
23 |
24 | void KLTStoreFeatureList(
25 | KLT_FeatureList fl,
26 | KLT_FeatureTable ft,
27 | int frame);
28 | void KLTStoreFeatureHistory(
29 | KLT_FeatureHistory fh,
30 | KLT_FeatureTable ft,
31 | int feat);
32 |
33 |
34 |
35 | KLTStoreFeatureList() stores 25 | KLT_FeatureList fl,
26 | KLT_FeatureTable ft,
27 | int frame);
28 | void KLTStoreFeatureHistory(
29 | KLT_FeatureHistory fh,
30 | KLT_FeatureTable ft,
31 | int feat);
32 |
fl in the frame
36 | column of ft. The number frame must be between 0 and
37 | ft->nFrames - 1. The nFeatures field of both
38 | fl and ft
39 | must be the same.
40 |
41 | KLTStoreFeatureHistory() is similar, except that
42 | fh is stored in the feat
43 | row of ft.
44 | 45 |
46 | 47 |
48 |
49 | void KLTExtractFeatureList(
50 | KLT_FeatureList fl,
51 | KLT_FeatureTable ft,
52 | int frame);
53 | void KLTExtractFeatureHistory(
54 | KLT_FeatureHistory fh,
55 | KLT_FeatureTable ft,
56 | int feat);
57 |
58 |
59 |
60 | KLTExtractFeatureList() sets 50 | KLT_FeatureList fl,
51 | KLT_FeatureTable ft,
52 | int frame);
53 | void KLTExtractFeatureHistory(
54 | KLT_FeatureHistory fh,
55 | KLT_FeatureTable ft,
56 | int feat);
57 |
fl to the
61 | frame column
62 | of ft, while
63 | KLTExtractFeatureHistory() sets fh to the
64 | feat row
65 | of ft. The same restrictions apply as those of the
66 | KLTStore...() functions.67 | 68 |
69 | 70 | 71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/ref/track.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTTrackFeatures()
19 | 20 |
21 |
22 | void KLTTrackFeatures(
23 | KLT_TrackingContext tc,
24 | KLT_PixelType *img1,
25 | KLT_PixelType *img2,
26 | int ncols,
27 | int nrows,
28 | KLT_FeatureList fl);
29 |
30 |
31 |
32 | KLTTrackFeatures() takes two images pointed to by 23 | KLT_TrackingContext tc,
24 | KLT_PixelType *img1,
25 | KLT_PixelType *img2,
26 | int ncols,
27 | int nrows,
28 | KLT_FeatureList fl);
29 |
img1
33 | and img2. (NOTE: KLT_PixelType
34 | is, unless modified by the user, an unsigned char.) If
35 | tc->sequentialMode is
36 | TRUE, and KLTTrackFeatures() has been previously called, then
37 | img1 is ignored
38 | and the first image is taken instead from
39 | tc->pyramid_last, tc->pyramid_last_gradx, and
40 | tc->pyramid_last_grady.
41 | In either case, the
42 | resulting images are smoothed by
43 | convolving with a Gaussian of sigma =
44 | tc->smooth_sigma_fact *
45 | max(tc->window_width, tc->window_height). Then a
46 | multi-resolution image pyramid is created with tc->nPyramidLevels
47 | levels and
48 | tc->subsampling pixels subsampled between each level; smoothing
49 | before sampling is accomplished
50 | with sigma = tc->subsampling * tc->pyramid_sigma_fact.
51 | Gradients are computed at each level
52 | of the pyramid by convolving with the
53 | derivative of a Gaussian of sigma = tc->grad_sigma.
54 | 55 | 56 | In the feature list, each feature that is not lost (i.e., whose value is nonnegative) 57 | is tracked beginning with the coarsest resolution and ending with the 58 | finest resolution, with each resolution providing the starting point for the 59 | subsequent resolution. At each resolution, tracking is accomplished 60 | by a Newton-Raphson iterative minimization between the intensities of the two 61 | windows, one window in each image. There are five conditions that cause the 62 | iterations to stop (only in the first case is the tracker successful): 63 |
-
64 |
- the feature moves by no more than
tc->min_displacement65 | - the determinant of the 2-by-2 gradient matrix is less than
66 |
tc->min_determinant67 | - the number of iterations exceeds
tc->max_iterations68 | - the feature is out of bounds (i.e., it is within
tc->borderx69 | ortc->borderyof the border of the image) 70 | - the residue is too large (i.e., the average intensity difference
71 | between pixels in the two windows is greater than
72 |
tc->max_residue) 73 |
KLT_TRACKED,
75 | KLT_SMALL_DET, KLT_MAX_ITERATIONS,
76 | KLT_OOB, and KLT_LARGE_RESIDUE,
77 | respectively, which are in turn equal to 0,
78 | -2, -3, -4, and -5. (See the reference page of
79 | KLT_Feature to see what a value of
80 | -1 means.)
81 |
82 | If tc->writeInternalImages is TRUE, then
83 | the smoothed image and the image derivatives at each level of the
84 | pyramid are written to
85 | "kltimg_tf_[I][n].pgm",
86 | "kltimg_tf_[I][n]_gx.pgm", and
87 | "kltimg_tf_[I][n]_gy.pgm", where [I] = i,j
88 | denotes either the first image or the second image,
89 | and [n] = 0,1,2,... denotes the level of the pyramid.
90 |
91 | After all the features are tracked, if tc->sequentialMode
92 | is TRUE, then the second image and its derivatives are stored in
93 | tc->pyramid_last, tc->pyramid_last_gradx,
94 | and tc->pyramid_last_grady.
95 | 96 |
97 | 98 | 99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/ref/update_border.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTUpdateTCBorder()
19 | 20 |
21 |
22 | void KLTUpdateTCBorder(
23 | KLT_TrackingContext tc);
24 |
25 |
26 |
27 | KLTUpdateTCBorder() is a convenience function that automatically recomputes
28 | and updates the 23 | KLT_TrackingContext tc);
24 |
borderx and bordery fields of the
29 | tracking context, so that the user doesn't have to ever touch these fields.
30 | Unless the user desires direct control over the border,
31 | this function should be called whenever
32 | smooth_sigma_fact,
33 | pyramid_sigma_fact, window_width,
34 | window_height, or
35 | subsampling is changed.
36 |
37 | 38 | 39 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/verbosity.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTSetVerbosity()
19 | 20 |
21 |
22 | void KLTSetVerbosity(
23 | int verbosity);
24 |
25 |
26 |
27 | KLTSetVerbosity() sets the verbosity. Currently there are only
28 | two levels:
29 | 23 | int verbosity);
24 |
-
30 |
- 0: forbids all printing to the screen 31 | (except for error and warning messages). 32 |
- 1: provides feedback by printing sparse messages (the default). 33 |
36 | 37 | -------------------------------------------------------------------------------- /Tracke/klt/doc/ref/write.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
KLTWrite...() / KLTRead...()
19 | 20 |21 | 22 |
23 |
24 | void KLTWriteFeatureListToPPM(
25 | KLT_TrackingContext tc,
26 | KLT_FeatureList fl,
27 | KLT_PixelType *greyimg,
28 | int ncols,
29 | int nrows,
30 | char *filename);
31 |
32 |
33 |
34 | KLTWriteFeatureListToPPM() writes the image pointed to by
35 | 25 | KLT_TrackingContext tc,
26 | KLT_FeatureList fl,
27 | KLT_PixelType *greyimg,
28 | int ncols,
29 | int nrows,
30 | char *filename);
31 |
greyimg to the PPM file named
36 | filename. The features in
37 | fl are overlayed
38 | in red.39 | 40 |
41 | 42 |
43 |
44 | void KLTWriteFeatureList(
45 | KLT_FeatureList fl,
46 | char *filename,
47 | char *fmt);
48 | void KLTWriteFeatureHistory(
49 | KLT_FeatureHistory fh,
50 | char *filename,
51 | char *fmt);
52 | void KLTWriteFeatureTable(
53 | KLT_FeatureTable ft,
54 | char *filename,
55 | char *fmt);
56 |
57 |
58 |
59 | These functions write feature lists, feature histories, and feature
60 | tables to a file named filename (or to stderr if filename is NULL).
61 | The third parameter, 'fmt', is either:
62 | 45 | KLT_FeatureList fl,
46 | char *filename,
47 | char *fmt);
48 | void KLTWriteFeatureHistory(
49 | KLT_FeatureHistory fh,
50 | char *filename,
51 | char *fmt);
52 | void KLTWriteFeatureTable(
53 | KLT_FeatureTable ft,
54 | char *filename,
55 | char *fmt);
56 |
-
63 |
- NULL, indicating that a binary file is being created, or 64 |
- a format string, indicating that a text file is being created. 65 | The string, which must begin with '%' and end with 'd' or 'f' (e.g., 66 | "%3d" or "%5.1f"), governs the printing of the feature 67 | locations (the feature values are always printed with "%5d"). 68 | For example, a particular feature 69 | will be written as "(128.2,364.8)= 7634" if 'fmt' is "%5.1f", or as 70 | "(128,365)= 7634" if 'fmt' is "%3d". 71 |
76 | 77 |
78 | 79 |
80 |
81 | KLT_FeatureList KLTReadFeatureList(
82 | KLT_FeatureList fl,
83 | char *filename);
84 | KLT_FeatureHistory KLTReadFeatureHistory(
85 | KLT_FeatureHistory fh,
86 | char *filename);
87 | KLT_FeatureTable KLTReadFeatureTable(
88 | KLT_FeatureTable ft,
89 | char *filename);
90 |
91 |
92 |
93 | These functions read feature lists, feature histories, and feature
94 | tables from a file named 'filename' (The file may be either text or
95 | binary). If the first parameter is NULL, then a structure
96 | of the same size as that in the file is created, filled,
97 | and returned. Otherwise, the structure indicated by the first parameter
98 | is filled and returned. Note that
99 | the structure passed must be the same size as the structure in
100 | the file (i.e., the nFeatures field must be identical, as well as
101 | the nFrames field).
102 |
103 | 82 | KLT_FeatureList fl,
83 | char *filename);
84 | KLT_FeatureHistory KLTReadFeatureHistory(
85 | KLT_FeatureHistory fh,
86 | char *filename);
87 | KLT_FeatureTable KLTReadFeatureTable(
88 | KLT_FeatureTable ft,
89 | char *filename);
90 |
104 | 105 | 106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/shi-tomasi-good-features-cvpr1994.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WangLCG/Image_Process/e6ada3ee5785b39c97155cde6a8abc1c57cefb05/Tracke/klt/doc/shi-tomasi-good-features-cvpr1994.pdf
--------------------------------------------------------------------------------
/Tracke/klt/doc/toc_motif.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WangLCG/Image_Process/e6ada3ee5785b39c97155cde6a8abc1c57cefb05/Tracke/klt/doc/toc_motif.gif
--------------------------------------------------------------------------------
/Tracke/klt/doc/up_motif.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WangLCG/Image_Process/e6ada3ee5785b39c97155cde6a8abc1c57cefb05/Tracke/klt/doc/up_motif.gif
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/backup:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | for file in `ls *.html`
4 | do
5 | cp $file `echo $file | sed s/'\.html'/"\.html~$1"/`
6 | done
7 |
8 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/chpt1.html:
--------------------------------------------------------------------------------
1 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 | 18 | 19 |
Chapter 1: Introduction
20 | 21 | KLT has been designed to be easy to use. It should take no more than 22 | a few minutes to learn how to select and track features, and store 23 | and use the results. For those who wish to maximize performance, 24 | however, the program allows the flexibility of tweaking nearly every 25 | parameter that governs the computation, and it includes several 26 | methods to improve speed.27 | 28 | This manual guides the user, in a tutorial fashion, through the 29 | essentials of KLT. Chapter 2 contains all that is needed to select 30 | good features, track them from one image to the next, and write the 31 | results. When features are lost (due to a large residue, drifting out 32 | of bounds, etc.), they can be replaced 33 | by finding features in the new image, a process which is described in 34 | Chapter 3. Chapter 4 explains a technique for speeding up the computation 35 | in the case of tracking through an image sequence. Chapter 5 describes 36 | an extension allowing the features from multiple frames to be stored 37 | in one data structure, which can then be saved to a file. Chapter 38 | 6 shows how to recall this structure and extract features from it. 39 | Finally, Chapter 7 shows how to customize the tracker by 40 | manually setting the various parameters.
41 |
42 | Most of these chapters contain example code, which is also provided with
43 | the distribution of KLT. To compile your own code, simply put the line
44 | #include "klt.h" near the top of your file, and link with
45 | the KLT library as in this example: cc file.c -lklt -lm.
46 | 47 |
48 | 49 | -------------------------------------------------------------------------------- /Tracke/klt/doc/user/chpt2.html: -------------------------------------------------------------------------------- 1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
Chapter 2: Selecting and Tracking Features
19 | 20 | Below is a sample program that selects the 100 best features in 21 | an image and tracks them in the next image. Instead of 22 | requiring images to be in a particular format, KLT needs only a 23 | pointer to the raw image data (in row-major format), along with 24 | the dimensions of the image. (The data is assumed to be unsigned 25 | char's, but this can be changed by 26 | modifying the code and recompiling.) We will now describe 27 | the code, line-by-line.
28 |
29 | The header file "pnmio.h" is necessary only for the helper
30 | function pgmReadFile, while "klt.h" must always be included
31 | in programs using KLT.
32 | 33 | KLTCreateTrackingContext() creates a tracking context, which 34 | is a structure containing various parameters (such as window size, 35 | sigma for Gaussian smoothing, minimum distance between features, etc.) 36 | that govern the computation. The nature of the structure is not 37 | important for now.
38 | 39 | KLTCreateFeatureList() creates a feature list, which is 40 | a structure containing all the features in a given image. 41 | The parameter of the function is the number of features desired.
42 |
43 | The helper function pgmReadFile() has been provided
44 | for reading PGM images, but it can be removed if the raw image
45 | data is obtained in another manner. Passing NULL as the second
46 | parameter causes pgmReadFile() to allocate memory for the image.
47 |
48 | KLTSelectGoodFeatures() finds the N best features
49 | in an image and stores them in a feature list in descending
50 | order of goodness. N is the size of the feature list (in this
51 | case 100). (Note: It is also possible to
52 | select all the features above a certain level of goodness, rather than
53 | just the N best features, by
54 | simply changing the min_eigenvalue field of the tracking context,
55 | as described in Chapter 7.)
56 |
57 | The for loop demonstrates how to access data in the
58 | feature list.
59 | A feature list is simply an array of fl->nFeatures
60 | features, where each feature has
61 | three members: x location, y location, and value.
62 | The first two are
63 | floats, and the second is an int.
64 | The location is given in pixels
65 | with the origin in the upper-left corner. The value is a constant
66 | multiplied by the minimum eigenvalue of the window surrounding the
67 | feature -- the larger the value, the better the feature. (NOTE:
68 | Because fl->nFeatures indicates the amount of memory allocated,
69 | it must not be changed by hand.)
70 |
71 | KLTWriteFeatureListToPPM() writes the grey-level image to
72 | a PPM file and overlays the features in red. This image can then
73 | be viewed with a tool like xv.
74 |
75 | KLTWriteFeatureList() writes the features to a file (If
76 | the second parameter is NULL, then the features are written to
77 | stderr instead). You will probably want to keep the
78 | third parameter NULL, which causes the file to be binary. Binary
79 | files are better because they are smaller and cause no truncation error.
80 | However, if a text file is desired, then the third parameter must be a
81 | string beginning with '%' and ending with either 'd' or 'f', as in
82 | "%3d" or "%5.1f", which specifies the format of the feature locations
83 | to be either decimal or floating point.
84 | Once the feature list is written, the file can be viewed off-line (if it
85 | is text) or read back into
86 | a feature list using the command KLTReadFeatureList().
87 | 88 | KLTTrackFeatures() tracks the features from the first image 89 | to the second image and overwrites the feature list. If a feature 90 | is successfully tracked, then its value becomes zero; otherwise, it becomes 91 | negative. Note that this function does not resort the features, 92 | but rather keeps them in place so that correspondences between the 93 | images are maintained. Chapter 5 describes the KLT_FeatureTable structure, 94 | which is useful for storing the feature list before it is overwritten.
95 | 96 | And that's all there is to selecting and tracking features. The remaining 97 | chapters describe various extensions that may be helpful.
98 | 99 |
100 | 101 |
Example 1
102 | 103 |
104 | /**********************************************************************
105 | Finds the 100 best features in an image, and tracks these
106 | features to the next image. Saves the feature
107 | locations (before and after tracking) to text files and to PPM files,
108 | and prints the features to the screen.
109 | **********************************************************************/
110 |
111 | #include "pnmio.h"
112 | #include "klt.h"
113 |
114 | void main()
115 | {
116 | unsigned char *img1, *img2;
117 | KLT_TrackingContext tc;
118 | KLT_FeatureList fl;
119 | int nFeatures = 100;
120 | int ncols, nrows;
121 | int i;
122 |
123 | tc = KLTCreateTrackingContext();
124 | KLTPrintTrackingContext(tc);
125 | fl = KLTCreateFeatureList(nFeatures);
126 |
127 | img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
128 | img2 = pgmReadFile("img1.pgm", NULL, &ncols, &nrows);
129 |
130 | KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
131 |
132 | printf("\nIn first image:\n");
133 | for (i = 0 ; i < fl->nFeatures ; i++) {
134 | printf("Feature #%d: (%f,%f) with value of %d\n",
135 | i, fl->feature[i]->x, fl->feature[i]->y, fl->feature[i]->val);
136 | }
137 |
138 | KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat1.ppm");
139 | KLTWriteFeatureList(fl, "feat1.txt", "%3d");
140 |
141 | KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);
142 |
143 | printf("\nIn second image:\n");
144 | for (i = 0 ; i < fl->nFeatures ; i++) {
145 | printf("Feature #%d: (%f,%f) with value of %d\n",
146 | i, fl->feature[i]->x, fl->feature[i]->y, fl->feature[i]->val);
147 | }
148 |
149 | KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, "feat2.ppm");
150 | KLTWriteFeatureList(fl, "feat2.fl", NULL); /* binary file */
151 | KLTWriteFeatureList(fl, "feat2.txt", "%5.1f"); /* text file */
152 | }
153 |
154 |
155 | 156 | 157 | 158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 |
168 |
169 |
170 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/chpt3.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
Chapter 3: Replacing Lost Features
19 | 20 | KLTTrackFeatures() sometimes loses features (either because 21 | they actually became occluded or go out of bounds, or because the computation fails 22 | for one reason or another). If it is desired to always maintain 23 | a certain number of features, e.g. 100, then the lost features can 24 | be replaced by calling KLTReplaceLostFeatures(). This function 25 | calls the same underlying computation as 26 | KLTSelectGoodFeatures() to 27 | find all the features in the image and rank them accordingly. 28 | Then, if k features have been lost, the k best 29 | features are used to replace them.30 | 31 | Below is sample code using this function. 32 | 33 |
34 | 35 |
Example 2
36 | 37 |
38 | /**********************************************************************
39 | Finds the 100 best features in an image, tracks these
40 | features to the next image, and replaces the lost features with new
41 | features in the second image. Saves the feature
42 | locations (before and after tracking) to text files and to PPM files.
43 | **********************************************************************/
44 |
45 | #include "pnmio.h"
46 | #include "klt.h"
47 |
48 | void main()
49 | {
50 | unsigned char *img1, *img2;
51 | KLT_TrackingContext tc;
52 | KLT_FeatureList fl;
53 | int nFeatures = 100;
54 | int ncols, nrows;
55 |
56 | tc = KLTCreateTrackingContext();
57 | fl = KLTCreateFeatureList(nFeatures);
58 |
59 | img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
60 | img2 = pgmReadFile("img1.pgm", NULL, &ncols, &nrows);
61 |
62 | KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
63 |
64 | KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat1.ppm");
65 | KLTWriteFeatureList(fl, "feat1.txt", "%3d");
66 |
67 | KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);
68 | KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
69 |
70 | KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, "feat2.ppm");
71 | KLTWriteFeatureList(fl, "feat2.txt", "%3d");
72 | }
73 |
74 |
75 | 76 | 77 | 78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/chpt4.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
Chapter 4: Speeding Up the Process 19 | (of Tracking through an Image Sequence)
20 | 21 | In the two functions KLTTrackFeatures() and 22 | KLTReplaceLostFeatures(), the majority of the computing time is taken 23 | up by convolution, which 24 | is necessary both to smooth the image and to compute its gradients. 25 | Much of this convolution is unnecessary 26 | when an image sequence is being processed, 27 | because each image is processed more than once. For 28 | example, the features are tracked between frames 0 and 1, then between 29 | frames 1 and 2, then between frames 2 and 3, etc. During each iteration 30 | the second image, after being processed, can be stored and recalled 31 | the next time as the first image.
32 |
33 | The tracking context has a member called sequentialMode which,
34 | when set to TRUE,
35 | causes KLTTrackFeatures() to store the gradients of the second image,
36 | along with its smoothed version, into the tracking context.
37 | When KLTTrackFeatures() is called, it ignores its second parameter and
38 | replaces it with the previously stored image (except for the first
39 | time the function is called, in which case it must use both images);
40 | in the same way, KLTReplaceLostFeatures() also ignores its second parameter.
41 | The computation is identical, but the speed is improved.
42 |
43 | WARNING: If it is desired to turn the sequential mode off after
44 | it has been set
45 | and KLTTrackFeatures() has been called, do NOT simply set
46 | tc->sequentialMode to FALSE. You must call
47 | KLTStopSequentialMode(), which deletes the images.
48 | Otherwise, the next call to
49 | KLTTrackFeatures() will use the previously computed images,
50 | even though they are no longer valid.
51 | 52 | Sample code demonstrating the use of the sequential mode is 53 | delayed until the next chapter. 54 | 55 |
56 | 57 | 58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/chpt5.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
Chapter 5: Storing All the Features in a Single Structure/File
19 | 20 | Up to now, all the features have been contained in a feature list, 21 | which is overwritten when the features are tracked. Sometimes, however, 22 | it is desirable to keep the features from the last frame, or from the 23 | last few frames, or from all the frames. In these cases, it would be 24 | tedious to have to create a new feature list for each image. Instead, 25 | we create what is called a feature table. 26 | While a feature list is a one-dimensional array of features from a 27 | single image, a feature table is a two-dimensional array of features 28 | from many images. Each column of the table is a feature list.
29 |
30 | The sample code below shows the use of the sequential mode from the
31 | last chapter, as well as the use of a feature table.
32 | If the constant REPLACE is defined, then lost features
33 | are replaced; otherwise they are not. In the former case, new
34 | features can be identified in the table because they have positive
35 | (rather than zero) values. Now let us examine the unfamiliar lines of
36 | code.
37 | 38 | KLTCreateFeatureTable() creates a feature table, given the 39 | number of frames and the number 40 | of features to store. Although in this example the number of frames is 41 | the same as the total number of actual images, this does not have to be 42 | the case if all the features do not need to be stored.
43 |
44 | KLTStoreFeatureList() stores a feature list as the ith
45 | column of a feature table, where i is given by the third parameter
46 | (i must be between 0 and
47 | fl->nFeatures-1).
48 | The dimensions of the feature list and feature table must be compatible,
49 | meaning that they must both contain the same number of features.
50 | It is perfectly legal to overwrite a column that has already been used,
51 | although this is not done in the current example.
52 | 53 | KLTWriteFeatureTable() writes a feature table to a file, in 54 | a manner similar to that of KLTWriteFeatureList(), which was 55 | described in Chapter 2.
56 |
57 | NOTE: To facilitate easy distribution, only three images are included
58 | with the code, making this example less impressive than it otherwise
59 | would be; however, it does demonstrate the principle. If desired, more
60 | images can be obtained from the
61 | installation page (item 7),
62 | and the code below can be easily modified to track through all
63 | ten frames, by setting nFrames = 10.
64 | 65 |
66 | 67 |
Example 3
68 | 69 |
70 | /**********************************************************************
71 | Finds the 150 best features in an image and tracks them through the
72 | next two images. The sequential mode is set in order to speed
73 | processing. The features are stored in a feature table, which is then
74 | saved to a text file; each feature list is also written to a PPM file.
75 | **********************************************************************/
76 |
77 | #include <stdlib.h>
78 | #include <stdio.h>
79 | #include "pnmio.h"
80 | #include "klt.h"
81 |
82 | #define REPLACE
83 |
84 | void main()
85 | {
86 | unsigned char *img1, *img2;
87 | char fnamein[100], fnameout[100];
88 | KLT_TrackingContext tc;
89 | KLT_FeatureList fl;
90 | KLT_FeatureTable ft;
91 | int nFeatures = 150, nFrames = 3;
92 | int ncols, nrows;
93 | int i;
94 |
95 | tc = KLTCreateTrackingContext();
96 | fl = KLTCreateFeatureList(nFeatures);
97 | ft = KLTCreateFeatureTable(nFrames, nFeatures);
98 | tc->sequentialMode = TRUE;
99 |
100 | img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
101 | img2 = (unsigned char *) malloc(ncols*nrows*sizeof(unsigned char));
102 |
103 | KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
104 | KLTStoreFeatureList(fl, ft, 0);
105 | KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat0.ppm");
106 |
107 | for (i = 1 ; i < nFrames ; i++) {
108 | sprintf(fnamein, "img%d.pgm", i);
109 | pgmReadFile(fnamein, img2, &ncols, &nrows);
110 | KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);
111 | #ifdef REPLACE
112 | KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
113 | #endif
114 | KLTStoreFeatureList(fl, ft, i);
115 | sprintf(fnameout, "feat%d.ppm", i);
116 | KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, fnameout);
117 | }
118 | KLTWriteFeatureTable(ft, "features.txt", "%5.1f");
119 | }
120 |
121 |
122 | 123 | 124 | 125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/chpt6.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
Chapter 6: Reading from Files and Storing/Extracting Between Structures
19 | 20 | Now that we have tracked the features through the entire image 21 | sequence and have saved the result to a file, we can read the 22 | file and access the data without having to process the images again. 23 | The following example shows how this is done. Once again, we will examine the 24 | unfamiliar lines.
25 |
26 | KLTReadFeatureTable() reads the feature table from the
27 | file "features.txt". Since the first parameter is NULL, a feature
28 | table of the appropriate size is created and returned.
29 | 30 | KLTExtractFeatureList() copies the (i+1)th column of 31 | a feature table into a feature list, where i is given by the 32 | third parameter (in this case 1). In other words, i=0 refers to 33 | the first column.
34 |
35 | Although in this example the call KLTReadFeatureList() is
36 | unnecessary, it is given here to show its syntax, which is identical
37 | to that of KLTReadFeatureTable(). Because the first parameter is
38 | not NULL, the data is written into the given feature list.
39 | 40 | KLTStoreFeatureList() copies a feature list into a 41 | particular column of a feature table (in this case the third column, for 42 | which i=2). Now, the 43 | second and third columns of the table are identical.
44 | 45 | The second half of this example involves a feature history, 46 | which is a single row of a feature table in the same way 47 | that a feature list is a single column. That is, a feature 48 | history contains a particular features' locations in all the 49 | frames. The syntax for dealing with a feature history is identical to 50 | that of a feature list and should be clear from the example.
51 | 52 | NOTE: Unlike this example, in which every KLTWriteFeature...() call 53 | produces a text file, you will most likely want to produce binary 54 | files. See the explanation in Chapter 2.
55 | 56 |
57 | 58 |
Example 4
59 | 60 |
61 | /**********************************************************************
62 | Reads the feature table from "features.txt", copies the features from
63 | the second frame to those of the third frame, writes the features to
64 | "feat2.txt", and writes the new feature table to "ft2.txt". Then the
65 | eighth feature is overwritten with the fifth feature, and the resulting
66 | table is saved to "ft3.txt".
67 | **********************************************************************/
68 |
69 | #include <stdio.h>
70 | #include "klt.h"
71 |
72 | void main()
73 | {
74 | KLT_FeatureList fl;
75 | KLT_FeatureHistory fh;
76 | KLT_FeatureTable ft;
77 | int i;
78 |
79 | ft = KLTReadFeatureTable(NULL, "features.txt");
80 | fl = KLTCreateFeatureList(ft->nFeatures);
81 | KLTExtractFeatureList(fl, ft, 1);
82 | KLTWriteFeatureList(fl, "feat1.txt", "%3d");
83 | KLTReadFeatureList(fl, "feat1.txt");
84 | KLTStoreFeatureList(fl, ft, 2);
85 | KLTWriteFeatureTable(ft, "ft2.txt", "%3d");
86 |
87 | fh = KLTCreateFeatureHistory(ft->nFrames);
88 | KLTExtractFeatureHistory(fh, ft, 5);
89 |
90 | printf("The feature history of feature number 5:\n\n");
91 | for (i = 0 ; i < fh->nFrames ; i++)
92 | printf("%d: (%5.1f,%5.1f) = %d\n",
93 | i, fh->feature[i]->x, fh->feature[i]->y, fh->feature[i]->val);
94 |
95 | KLTStoreFeatureHistory(fh, ft, 8);
96 | KLTWriteFeatureTable(ft, "ft3.txt", "%6.1f");
97 | }
98 |
99 |
100 | 101 | 102 | 103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/chpt7.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | 17 | 18 |
Chapter 7: Customizing the Tracker
19 | 20 | Because computer vision is an experimental science, feature tracking 21 | cannot be accomplished without introducing parameters that must 22 | be empirically determined. These parameters are hopefully stable 23 | enough that they can be considered constant and therefore ignored; 24 | nevertheless, KLT provides access to nearly all the parameters for those 25 | users who wish to change them. 26 | As mentioned in Chapters 1 and 2, these parameters 27 | are contained in the tracking context, whose members we now list, along 28 | with a brief description of each:29 |
30 | int mindist; /* minimum distance between selected features */ 31 | int window_width; /* dimensions of feature window */ 32 | int window_height; " 33 | KLT_BOOL sequentialMode; /* whether to save most recent image */ 34 | KLT_BOOL smoothBeforeSelecting; /* whether to smooth image before selecting features */ 35 | KLT_BOOL writeInternalImages; /* whether to write internal images for later viewing */ 36 | int min_eigenvalue; /* smallest eigenvalue allowed for selecting */ 37 | float min_determinant; /* min determinant for declaring tracking failure */ 38 | float min_displacement; /* amount of pixel shift for stopping tracking iterations */ 39 | int max_iterations; /* max iterations before declaring tracking failure */ 40 | float max_residue; /* max residue before declaring tracking failure */ 41 | float grad_sigma; /* sigma of gaussian for computing gradient */ 42 | float smooth_sigma_fact; /* sigma factor of gaussian for smoothing image */ 43 | float pyramid_sigma_fact; /* sigma factor of gaussian for computing image pyramid */ 44 | int nSkippedPixels; /* used to speed up feature selection */ 45 | int borderx; /* border in which features will not be selected, and */ 46 | int bordery; /* tracked features will be declared out-of-bounds */ 47 | int nPyramidLevels; /* number of pyramid levels */ 48 | int subsampling; /* amount of subsampling between pyramid levels */ 49 |50 | (There are three additional members which point to the most recent image 51 | when the sequential mode is set, but these should never be accessed directly 52 | by the user. A complete description of the tracking context parameters can be 53 | found in the reference manual.)
54 |
55 | All of these members are initialized to default values when the tracking
56 | context is created. Afterwards, they can be read and changed at leisure.
57 | The only exception is that sequentialMode must be set to FALSE
58 | via the function KLTStopSequentialMode().
59 |
60 | A convenience function named KLTChangeTCPyramid() is
61 | provided for changing nPyramidLevels and
62 | subsampling. This function
63 | accepts the maximum search range as input, and computes and changes the
64 | two members accordingly. Therefore, the user can control these rather
65 | low-level parameters from a more high-level, intuitive objective. If
66 | desired, however, these members can be changed directly.
67 |
68 | Another convenience function, KLTUpdateTCBorder(), automatically
69 | recomputes the borderx and bordery fields,
70 | which are dependent upon smooth_sigma_fact,
71 | pyramid_sigma_fact, window_width,
72 | window_height,
73 | and subsampling.
74 | Unless the user desires
75 | direct control over the border,
76 | this function should be called whenever
77 | one of these parameters is changed.
78 | 79 | The example below illustrates how to change some of the parameters. 80 | It should be self-explanatory.
81 | 82 |
83 | 84 |
Example 5
85 | 86 |
87 | /**********************************************************************
88 | Demonstrates manually tweaking the tracking context parameters.
89 | **********************************************************************/
90 |
91 | #include "pnmio.h"
92 | #include "klt.h"
93 |
94 | void main()
95 | {
96 | unsigned char *img1, *img2;
97 | KLT_TrackingContext tc;
98 | KLT_FeatureList fl;
99 | int nFeatures = 100;
100 | int ncols, nrows;
101 |
102 | tc = KLTCreateTrackingContext();
103 | tc->mindist = 20;
104 | tc->window_width = 9;
105 | tc->window_height = 9;
106 | KLTChangeTCPyramid(tc, 15);
107 | KLTUpdateTCBorder(tc);
108 | fl = KLTCreateFeatureList(nFeatures);
109 |
110 | img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
111 | img2 = pgmReadFile("img2.pgm", NULL, &ncols, &nrows);
112 |
113 | KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
114 |
115 | KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat1b.ppm");
116 |
117 | KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);
118 |
119 | KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, "feat2b.ppm");
120 | }
121 |
122 |
123 | 124 | 125 | 126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
--------------------------------------------------------------------------------
/Tracke/klt/doc/user/index.html:
--------------------------------------------------------------------------------
1 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 | 18 | 19 | 20 |
Tutorial / User's Manual
21 | 22 |-
23 |
- Chapter 1: Introduction 24 |
- Chapter 2: Selecting and Tracking Features 25 |
- Chapter 3: Replacing Lost Features 26 |
- Chapter 4: Speeding Up the Process 27 | of Tracking through an Image Sequence 28 |
- Chapter 5: Storing All the Features in a 29 | Single Structure/File 30 |
- Chapter 6: Reading from Files and Storing/Extracting 31 | Between Structures 32 |
- Chapter 7: Customizing the Tracker 33 |
36 | -------------------------------------------------------------------------------- /Tracke/klt/doc/user/noUchar.html: -------------------------------------------------------------------------------- 1 |
4 | 5 |
Using Image Data Other than Unsigned Chars
6 | 7 | Typically, grey-level images are stored as unsigned chars, and 8 | KLT assumes the same. However, if this is not the case, then 9 | KLT can be modified by changing the line 10 | 11 |12 | typedef unsigned char KLT_PixelType; 13 |14 | 15 | in the file klt.h. This has not been tested, but it 16 | should work. The only function that will no longer work properly 17 | is KLTWriteFeatureListToPPM, because the image will now contain 18 | more than eight bytes per pixel. 19 | 20 |
21 | 22 | -------------------------------------------------------------------------------- /Tracke/klt/klt_track.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WangLCG/Image_Process/e6ada3ee5785b39c97155cde6a8abc1c57cefb05/Tracke/klt/klt_track.gif --------------------------------------------------------------------------------