├── CMakeLists.txt
├── LICENSE
├── README.md
├── TrackingLib
├── CMakeLists.txt
├── include
│ └── tracking.hpp
└── src
│ ├── KalmanFilter.cpp
│ ├── MeanShift.cpp
│ └── RANSAC.cpp
├── calibration_camera
├── .gitignore
├── checkerboard.jpg
├── imgs
│ ├── .gitignore
│ ├── calibration
│ └── imagelist_creator
├── out_camera_data.yml
├── sample
│ ├── .gitignore
│ ├── checkerboard
│ │ ├── .gitignore
│ │ ├── 1.jpg
│ │ ├── 10.jpg
│ │ ├── 11.jpg
│ │ ├── 12.jpg
│ │ ├── 13.jpg
│ │ ├── 14.jpg
│ │ ├── 15.jpg
│ │ ├── 16.jpg
│ │ ├── 17.jpg
│ │ ├── 18.jpg
│ │ ├── 19.jpg
│ │ ├── 2.jpg
│ │ ├── 20.jpg
│ │ ├── 3.jpg
│ │ ├── 4.jpg
│ │ ├── 5.jpg
│ │ ├── 6.jpg
│ │ ├── 7.jpg
│ │ ├── 8.jpg
│ │ └── 9.jpg
│ └── correcte
│ │ ├── .gitignore
│ │ └── corrected.png
└── src
│ ├── .gitignore
│ ├── calibration_camera.sh
│ ├── demo
│ ├── demo_source
│ ├── .gitignore
│ ├── CMakeLists.txt
│ └── demo.cpp
│ └── getCheker.py
├── icon
├── .gitignore
├── RANSAC.png
├── icon.jpg
├── icon_big.jpg
├── kalman.gif
└── meanshift.gif
├── test_camera.cpp
└── utils
├── camera.hpp
├── clock.hpp
└── future.hpp
/CMakeLists.txt:
--------------------------------------------------------------------------------
1 |
2 | cmake_minimum_required(VERSION 2.8)
3 | SET(CMAKE_BUILD_TYPE "Release")
4 | SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2 -DNDEBUG -pthread -fopenmp -pipe")
5 | add_definitions(-std=c++11)
6 | # Define project name
7 | project(tracking)
8 |
9 | find_package(OpenCV REQUIRED)
10 | #find_package(CUDA REQUIRED)
11 |
12 | include_directories(${OpenCV_INCLUDE_DIRS}
13 | ${PROJECT_SOURCE_DIR}/TrackingLib/include
14 | ${PROJECT_SOURCE_DIR}/utils)
15 |
16 | add_subdirectory(TrackingLib)
17 |
18 | # Declare the executable target built from your sources
19 | add_executable(tracker
20 | test_camera.cpp
21 | )
22 | # Link your application with OpenCV libraries
23 | target_link_libraries(tracker ${OpenCV_LIBS} TRACKING_SRCS)
24 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 | Preamble
9 |
10 | The GNU General Public License is a free, copyleft license for
11 | software and other kinds of works.
12 |
13 | The licenses for most software and other practical works are designed
14 | to take away your freedom to share and change the works. By contrast,
15 | the GNU General Public License is intended to guarantee your freedom to
16 | share and change all versions of a program--to make sure it remains free
17 | software for all its users. We, the Free Software Foundation, use the
18 | GNU General Public License for most of our software; it applies also to
19 | any other work released this way by its authors. You can apply it to
20 | your programs, too.
21 |
22 | When we speak of free software, we are referring to freedom, not
23 | price. Our General Public Licenses are designed to make sure that you
24 | have the freedom to distribute copies of free software (and charge for
25 | them if you wish), that you receive source code or can get it if you
26 | want it, that you can change the software or use pieces of it in new
27 | free programs, and that you know you can do these things.
28 |
29 | To protect your rights, we need to prevent others from denying you
30 | these rights or asking you to surrender the rights. Therefore, you have
31 | certain responsibilities if you distribute copies of the software, or if
32 | you modify it: responsibilities to respect the freedom of others.
33 |
34 | For example, if you distribute copies of such a program, whether
35 | gratis or for a fee, you must pass on to the recipients the same
36 | freedoms that you received. You must make sure that they, too, receive
37 | or can get the source code. And you must show them these terms so they
38 | know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps:
41 | (1) assert copyright on the software, and (2) offer you this License
42 | giving you legal permission to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains
45 | that there is no warranty for this free software. For both users' and
46 | authors' sake, the GPL requires that modified versions be marked as
47 | changed, so that their problems will not be attributed erroneously to
48 | authors of previous versions.
49 |
50 | Some devices are designed to deny users access to install or run
51 | modified versions of the software inside them, although the manufacturer
52 | can do so. This is fundamentally incompatible with the aim of
53 | protecting users' freedom to change the software. The systematic
54 | pattern of such abuse occurs in the area of products for individuals to
55 | use, which is precisely where it is most unacceptable. Therefore, we
56 | have designed this version of the GPL to prohibit the practice for those
57 | products. If such problems arise substantially in other domains, we
58 | stand ready to extend this provision to those domains in future versions
59 | of the GPL, as needed to protect the freedom of users.
60 |
61 | Finally, every program is threatened constantly by software patents.
62 | States should not allow patents to restrict development and use of
63 | software on general-purpose computers, but in those that do, we wish to
64 | avoid the special danger that patents applied to a free program could
65 | make it effectively proprietary. To prevent this, the GPL assures that
66 | patents cannot be used to render the program non-free.
67 |
68 | The precise terms and conditions for copying, distribution and
69 | modification follow.
70 |
71 | TERMS AND CONDITIONS
72 |
73 | 0. Definitions.
74 |
75 | "This License" refers to version 3 of the GNU General Public License.
76 |
77 | "Copyright" also means copyright-like laws that apply to other kinds of
78 | works, such as semiconductor masks.
79 |
80 | "The Program" refers to any copyrightable work licensed under this
81 | License. Each licensee is addressed as "you". "Licensees" and
82 | "recipients" may be individuals or organizations.
83 |
84 | To "modify" a work means to copy from or adapt all or part of the work
85 | in a fashion requiring copyright permission, other than the making of an
86 | exact copy. The resulting work is called a "modified version" of the
87 | earlier work or a work "based on" the earlier work.
88 |
89 | A "covered work" means either the unmodified Program or a work based
90 | on the Program.
91 |
92 | To "propagate" a work means to do anything with it that, without
93 | permission, would make you directly or secondarily liable for
94 | infringement under applicable copyright law, except executing it on a
95 | computer or modifying a private copy. Propagation includes copying,
96 | distribution (with or without modification), making available to the
97 | public, and in some countries other activities as well.
98 |
99 | To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies. Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 |
103 | An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License. If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 |
112 | 1. Source Code.
113 |
114 | The "source code" for a work means the preferred form of the work
115 | for making modifications to it. "Object code" means any non-source
116 | form of a work.
117 |
118 | A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 |
123 | The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form. A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 |
134 | The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities. However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work. For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 |
147 | The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 |
151 | The Corresponding Source for a work in source code form is that
152 | same work.
153 |
154 | 2. Basic Permissions.
155 |
156 | All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met. This License explicitly affirms your unlimited
159 | permission to run the unmodified Program. The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work. This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 |
164 | You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force. You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright. Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 |
175 | Conveying under any other circumstances is permitted solely under
176 | the conditions stated below. Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 |
179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 |
181 | No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 |
187 | When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 |
195 | 4. Conveying Verbatim Copies.
196 |
197 | You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 |
205 | You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 |
208 | 5. Conveying Modified Source Versions.
209 |
210 | You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 |
214 | a) The work must carry prominent notices stating that you modified
215 | it, and giving a relevant date.
216 |
217 | b) The work must carry prominent notices stating that it is
218 | released under this License and any conditions added under section
219 | 7. This requirement modifies the requirement in section 4 to
220 | "keep intact all notices".
221 |
222 | c) You must license the entire work, as a whole, under this
223 | License to anyone who comes into possession of a copy. This
224 | License will therefore apply, along with any applicable section 7
225 | additional terms, to the whole of the work, and all its parts,
226 | regardless of how they are packaged. This License gives no
227 | permission to license the work in any other way, but it does not
228 | invalidate such permission if you have separately received it.
229 |
230 | d) If the work has interactive user interfaces, each must display
231 | Appropriate Legal Notices; however, if the Program has interactive
232 | interfaces that do not display Appropriate Legal Notices, your
233 | work need not make them do so.
234 |
235 | A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit. Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 |
245 | 6. Conveying Non-Source Forms.
246 |
247 | You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 |
252 | a) Convey the object code in, or embodied in, a physical product
253 | (including a physical distribution medium), accompanied by the
254 | Corresponding Source fixed on a durable physical medium
255 | customarily used for software interchange.
256 |
257 | b) Convey the object code in, or embodied in, a physical product
258 | (including a physical distribution medium), accompanied by a
259 | written offer, valid for at least three years and valid for as
260 | long as you offer spare parts or customer support for that product
261 | model, to give anyone who possesses the object code either (1) a
262 | copy of the Corresponding Source for all the software in the
263 | product that is covered by this License, on a durable physical
264 | medium customarily used for software interchange, for a price no
265 | more than your reasonable cost of physically performing this
266 | conveying of source, or (2) access to copy the
267 | Corresponding Source from a network server at no charge.
268 |
269 | c) Convey individual copies of the object code with a copy of the
270 | written offer to provide the Corresponding Source. This
271 | alternative is allowed only occasionally and noncommercially, and
272 | only if you received the object code with such an offer, in accord
273 | with subsection 6b.
274 |
275 | d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 |
288 | e) Convey the object code using peer-to-peer transmission, provided
289 | you inform other peers where the object code and Corresponding
290 | Source of the work are being offered to the general public at no
291 | charge under subsection 6d.
292 |
293 | A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 |
297 | A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling. In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage. For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product. A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source. The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed. Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 |
337 | Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 |
343 | 7. Additional Terms.
344 |
345 | "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law. If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 |
354 | When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it. (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.) You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 |
361 | Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 |
365 | a) Disclaiming warranty or limiting liability differently from the
366 | terms of sections 15 and 16 of this License; or
367 |
368 | b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 |
372 | c) Prohibiting misrepresentation of the origin of that material, or
373 | requiring that modified versions of such material be marked in
374 | reasonable ways as different from the original version; or
375 |
376 | d) Limiting the use for publicity purposes of names of licensors or
377 | authors of the material; or
378 |
379 | e) Declining to grant rights under trademark law for use of some
380 | trade names, trademarks, or service marks; or
381 |
382 | f) Requiring indemnification of licensors and authors of that
383 | material by anyone who conveys the material (or modified versions of
384 | it) with contractual assumptions of liability to the recipient, for
385 | any liability that these contractual assumptions directly impose on
386 | those licensors and authors.
387 |
388 | All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10. If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term. If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 |
398 | If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 |
403 | Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 |
407 | 8. Termination.
408 |
409 | You may not propagate or modify a covered work except as expressly
410 | provided under this License. Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 |
415 | However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 |
422 | Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 |
429 | Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License. If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 |
435 | 9. Acceptance Not Required for Having Copies.
436 |
437 | You are not required to accept this License in order to receive or
438 | run a copy of the Program. Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance. However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work. These actions infringe copyright if you do
443 | not accept this License. Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 |
446 | 10. Automatic Licensing of Downstream Recipients.
447 |
448 | Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License. You are not responsible
451 | for enforcing compliance by third parties with this License.
452 |
453 | An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations. If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 |
463 | You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License. For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 |
471 | 11. Patents.
472 |
473 | A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based. The
475 | work thus licensed is called the contributor's "contributor version".
476 |
477 | A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version. For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 |
487 | Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 |
492 | In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement). To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 |
499 | If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients. "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 |
513 | If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 |
521 | A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License. You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 |
536 | Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 |
540 | 12. No Surrender of Others' Freedom.
541 |
542 | If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License. If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all. For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 |
552 | 13. Use with the GNU Affero General Public License.
553 |
554 | Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work. The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 |
563 | 14. Revised Versions of this License.
564 |
565 | The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time. Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 |
570 | Each version is given a distinguishing version number. If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation. If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 |
579 | If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 |
584 | Later license versions may give you additional or different
585 | permissions. However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 |
589 | 15. Disclaimer of Warranty.
590 |
591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 |
600 | 16. Limitation of Liability.
601 |
602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 |
612 | 17. Interpretation of Sections 15 and 16.
613 |
614 | If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 |
621 | END OF TERMS AND CONDITIONS
622 |
623 | How to Apply These Terms to Your New Programs
624 |
625 | If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 |
629 | To do so, attach the following notices to the program. It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 |
634 |
635 | Copyright (C)
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see .
649 |
650 | Also add information on how to contact you by electronic and paper mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
668 |
669 | The GNU General Public License does not permit incorporating your program
670 | into proprietary programs. If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library. If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License. But first, please read
674 | .
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 | ___
3 | # Object-Tracking
4 | [](https://github.com/DasudaRunner/Object-Tracking)
5 | [](https://github.com/dwyl/esta/issues)
6 | ## This object tracking library is optimized by using Eigen3 and openMP
7 | - ***Author**: Haibo Wang*
8 | - ***Email**: dasuda2015@163.com*
9 | - *This is an open source Object-Tracking library, The development language is C++, The classic and mainstream object tracking algorithms and related algorithms are reproduced(For example, RANSAC, least squares and so on). Of course, these are optimized by Eigen3 and openMP.*
10 | ## Hardware platform:
11 | - ***CPU**: intel i5 7500*
12 | - ***Memory**: 8G x 2 DDR4*
13 | - ***GPU**: GTX 1070 8GHz*
14 | ## Performance:
15 | - **RANSAC**:
16 | *Linear Fitting, 600 sample point, 500 iteration, Time consuming: **70-100us***
17 |
18 | `The least-square method` `RANSAC`
19 | # 
20 |
21 | - **Kalman Filter**:
22 | *Two dimensional coordinate tracking, System state variable is [x,y,dx,dy], prediction+update. Mean time consuming: **8us***
23 |
24 | # 
25 |
26 | - **MeanShift**:
27 | *Using kernel function,refactoring with Eigen3 and openMP, Test images's size is 640x480, using RGB color space. Mean time consuming:**100-2000us***
28 |
29 | # 
30 |
31 | ___
32 | ## 1. Camera calibration
33 | - Using opencv's own calibration tool to calculate the internal parameters of the camera, the chessboard picture has been given, fool-style operation, take a look.
34 | ### Location:
35 | DasudaRunner/Object-Tracking/calibration_camera
36 | ### Requirments:
37 | opencv:>=3.3.0 or >=3.0.0
38 | python:>=2.7
39 | python-opencv:
40 | ### Quick Start:
41 | #### Step 1. Connecte Camera, get images containing checkerboard.
42 | ./src$ python getChecker.py # press 's' to save image
43 | #### Step 2. I encapsulated these commands into a script file, and you can run the following command.
44 | ./src$ sudo sh calibration_camera.sh
45 | Now you can get out_camera_data.yml , this is a file that contains your camera's internal reference.
46 | #### Step 3. You can run ./demo, and get corrected images.
47 | ./src$ ./demo ../out_camera_data.yml
48 | 
49 | Actually, it call the function remap_image() in tracking.hpp.
50 | ```cpp
51 | #include
52 | #include
53 | #include
54 | #include
55 | #include
56 | #include "../../../tracking.hpp"
57 | using namespace std;
58 | int main(int argc, char* argv[])
59 | {
60 | cv::VideoCapture cap;
61 | cap.open(0);
62 | wong::calibration_camera camera(argv[1]);
63 | cv::Mat frame,out;
64 | cout<<"Press any key to exit the program !"<> frame;
67 | camera.remap_image(frame,out);
68 | cv::imshow("source",frame);
69 | cv::imshow("corrected",out);
70 | if(cv::waitKey(5)>=0)
71 | break;
72 | }
73 | }
74 | ```
75 |
--------------------------------------------------------------------------------
/TrackingLib/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | AUX_SOURCE_DIRECTORY(src DIR_TRACKING_SRCS)
2 | ADD_LIBRARY(TRACKING_SRCS ${DIR_TRACKING_SRCS})
--------------------------------------------------------------------------------
/TrackingLib/include/tracking.hpp:
--------------------------------------------------------------------------------
1 | //
2 | // Created by irim on 18-8-2.
3 | //
4 |
5 | #ifndef TRACKING_HPP
6 | #define TRACKING_HPP
7 |
8 | #include "opencv2/core.hpp"
9 | #include "opencv2/imgcodecs.hpp"
10 | #include "opencv2/highgui.hpp"
11 | #include
12 | #include
13 | #include
14 | #include
15 | #include
16 | #include
17 | #include
18 | #include
19 | #include
20 |
21 | namespace wong {
22 |
23 | using namespace std;
24 | using Eigen::MatrixXd;
25 | using namespace Eigen;
26 |
27 | class utils{
28 | private:
29 |
30 | public:
31 |
32 | static void prepareBackProject(cv::Mat& image,const cv::Rect selections,const int mode,cv::Mat& hist,const int bins,bool enable_normalize){
33 | assert(mode>=0 && mode<=1);
34 |
35 | cv::Mat color_model,single_channel;
36 | std::vector split_src;
37 | float range[2] = {0,float(bins)};
38 | const float * histRange = {range};
39 | cv::Mat roi_image = image(selections);
40 |
41 | if(mode==0){
42 | cv::cvtColor(roi_image,color_model,CV_BGR2HSV);
43 | cv::split(color_model,split_src);
44 | single_channel = split_src.at(0);
45 | }else {
46 | cv::cvtColor(roi_image, color_model, CV_BGR2YCrCb);
47 | cv::split(color_model, split_src);
48 | single_channel = split_src.at(1);
49 | }
50 |
51 | cv::calcHist(&single_channel,1,0,cv::Mat(),hist,1,&bins,&histRange,true,false);
52 |
53 | if(enable_normalize){
54 | cv::normalize(hist, hist, 0, 255, cv::NORM_MINMAX, -1, cv::Mat());
55 | }
56 | }
57 |
58 | static void getBackProject(const cv::Mat& src, const cv::Mat& hist,const int bins, cv::Mat& backProjectImage, const int mode){
59 | assert(mode>=0 && mode<=1);
60 |
61 | cv::Mat color_model,single_channel;
62 | std::vector split_src;
63 | float range[2] = {0,float(bins)};
64 | const float * histRange = {range};
65 |
66 | if(mode==0){
67 | cv::cvtColor(src,color_model,CV_BGR2HSV);
68 | cv::split(color_model,split_src);
69 | single_channel = split_src.at(0);
70 | }else {
71 | cv::cvtColor(src, color_model, CV_BGR2YCrCb);
72 | cv::split(color_model, split_src);
73 | single_channel = split_src.at(1);
74 | }
75 |
76 | cv::calcBackProject(&single_channel,1,0,hist,backProjectImage,&histRange,1,true);
77 | }
78 |
79 | template
80 | static void ArrayToMatrix(T1& array,T2& matrix,int h,int w){
81 | matrix = Map(array,h,w);
82 | }
83 |
84 | //按列展开
85 | template
86 | static void MatrixToArray(T1& matrix,T2& array){
87 | array = matrix.data();
88 | }
89 |
90 | };
91 |
92 | class MeanShift{
93 |
94 | private:
95 | //画出矩形框
96 | void drawRect(cv::Mat& src,cv::Rect rec);
97 | //带有安全检查的方框移动
98 | cv::Point2d safeUpdate(cv::Point2d ori,cv::Point2d update,cv::Rect track_window,const int img_width,const int img_height);
99 |
100 | //计算直方图 返回为hist
101 | // int histBin = 16; //直方图中bin的个数
102 | // int allBins = histBin*histBin*histBin;
103 | // float range[2] = {0,float(histBin)};
104 | // const float * histRange = {range};
105 | //
106 | // void getHist(const cv::Mat& src,cv::Mat& hist){
107 | // cv::calcHist(&src,1,0,cv::Mat(),hist,1,&histBin,&histRange,true,false);
108 | // }
109 | //
110 | // //计算直方图的相关性
111 | // double histCorrelation(cv::Mat& src,cv::Mat& pattern){
112 | // cv::Mat srcHSV,patternHSV;
113 | // cv::cvtColor(src,srcHSV,CV_BGR2HSV);
114 | // cv::cvtColor(pattern,patternHSV,CV_BGR2HSV);
115 | //
116 | // std::vector srcChannels,patternChannels;
117 | // cv::split(srcHSV,srcChannels);
118 | // cv::split(patternHSV,patternChannels);
119 | //
120 | // cv::Mat srcHist,patternHist;
121 | // getHist(srcChannels[0],srcHist);
122 | // getHist(patternChannels[0],patternHist);
123 | //
124 | // cv::normalize(srcHist,srcHist,0,1,cv::NORM_MINMAX);
125 | // cv::normalize(patternHist,patternHist,0,1,cv::NORM_MINMAX);
126 | //
127 | // /*
128 | // * CV_COMP_CORREL:相关性性 1相关性最大
129 | // * CV_COMP_CHISQR:卡方法 0相关性最大
130 | // * CV_COMP_INTERSECT:交集法 值越大相关性越大
131 | // * CV_COMP_BHATTACHARYYA: BHATTACHARYYA距离法 0相关性最大
132 | // */
133 | // return cv::compareHist(srcHist,patternHist,CV_COMP_CORREL);
134 | // }
135 |
136 | const int bin = 16;
137 | const int allBins = bin*bin*bin;
138 |
139 | //------------------tracking_withoutKernel--------------------
140 | int t_x,t_y,t_w,t_h; //追踪框的参数
141 | int band_width; //带宽
142 |
143 | double *m_wei = (double* )malloc(sizeof(double)*50*50); //权值矩阵
144 | double C_ = 0.0; //归一化系数
145 | double *hist1 = (double* )malloc(sizeof(double)*bin*bin*bin); //模板的直方图
146 | double *hist2 = (double* )malloc(sizeof(double)*bin*bin*bin); //候选区的直方图
147 | double *w = (double* )malloc(sizeof(double)*bin*bin*bin);//权值
148 | //------------------tracking_withoutKernel--------------------
149 |
150 | //计算巴氏相关系数
151 | double Bhattacharyya(cv::Mat& Pu,cv::Mat& qu);
152 |
153 | //核函数相关的参数
154 | double *K;
155 | double *Gx;
156 | double *Gy;
157 |
158 | void EpanechnikovKernelF(const int H,const int W);
159 |
160 | //获得概率密度矩阵 计算模板和匹配区域的特征
161 | void getPu(cv::Mat& roi_image,cv::Mat& Mat_Pu);
162 |
163 | //权值矩阵
164 | void getWi(cv::Mat& roi_image,cv::Mat& pu, cv::Mat& qu ,cv::Mat& Mat_Wi);
165 |
166 | //更新Yi,追踪框的新位置
167 | cv::Point2d updateYi(const cv::Mat& roi_image,cv::Mat& Mat_Wi);
168 |
169 | cv::Rect trackWindow;//保存追踪框
170 | cv::Point2d point_Y0,point_Y1;//保存追踪框的原始点和候选框的点
171 | cv::Mat qu_hist,pu_hist; //追踪框和候选框的特征
172 |
173 | cv::Mat Mat_wi; //权值矩阵
174 |
175 |
176 | public:
177 |
178 | void initTracker_withoutKernel(const cv::Mat & src,cv::Rect tracking_window);
179 |
180 | //跟踪函数
181 | void tracking_withoutKernel(cv::Mat& frame);
182 |
183 | void initTracker_withKernel(const cv::Mat& src,cv::Rect rec);
184 |
185 | const double update_step = 1.4; //更新的步长
186 | double lastCorrelation=0.0;
187 |
188 | bool tracking_withKernel(cv::Mat& src);
189 | };
190 |
191 |
192 |
193 | class KF{
194 |
195 | private:
196 | const int dim_status = 4; //系统状态的维数
197 |
198 | const int dim_measure = 2; //系统观测的维数
199 |
200 | // const int dim_control = 1; //系统控制输入的维数
201 | const double time_step=0.1; //时间周期
202 |
203 | MatrixXd Xhat = MatrixXd::Constant(dim_status,1,0); //k-1时刻系统状态的最优估计 ok n*1
204 | MatrixXd Phat = MatrixXd::Constant(dim_status,dim_status,0); //k-1时刻最优估计的协方差 ok n*n
205 |
206 | MatrixXd Xhat_minus = MatrixXd::Constant(dim_status,1,0); //k-1时刻的预测值 ok n*1
207 | MatrixXd Phat_minus = MatrixXd::Constant(dim_status,dim_status,0); //k-1时刻最优估计的协方差 ok n*n
208 |
209 | MatrixXd A = MatrixXd::Constant(dim_status,dim_status,0); //上一时刻的最优估计 ok n*n
210 | // MatrixXd B = MatrixXd::Constant(dim_control,dim_control,0); //控制->状态空间转换矩阵
211 | MatrixXd H = MatrixXd::Constant(dim_measure,dim_status,0); //测量矩阵 n*m
212 |
213 | MatrixXd Q = MatrixXd::Identity(dim_status,dim_status); //系统预测噪声 ok n*n
214 | MatrixXd R = MatrixXd::Identity(dim_measure,dim_measure); //系统测量噪声 ok m*m
215 |
216 | MatrixXd K = MatrixXd::Constant(dim_status,dim_measure,0);; //卡尔曼增益 ok
217 |
218 | MatrixXd I = MatrixXd::Identity(dim_status,dim_status); //对角矩阵 ok
219 |
220 | public:
221 | KF();
222 | cv::Point predict(double* measurement,int len);
223 | };
224 |
225 | class RANSAC{
226 |
227 | private:
228 |
229 | inline double getDistanceP2L(cv::Point2d a,double* K){
230 | return abs(K[0]*a.x+K[1]*a.y+K[2])/(sqrt(K[0]*K[0]+K[1]*K[1]));
231 | }
232 |
233 | void getDistanceP2L_Matrix(MatrixXd& points,double* K,MatrixXd& dis);
234 |
235 | template
236 | inline double getDistanceP2P(const T ax, const T ay,const T bx,const T by){
237 | return sqrt(pow(ax-bx,2)+pow(ay-by,2));
238 | }
239 |
240 | public:
241 | RANSAC(){
242 | srand((unsigned)time(NULL));
243 | }
244 | const double inlier_error=2.99;//判断时候是否为内点的阈值
245 | //最小二乘法拟合直线
246 | void LeastSquares(std::vector points,double* result);
247 | //两点确定一条直线
248 | void getLine(double ax,double ay,double bx, double by,double* K);
249 |
250 | //随机获得两个点
251 | bool getSamples(const int max,int* sam_id);
252 |
253 | //判断两个点的距离
254 | void fit(std::vector points,double K_coefficient[2]);
255 |
256 | void getTestSamples(std::vector& points,const int max_iter);
257 |
258 | };
259 |
260 | }
261 |
262 | #endif //TRACKING_HPP
263 |
--------------------------------------------------------------------------------
/TrackingLib/src/KalmanFilter.cpp:
--------------------------------------------------------------------------------
1 | //
2 | // Created by dasuda on 18-10-26.
3 | //
4 |
5 | #include "../include/tracking.hpp"
6 |
7 | wong::KF::KF(){
8 |
9 | //转换矩阵
10 | A << 1,0,1,0,
11 | 0,1,0,1,
12 | 0,0,1,0,
13 | 0,0,0,1;
14 | H << 1,0,0,0,
15 | 0,1,0,0;
16 | //先确定R再去调节Q
17 | Q *= 1e-2;
18 | R *= 0.1;
19 |
20 | }
21 |
22 | cv::Point wong::KF::predict(double* measurement,int len){
23 |
24 | MatrixXd measure;
25 | double* prediction;
26 |
27 | utils::ArrayToMatrix(measurement,measure,len,1); //将测量值转换为matrix
28 |
29 | Xhat_minus = A * Xhat; //状态预测 公式1
30 | Phat_minus = A * Phat * A.transpose() + Q; //系统预测的协方差矩阵 公式2
31 |
32 | MatrixXd temp(dim_measure,dim_measure);
33 | temp = H * Phat_minus * H.transpose() + R;
34 | K = Phat_minus * H.transpose() * temp.inverse(); //求出卡尔曼增益 公式3
35 |
36 | Xhat = Xhat_minus + K * (measure - H * Xhat_minus); //更新系统状态 公式4
37 |
38 | Phat = (I - K * H) * Phat_minus; //更新估计值的协方差矩阵 公式5
39 |
40 | utils::MatrixToArray(Xhat_minus,prediction);
41 |
42 | return cv::Point(prediction[0],prediction[1]);
43 | }
--------------------------------------------------------------------------------
/TrackingLib/src/MeanShift.cpp:
--------------------------------------------------------------------------------
1 | //
2 | // Created by dasuda on 18-10-26.
3 | //
4 |
5 | #include "../include/tracking.hpp"
6 |
7 | void wong::MeanShift::drawRect(cv::Mat& src,cv::Rect rec)
8 | {
9 | cv::rectangle(src,rec.tl(),rec.br(),cv::Scalar(0,255,0),2);
10 | }
11 |
12 | cv::Point2d wong::MeanShift::safeUpdate(cv::Point2d ori,
13 | cv::Point2d update,
14 | cv::Rect track_window,
15 | const int img_width,
16 | const int img_height)
17 | {
18 | ori.x += update.x* update_step;
19 | ori.y += update.y* update_step;
20 |
21 | if(round(ori.x) +track_window.width >= img_width){
22 | ori.x = img_width - track_window.width-1;
23 | }else if(ori.x < 0){
24 | ori.x = 0;
25 | }
26 |
27 | if(round(ori.y)+track_window.height>=img_height){
28 | ori.y = img_height - track_window.height-1;
29 | }else if(ori.y < 0){
30 | ori.y=0;
31 | }
32 |
33 | return ori;
34 | }
35 |
36 | double wong::MeanShift::Bhattacharyya(cv::Mat& Pu,cv::Mat& qu)
37 | {
38 | assert(Pu.rows==1 && qu.rows==1); //保证是行向量
39 | assert(Pu.rows==qu.rows); //保证尺寸是一样的
40 |
41 | double Bhatta=0;
42 | const double* data_Pu = Pu.ptr(0);
43 | const double* data_q = qu.ptr(0);
44 | for (int i = 0; i < Pu.cols; ++i) {
45 | Bhatta += sqrt(data_Pu[i]*data_q[i]);
46 | }
47 |
48 | return Bhatta;
49 | }
50 |
51 | void wong::MeanShift::EpanechnikovKernelF(const int H,const int W){
52 |
53 | int radWidth = (int)sqrt(pow((double)W,2)+pow((double)H,2));
54 | int radHeight = radWidth;
55 | double pi = 3.141596;
56 | int d = 2;//当前维度
57 | double Cd = pi; //d维空间下单位球体的体积
58 | double kx=0,ky=0; //kernel funciton 的梯度
59 |
60 | K = new double[W*H];
61 | Gx = new double[W*H];
62 | Gy = new double[W*H];
63 |
64 | for (int i = 0; i < W*H; ++i) { //初始化
65 | K[i]=0;
66 | Gx[i]=0;
67 | Gy[i]=0;
68 | }
69 |
70 | //计算函数值 保存在K中,但它只与位置有关
71 | for (int i = 0; i < H; ++i) {
72 | for (int j = 0; j < W; ++j) {
73 | kx = pow(double(i-0.5*H)/(double)radWidth,2);
74 | ky = pow(double(j-0.5*W)/(double)radHeight,2);
75 | if((kx+ky)<1){
76 | K[i*W+j] = (0.5*(d+2)*(1-(kx+ky)))/Cd;
77 | }else{
78 | K[i*W+j] = 0;
79 | }
80 | }
81 | }
82 |
83 | //接下来计算密度
84 | for (int x = 0; x < W; ++x) {
85 | for (int y = 0; y < H; ++y) {
86 | //x方向的密度
87 | if(x==0)
88 | Gx[y*W+x] = -(K[y*W+x+1]-K[y*W+x]);
89 | else if(x==(W-1))
90 | Gx[y*W+x] = -(K[y*W+x]-K[y*W+x-1]);
91 | else
92 | Gx[y*W+x] = -(K[y*W+x+1]-K[y*W+x-1])/2.0;
93 | //y方向的密度
94 | if(y==0)
95 | Gy[y*W+x] = -(K[(y+1)*W+x]-K[y*W+x]);
96 | else if(y==(H-1))
97 | Gy[y*W+x] = -(K[y*W+x]-K[(y-1)*W+x]);
98 | else
99 | Gy[y*W+x] = -(K[(y+1)*W+x]-K[(y-1)*W+x])/2.0;
100 | }
101 | }
102 |
103 | }
104 |
105 | //获得概率密度矩阵 计算模板和匹配区域的特征
106 | void wong::MeanShift::getPu(cv::Mat& roi_image,cv::Mat& Mat_Pu){
107 | double *pu = new double[allBins];
108 |
109 | for (int i = 0; i < allBins; ++i) {
110 | pu[i]=0.0;
111 | }
112 |
113 | //求出了qu特征矩阵
114 | int bxi=0;
115 | double sum_pu = 0.0;
116 | for (int i = 0; i < roi_image.rows; ++i) {
117 | const uchar* data = roi_image.ptr(i);
118 | for (int j = 0; j < roi_image.cols; j+=3) {
119 | bxi = ((int)data[j+2]>>5)*bin*bin +
120 | ((int)data[j+1]>>5)*bin +
121 | ((int)data[j]>>5);
122 | pu[bxi] += K[i*roi_image.cols+j];//有可能出错 它类似一个直方图
123 | sum_pu += K[i*roi_image.cols+j];
124 | }
125 | }
126 |
127 | //归一化的pu
128 | double sumQu=0;
129 | for (int i = 0; i < allBins; ++i) {
130 | pu[i] /= sum_pu;
131 | sumQu += pu[i]; //这个sumQu不是1吗?
132 | }
133 |
134 | cv::Mat pu_mat(1,allBins,CV_64FC1,pu);
135 | Mat_Pu.release();
136 | pu_mat.copyTo(Mat_Pu);
137 | }
138 |
139 | //权值矩阵
140 | void wong::MeanShift::getWi(cv::Mat& roi_image,cv::Mat& pu, cv::Mat& qu ,cv::Mat& Mat_Wi){
141 |
142 | double* Wi = new double[roi_image.rows*roi_image.cols];
143 |
144 | for (int i = 0; i < roi_image.rows*roi_image.cols; ++i) {
145 | Wi[i]=0.0;
146 | }
147 |
148 | //计算得到权值矩阵
149 | int bxi = 0;
150 | const double* data_pu = pu.ptr(0);
151 | const double* data_qu = qu.ptr(0);
152 | // #pragma omp parallel for
153 | for (int i = 0; i < roi_image.rows; ++i) {
154 | const uchar* data_image = roi_image.ptr(i);
155 | for (int j = 0; j < roi_image.cols; j+=3) {
156 | bxi = ((int)data_image[j+2]>>5)*bin*bin+
157 | ((int)data_image[j+1]>>5)*bin+
158 | ((int)data_image[j]>>5);
159 | if(data_pu[bxi] != 0){
160 | Wi[i*roi_image.cols+j] = sqrt(data_qu[bxi]/data_pu[bxi]);
161 | }else{
162 | Wi[i*roi_image.cols+j] = 0;
163 | }
164 | }
165 | }
166 |
167 | cv::Mat W_Mat(roi_image.rows,roi_image.cols,CV_64FC1,Wi);
168 | Mat_Wi.release();
169 | W_Mat.copyTo(Mat_Wi);
170 | }
171 |
172 | //更新Yi,追踪框的新位置
173 | cv::Point2d wong::MeanShift::updateYi(const cv::Mat& roi_image,cv::Mat& Mat_Wi){
174 |
175 | double wi,g_x=0,g_y=0,g_xy=0,sum_wig=0;
176 | double yi_x=0,yi_y=0;
177 | double yi_dx=0,yi_dy=0;
178 | for (int i = 0; i < roi_image.rows; ++i) {
179 | for (int j = 0; j < roi_image.cols; ++j) {
180 | wi = Mat_Wi.at(i,j);
181 | g_x = Gx[i*roi_image.cols+j];
182 | g_y = Gy[i*roi_image.cols+j];
183 | g_xy = sqrt(g_x*g_x+g_y*g_y);
184 |
185 | yi_dx += (i+1)*wi*g_x;
186 | yi_dy += (j+1)*wi*g_y;
187 |
188 | sum_wig += wi*g_xy;
189 |
190 | // cout<<"-----------inner variable-------------"<(i);
255 | for (int j = 0; j < t_w; j+=3) {
256 |
257 | q_b = data[j]/bin;
258 | q_g = data[j+1]/bin;
259 | q_r = data[j+2]/bin;
260 |
261 | q_temp = q_r*256+q_g*16+q_b;
262 | hist1[q_temp] += m_wei[i*t_w+j];
263 | }
264 | }
265 | cout<<"q_g: "<0.8) && (num < 20)){
283 | //控制迭代次数
284 | ++num;
285 |
286 | memset(q_temp,0,sizeof(int)*t_w*t_h);
287 |
288 | for (int i = 0; i < 4096; ++i) {
289 | hist2[i]=0.0;
290 | w[i]=0.0;
291 | }
292 |
293 | //获得当前追踪框的roi图像
294 | roi_frame = temp_frame(cv::Rect(t_x,t_y,t_w,t_h));
295 |
296 | //画出跟踪框
297 | drawRect(frame,cv::Rect(t_x,t_y,t_w,t_h));
298 |
299 |
300 | for (int i = 0; i < t_h; ++i) {
301 | uchar* data = roi_frame.ptr(i);
302 | for (int j = 0; j < t_w; j+=3) {
303 | q_b = data[j]/bin;
304 | q_g = data[j+1]/bin;
305 | q_r = data[j+2]/bin;
306 | q_temp[i*t_w+j] = q_r*256+q_g*16+q_b;
307 | hist2[q_temp[i*t_w+j]] += m_wei[i*t_w+j];
308 |
309 | }
310 | }
311 |
312 | for (int i = 0; i < bin*bin*bin; ++i) {
313 | hist2[i] /= C_;
314 |
315 | if (hist2[i] != 0)
316 | {
317 | w[i] = sqrt(hist1[i]/hist2[i]);
318 | if(isnan(w[i])){
319 | cout<<"w[i] is nan:" < eps && iter_count < 20){
397 |
398 | ++iter_count;
399 |
400 | roi_image = draw_mat(trackWindow);
401 |
402 | getPu(roi_image,pu_hist); //获得候选区域的特征
403 |
404 | getWi(roi_image,pu_hist,qu_hist,Mat_wi); //获得权值矩阵
405 |
406 | bhattacharyyaK = Bhattacharyya(pu_hist,qu_hist);
407 |
408 | Yi_bias = updateYi(roi_image,Mat_wi);
409 |
410 | if(isnan(Yi_bias.x) || isnan(Yi_bias.y)){
411 | continue;
412 | }
413 |
414 | if(lastCorrelation > bhattacharyyaK){
415 | Yi_bias = Yi_bias / 2.0;
416 | }
417 |
418 | point_Y0 = safeUpdate(point_Y0,Yi_bias,trackWindow,draw_mat.cols,draw_mat.rows);
419 |
420 | trackWindow.x = (int)round(point_Y0.x);
421 | trackWindow.y = (int)round(point_Y0.y);
422 |
423 | error = sqrt(pow((double)Yi_bias.x,2) + pow((double)Yi_bias.y,2));
424 |
425 | cout<<"-------track_windows-------"< points,double* result){
25 | double sumX_pow=0,sumX=0,sumXY=0,sumY=0;
26 | unsigned long N_points = points.size();
27 |
28 | // #pragma omp parallel for reduction(+:sumX_pow,sumX,sumXY,sumY)
29 | for (int i = 0; i < N_points; ++i) {
30 | sumX_pow += points[i].x * points[i].x;
31 | sumX += points[i].x;
32 | sumXY += points[i].x*points[i].y;
33 | sumY += points[i].y;
34 | }
35 |
36 | double temp;
37 | temp = N_points*sumX_pow-sumX*sumX;
38 | if(temp==0){
39 | result[0] = 1;
40 | result[1] = 0;
41 | }else{
42 | result[0] = (N_points*sumXY-sumX*sumY)/temp;
43 | result[1] = (sumX_pow*sumY-sumX*sumXY)/temp;
44 | }
45 | // cout< points,double K_coefficient[2]){
72 | unsigned long num_points;
73 | num_points = points.size();
74 | MatrixXd m_points = MatrixXd::Constant(num_points,3,1);
75 | // #pragma omp parallel for
76 | for (int i = 0; i < num_points; ++i) {
77 | m_points(i,0) = points[i].x;
78 | m_points(i,1) = points[i].y;
79 | }
80 | int N = 500,sample_count=0,sample_id[2],max_inlier_counter=0;
81 | bool stop_flag=false;
82 |
83 | double K_abc[3];//由两点确定的直线参数
84 | int inlier_counter=0;//内点的个数
85 |
86 | std::vector final_inlier_points;
87 | while(N > sample_count && !stop_flag){
88 | //获取两个样本
89 | if(!getSamples(num_points,sample_id)){
90 | stop_flag = true;
91 | continue;
92 | }
93 | //两个点之间的距离不能太小
94 | if(getDistanceP2P(m_points(sample_id[0],0),m_points(sample_id[0],1),
95 | m_points(sample_id[1],0),m_points(sample_id[1],1))<5.0)
96 | {
97 | ++sample_count;
98 | continue;
99 | }
100 | //通过选取的两个点计算出确定的直线方程
101 | getLine(m_points(sample_id[0],0),m_points(sample_id[0],1),
102 | m_points(sample_id[1],0),m_points(sample_id[1],1),K_abc);
103 | //找出内点
104 | MatrixXd error_;
105 | getDistanceP2L_Matrix(m_points,K_abc,error_);
106 |
107 | std::vector inlierPoints;
108 |
109 | for (int i = 0; i < num_points; ++i) {
110 | if(error_(i,0) <= inlier_error){
111 | inlierPoints.push_back(cv::Point2d(m_points(i,1),m_points(i,0)));
112 | }
113 | }
114 | inlier_counter = inlierPoints.size();
115 |
116 | if(inlier_counter > max_inlier_counter){
117 | max_inlier_counter = inlier_counter;
118 | final_inlier_points = inlierPoints;
119 | }
120 |
121 | if(inlier_counter == 0)
122 | {
123 | N=500;
124 | }else{
125 | double epsilon = double(inlier_counter)/(double)num_points;
126 | double p = 0.99;
127 | double s = 2.0;
128 | N = int(log(1.0-p)/log(1.0-pow(epsilon,s)));
129 | }
130 | ++sample_count;
131 |
132 | }
133 | double KKKK[2];
134 | LeastSquares(final_inlier_points,K_coefficient);
135 | }
136 |
137 | void wong::RANSAC::getTestSamples(std::vector& points,const int max_iter){
138 | // for (int i = 0; i < max_iter; i+=5) {
139 | // points.push_back(cv::Point2d(i,i*0.85+7+(rand()/double(RAND_MAX))*40));
140 | // }
141 | // for (int i = 0; i < max_iter; i+=50) {
142 | // points.push_back(cv::Point2d(i,i*0.85+((rand()-RAND_MAX)/double(RAND_MAX))*400));
143 | // }
144 | for (int i = 1; i < max_iter; i+=10) {
145 | points.push_back(cv::Point2d(i,i*0.85+7+((rand()-RAND_MAX)/double(RAND_MAX))*50));
146 | }
147 |
148 | for (int i = 1; i < max_iter; i+=2) {
149 | points.push_back(cv::Point2d(i,i*0.85+7+((rand()-RAND_MAX)/double(RAND_MAX))*10));
150 | }
151 | }
--------------------------------------------------------------------------------
/calibration_camera/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/calibration_camera/checkerboard.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/checkerboard.jpg
--------------------------------------------------------------------------------
/calibration_camera/imgs/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/calibration_camera/imgs/calibration:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/imgs/calibration
--------------------------------------------------------------------------------
/calibration_camera/imgs/imagelist_creator:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/imgs/imagelist_creator
--------------------------------------------------------------------------------
/calibration_camera/out_camera_data.yml:
--------------------------------------------------------------------------------
1 | %YAML:1.0
2 | ---
3 | calibration_time: "2018年08月20日 星期一 17时52分04秒"
4 | image_width: 640
5 | image_height: 480
6 | board_width: 7
7 | board_height: 7
8 | square_size: 1.
9 | aspectRatio: 1.
10 | flags: 2
11 | camera_matrix: !!opencv-matrix
12 | rows: 3
13 | cols: 3
14 | dt: d
15 | data: [ 5.3101564559463623e+02, 0., 3.0668324727632807e+02, 0.,
16 | 5.3101564559463623e+02, 2.3741958427982166e+02, 0., 0., 1. ]
17 | distortion_coefficients: !!opencv-matrix
18 | rows: 5
19 | cols: 1
20 | dt: d
21 | data: [ -1.3957980991568589e-01, 1.6706476438511100e-01,
22 | 6.4065444407492998e-04, 1.6858992065452159e-03,
23 | 7.2474287140812044e-01 ]
24 | avg_reprojection_error: 2.8814763752004585e-01
25 |
--------------------------------------------------------------------------------
/calibration_camera/sample/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/1.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/10.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/10.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/11.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/11.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/12.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/12.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/13.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/13.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/14.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/14.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/15.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/15.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/16.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/16.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/17.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/17.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/18.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/18.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/19.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/19.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/2.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/20.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/20.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/3.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/4.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/5.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/5.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/6.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/6.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/7.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/7.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/8.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/8.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/checkerboard/9.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/checkerboard/9.jpg
--------------------------------------------------------------------------------
/calibration_camera/sample/correcte/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/calibration_camera/sample/correcte/corrected.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/sample/correcte/corrected.png
--------------------------------------------------------------------------------
/calibration_camera/src/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/calibration_camera/src/calibration_camera.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | sudo chmod 777 demo
3 | cd ../imgs
4 | sudo chmod 777 imagelist_creator calibration
5 | ./imagelist_creator imagelist.yaml *.jpg
6 | ./calibration -w=7 -h=7 imagelist.yaml
7 | sudo mv out_camera_data.yml ../
8 | sudo rm -rf imagelist.yaml
9 |
--------------------------------------------------------------------------------
/calibration_camera/src/demo:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/calibration_camera/src/demo
--------------------------------------------------------------------------------
/calibration_camera/src/demo_source/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/calibration_camera/src/demo_source/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # cmake needs this line
2 | cmake_minimum_required(VERSION 2.8)
3 | SET(CMAKE_BUILD_TYPE "Release")
4 | SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2 -DNDEBUG -pthread -fopenmp -pipe")
5 | add_definitions(-std=c++11)
6 | # Define project name
7 | project(demo)
8 |
9 | find_package(OpenCV REQUIRED)
10 |
11 | include_directories(${OpenCV_INCLUDE_DIRS})
12 |
13 | # Declare the executable target built from your sources
14 | add_executable(demo
15 | demo.cpp
16 | ../../../TrackingLib/include/tracking.hpp
17 | )
18 | # Link your application with OpenCV libraries
19 | target_link_libraries(demo ${OpenCV_LIBS})
20 |
--------------------------------------------------------------------------------
/calibration_camera/src/demo_source/demo.cpp:
--------------------------------------------------------------------------------
1 | #include "opencv2/core.hpp"
2 | #include "opencv2/imgcodecs.hpp"
3 | #include "opencv2/highgui.hpp"
4 | #include
5 | #include "../../../TrackingLib/include/tracking.hpp"
6 | #include
7 | using namespace std;
8 | int main(int argc, char* argv[])
9 | {
10 | cv::VideoCapture cap;
11 | cap.open(0);
12 | wong::calibration_camera camera(argv[1]);
13 | cv::Mat frame,out;
14 | cout<<"Press any key to exit the program !"<> frame;
17 | camera.remap_image(frame,out);
18 | cv::imshow("src",frame);
19 | cv::imshow("corrected",out);
20 | if(cv::waitKey(5)>=0)
21 | break;
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/calibration_camera/src/getCheker.py:
--------------------------------------------------------------------------------
1 | import cv2
2 | import numpy
3 | import os
4 | cap = cv2.VideoCapture(0)
5 | cnt=0
6 | print('Perss q to exit the program !')
7 | print('Perss s to save image !')
8 | for i in os.listdir('../imgs'):
9 | if i[-4:]=='.jpg':
10 | os.remove('../imgs/'+i)
11 | while True:
12 | ret,frame = cap.read()
13 | cv2.imshow('out',frame)
14 | key=cv2.waitKey(5)
15 | if (key & 0xff)==ord('s'):
16 | cnt+=1
17 | cv2.imwrite('../imgs/'+str(cnt)+'.jpg',frame)
18 | print('image has been saved in imgs/'+str(cnt)+'.jpg')
19 | if key & 0xff==ord('q'):
20 | break
21 |
--------------------------------------------------------------------------------
/icon/.gitignore:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/icon/RANSAC.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/icon/RANSAC.png
--------------------------------------------------------------------------------
/icon/icon.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/icon/icon.jpg
--------------------------------------------------------------------------------
/icon/icon_big.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/icon/icon_big.jpg
--------------------------------------------------------------------------------
/icon/kalman.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/icon/kalman.gif
--------------------------------------------------------------------------------
/icon/meanshift.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DasudaRunner/Object-Tracking/da43ea4f6bca990e2e07cdc6c630b4d0c4a43a6f/icon/meanshift.gif
--------------------------------------------------------------------------------
/test_camera.cpp:
--------------------------------------------------------------------------------
1 | //#include
2 | //#include
3 | //#include
4 | //#include "opencv2/core.hpp"
5 | //#include "opencv2/imgcodecs.hpp"
6 | //#include "opencv2/highgui.hpp"
7 | //#include "tracking.hpp"
8 | //#include
9 | //#include
10 | //#include
11 | //#include
12 | //#include
13 | //#include "tracking.hpp"
14 | //#include "KCFlib/kcftracker.hpp"
15 | //using namespace std;
16 | //using Eigen::MatrixXd;
17 | //cv::Rect selection;
18 | //bool selectObject = false;
19 | //cv::Point origin;
20 | //cv::Mat frame,img,out,rect_image;
21 | //bool flag = false;
22 | //bool tpause = false;
23 | //
24 | //static void onMouse(int event, int x, int y, int, void*)
25 | //{
26 | // if (!flag&&tpause)
27 | // {
28 | // if (selectObject)
29 | // {
30 | // selection.x = MIN(x, origin.x);
31 | // selection.y = MIN(y, origin.y);
32 | // selection.width = std::abs(x - origin.x);
33 | // selection.height = std::abs(y - origin.y);
34 | // selection &= cv::Rect(0, 0, frame.cols, frame.rows);
35 | // }
36 | //
37 | // switch (event)
38 | // {
39 | // case CV_EVENT_LBUTTONDOWN:
40 | // origin = cv::Point(x, y);
41 | // selection = cv::Rect(x, y, 0, 0);
42 | // selectObject = true;
43 | // break;
44 | // case CV_EVENT_LBUTTONUP:
45 | // selectObject = false;
46 | // if (selection.width > 0 && selection.height > 0)
47 | // cv::rectangle(img, selection, cv::Scalar(0, 255, 255));
48 | // flag = true;
49 | // break;
50 | // }
51 | // }
52 | //}
53 | //
54 | //int main(int argc, char* argv[])
55 | //{
56 | //
57 | // haibo::MeanShift tracker;
58 | // cv::VideoCapture cap;
59 | //
60 | // cap.open(0);
61 | // MatrixXd A(2,2);
62 | // haibo::KF kf;
63 | // kf.initKF();
64 | //
65 | // cv::namedWindow("Image", 2);
66 | // cv::setMouseCallback("Image", onMouse, 0);
67 | // haibo::calibration_camera camera("/home/irim/david/camera/cpp_src/test/out_camera_data.yml");
68 | //
69 | // int nFrames = 0;
70 | // for (;;)
71 | // {
72 | // if (!tpause)
73 | // {
74 | // cap >> out;
75 | // camera.remap_image(out,frame);
76 | // if (frame.empty())
77 | // break;
78 | // frame.copyTo(img);
79 | // if (flag)
80 | // {
81 | //// result = tracker.update(img);
82 | // cout<<"-----------------------------------------"< // Include RealSense Cross Platform API
123 | //#include
124 | //#include "opencv2/core.hpp"
125 | //#include "opencv2/imgcodecs.hpp"
126 | //#include "opencv2/highgui.hpp"
127 | //#include
128 | //#include "cv-helpers.hpp"
129 | //using namespace std;
130 | //int main(int argc, char * argv[])
131 | //{
132 | ////// Create a Pipeline - this serves as a top-level API for streaming and processing frames
133 | // rs2::pipeline p;
134 | // rs2::colorizer colorize;
135 | //
136 | // colorize.set_option(RS2_OPTION_COLOR_SCHEME,2);
137 | //// Configure and start the pipeline
138 | // rs2::pipeline_profile profile = p.start();
139 | //
140 | // rs2::align align_to(RS2_STREAM_COLOR);
141 | //
142 | // auto gen_element = [](int erosion_size)
143 | // {
144 | // return cv::getStructuringElement(cv::MORPH_RECT,
145 | // cv::Size(erosion_size + 1, erosion_size + 1),
146 | // cv::Point(erosion_size, erosion_size));
147 | // };
148 | //
149 | // const int erosion_size = 3;
150 | // auto erode_less = gen_element(erosion_size);
151 | // auto erode_more = gen_element(erosion_size * 2);
152 | // auto create_mask_from_depth = [&](cv::Mat& depth, int thresh, cv::ThresholdTypes type)
153 | // {
154 | // cv::threshold(depth, depth, thresh, 255, type);
155 | // cv::dilate(depth, depth, erode_less);
156 | // cv::erode(depth, depth, erode_more);
157 | // };
158 | //
159 | // while (true)
160 | // {
161 | // // Block program until frames arrive
162 | // rs2::frameset frames = p.wait_for_frames();
163 | //
164 | // rs2::frameset aligned_set = align_to.process(frames);
165 | // rs2::frame depth = aligned_set.get_depth_frame();
166 | // auto color_mat = frame_to_mat(aligned_set.get_color_frame());
167 | //
168 | // rs2::frame bw_depth = colorize(depth);
169 | //
170 | // auto depth_mat = frame_to_mat(bw_depth);
171 | // cv::cvtColor(depth_mat, depth_mat, CV_BGR2GRAY);
172 | // create_mask_from_depth(depth_mat, 180, cv::THRESH_BINARY);
173 | //
174 | // auto far = frame_to_mat(bw_depth);
175 | // cv::cvtColor(far, far, CV_BGR2GRAY);
176 | // far.setTo(255, far == 0);
177 | // create_mask_from_depth(far, 100, cv::THRESH_BINARY_INV);
178 | //
179 | // cv::Mat mask;
180 | // mask.create(depth_mat.size(), CV_8UC1);
181 | // mask.setTo(cv::Scalar::all(cv::GC_BGD));
182 | // mask.setTo(cv::GC_PR_BGD, far == 0);
183 | // mask.setTo(cv::GC_FGD, depth_mat == 255);
184 | //
185 | // cv::Mat bgModel, fgModel;
186 | // cv::grabCut(color_mat, mask, cv::Rect(), bgModel, fgModel, 1, cv::GC_INIT_WITH_MASK);
187 | // cv::Mat3b foreground = cv::Mat3b::zeros(color_mat.rows, color_mat.cols);
188 | // color_mat.copyTo(foreground, (mask == cv::GC_FGD) | (mask == cv::GC_PR_FGD));
189 | //
190 | //// cout<
206 | #include
207 | #include
208 | #include "opencv2/core.hpp"
209 | #include "opencv2/imgcodecs.hpp"
210 | #include "opencv2/highgui.hpp"
211 | #include
212 | #include
213 | #include
214 | #include
215 | #include
216 | #include
217 | #include
218 | #include
219 | #include "tracking.hpp"
220 | #include "clock.hpp"
221 |
222 | using namespace std;
223 | using Eigen::MatrixXd;
224 | using namespace Eigen;
225 | cv::Rect selection;
226 | cv::Point origin;
227 | cv::Mat frame;
228 | cv::Mat hist;
229 | int flag=0;
230 | //
231 | //cv::Mat srcHSV,H_hist,H_channel;
232 | //std::vector srcChannels;
233 | //cv::MatND backProjection;
234 | //int histBin = 180; //直方图中bin的个数
235 | //// int allBins = histBin*histBin*histBin;
236 | //float range[2] = {0,float(histBin)};
237 | //const float * histRange = {range};
238 | //haibo::utils util;
239 | //static void onMouse(int event, int x, int y, int, void*)
240 | //{
241 | // switch (event)
242 | // {
243 | // case CV_EVENT_LBUTTONDOWN:
244 | // origin = cv::Point(x, y);
245 | // selection = cv::Rect(x, y, 0, 0);
246 | // break;
247 | // case CV_EVENT_LBUTTONUP:
248 | // selection.x = MIN(x, origin.x);
249 | // selection.y = MIN(y, origin.y);
250 | // selection.width = std::abs(x - origin.x);
251 | // selection.height = std::abs(y - origin.y);
252 | // selection &= cv::Rect(0, 0, frame.cols, frame.rows);
253 | // if (selection.width > 0 && selection.height > 0)
254 | // cv::rectangle(frame, selection, cv::Scalar(0, 255, 255));
255 | //
256 | ////// cv::cvtColor(frame,srcHSV,CV_BGR2HSV);
257 | //// cv::cvtColor(frame,srcHSV,CV_BGR2YCrCb);
258 | //// cv::split(srcHSV,srcChannels);
259 | ////
260 | ////// H_channel = srcChannels.at(0);
261 | //// H_channel = srcChannels.at(1);
262 | //// cv::Mat roi_frame = H_channel(selection);
263 | ////
264 | //// cv::calcHist(&roi_frame,1,0,cv::Mat(),H_hist,1,&histBin,&histRange,true,false);
265 | ////
266 | //// cv::normalize(H_hist, H_hist, 0, 255, cv::NORM_MINMAX, -1, cv::Mat());
267 | // util.prepareBackProject(frame,selection,0,H_hist,histBin,true);
268 | // flag=1;
269 | // break;
270 | // }
271 | //}
272 | double mouse_point[2];
273 | static void onMouse(int event, int x, int y, int, void*)
274 | {
275 | if(event==CV_EVENT_MOUSEMOVE){
276 | mouse_point[0]=x;
277 | mouse_point[1]=y;
278 | }
279 |
280 | }
281 |
282 | int main(int argc, char * argv[])
283 | {
284 | // cv::VideoCapture cap;
285 | // cap.open(0);
286 | //
287 | // cv::namedWindow("Image");
288 | // cv::setMouseCallback("Image", onMouse, 0);
289 | //
290 | // haibo::KF kf;
291 | // cv::Point pre_point;
292 | // while(true){
293 | // cap>>frame;
294 | // pre_point = kf.predict(mouse_point,2);
295 | //
296 | // cv::circle(frame,cv::Point(int(mouse_point[0]),int(mouse_point[1])),5,cv::Scalar(0,255,0),3);
297 | // cv::circle(frame,pre_point,5,cv::Scalar(255,0,0),3);
298 | //
299 | // cv::imshow("Image",frame);
300 | // if(cv::waitKey(5)>0)
301 | // {
302 | // break;
303 | // }
304 | //
305 | // }
306 | // double sum=0,sum_f;
307 |
308 | // for (int i = 0; i < 10; ++i) {
309 | // sum+=i;
310 | // sum_f+=2*i;
311 | // }
312 | // cout< a;
316 | a.push_back(cv::Point2d(35.3,10.98));
317 | a.push_back(cv::Point2d(29.7,11.13));
318 | a.push_back(cv::Point2d(30.8,12.51));
319 | a.push_back(cv::Point2d(58.8,8.4));
320 | a.push_back(cv::Point2d(61.4,9.27));
321 |
322 | a.push_back(cv::Point2d(71.3,8.73));
323 | a.push_back(cv::Point2d(74.4,6.36));
324 | a.push_back(cv::Point2d(76.6,8.5));
325 | a.push_back(cv::Point2d(70.7,7.82));
326 | a.push_back(cv::Point2d(57.5,9.17));
327 |
328 | a.push_back(cv::Point2d(46.4,8.24));
329 | a.push_back(cv::Point2d(28.9,12.19));
330 | a.push_back(cv::Point2d(28.1,11.88));
331 | a.push_back(cv::Point2d(39.1,9.57));
332 | a.push_back(cv::Point2d(46.8,10.94));
333 |
334 | a.push_back(cv::Point2d(48.5,9.58));
335 | a.push_back(cv::Point2d(59.3,10.09));
336 | a.push_back(cv::Point2d(70.0,8.11));
337 | a.push_back(cv::Point2d(70.0,6.83));
338 | a.push_back(cv::Point2d(74.5,8.88));
339 |
340 | a.push_back(cv::Point2d(72.1,7.68));
341 | a.push_back(cv::Point2d(58.1,8.47));
342 | a.push_back(cv::Point2d(44.6,8.86));
343 | a.push_back(cv::Point2d(33.4,10.38));
344 | a.push_back(cv::Point2d(28.6,11.08));
345 |
346 |
347 | wong::clocker clocker;
348 | wong::RANSAC line;
349 |
350 | cv::Mat image = cv::Mat::zeros(480,640,CV_8UC3);
351 | image.setTo(cv::Scalar(100,0,0));
352 |
353 | std::vector points;
354 | line.getTestSamples(points,1000);
355 | for (int i = 0; i < points.size(); ++i) {
356 | cv::circle(image, points[i], 1, cv::Scalar(0, 0, 255), 1, 8, 0);
357 | }
358 |
359 | double K[2];
360 | for (int j = 0; j < 10; ++j) {
361 | clocker.clock_start();
362 | line.fit(points,K);
363 | clocker.print_time_us("01");
364 | }
365 |
366 | cv::line(image,cv::Point(0,-K[1]/K[0]),cv::Point(1800,(1800-K[1])/K[0]),cv::Scalar(0,255,0),3);
367 | // cout<
9 | #include
10 | #include
11 | #include
12 |
13 | /*
14 | ***************测试代码****************
15 | #include "opencv2/core.hpp"
16 | #include "opencv2/imgcodecs.hpp"
17 | #include "opencv2/highgui.hpp"
18 | #include
19 | #include "utils/Camera.hpp"
20 |
21 | using namespace std;
22 |
23 | int main()
24 | {
25 | calibration_camera camera("-----/out_camera_data.yml");
26 | cv::VideoCapture cap(0);
27 | cv::Mat frame,remape_frame;
28 | while(true){
29 | cap>>frame;
30 |
31 | cv::imshow("src",frame);
32 |
33 | camera.remap_image(frame,remape_frame);
34 |
35 | cv::imshow("remape",remape_frame);
36 |
37 | if(cv::waitKey(5)>0)
38 | {
39 | break;
40 | }
41 | }
42 | }
43 |
44 | */
45 |
46 | namespace wong{
47 | class calibration_camera{
48 | private:
49 | cv::Mat cameraMatrix = cv::Mat::eye(3, 3, CV_64F);
50 | cv::Mat distCoeffs = cv::Mat::zeros(5, 1, CV_64F);
51 | cv::Size imageSize;
52 | public:
53 | //构造函数读取标定的参数文件
54 | calibration_camera(std::string filename){
55 | fprintf(stderr, "loadParams.\n");
56 | cv::FileStorage fs(filename, cv::FileStorage::READ);
57 | if (!fs.isOpened()) {
58 | fprintf(stderr, "%s:%d:loadParams falied. 'camera.yml' does not exist\n", __FILE__, __LINE__);
59 | }
60 | char buf1[100];
61 | sprintf(buf1, "camera_matrix");
62 | char buf2[100];
63 | sprintf(buf2, "distortion_coefficients");
64 | fs[buf1] >> cameraMatrix;
65 | fs[buf2] >> distCoeffs;
66 | fs.release();
67 | }
68 | //对摄像头读取的每一帧进行校正
69 | void remap_image(cv::Mat &src,cv::Mat &out){
70 | cv::Mat view, rview, map1, map2;
71 | imageSize = src.size();
72 | cv::initUndistortRectifyMap(cameraMatrix, distCoeffs, cv::Mat(),
73 | getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0),
74 | imageSize, CV_16SC2, map1, map2);
75 | cv::remap(src, out, map1, map2, cv::INTER_LINEAR);
76 | }
77 | };
78 | }
79 | #endif //TRACKING_CAMERA_HPP
80 |
--------------------------------------------------------------------------------
/utils/clock.hpp:
--------------------------------------------------------------------------------
1 | //
2 | // Created by dasuda on 18-10-26.
3 | //
4 |
5 | #ifndef TRACKING_CLOCK_HPP
6 | #define TRACKING_CLOCK_HPP
7 | #include
8 | #include
9 | #include
10 |
11 | namespace wong {
12 | using namespace std;
13 |
14 | class clocker {
15 |
16 | private:
17 | clock_t last_time;
18 |
19 | public:
20 | void clock_start(){
21 | last_time = clock();
22 | }
23 |
24 | void print_time_us(string ID){
25 | cout<<"Total time["<
9 | #include
10 | #include
11 | #include
12 |
13 | namespace wong{
14 | class GetTensorflowNet{
15 | using namespace std;
16 | using namespace cv;
17 | private:
18 | dnn::Net net;
19 | String _modelName,_inputBLobName,_outputBlobName;
20 | Size _imgSize;
21 |
22 | void getMaxClass_n(const Mat &probBlob, int *classId, double *classProb);
23 | public:
24 | //初始化模型
25 | GetTensorflowNet(String modelName,String inputBlobName, String outputBlobName, Size imgSize);
26 | //进行预测
27 | bool predict(const std::vector & imgs, int nClass, int *classId, double *classProb_n);
28 |
29 | };
30 | /*
31 | * @details init the tensorflow model
32 | * @param modelName the model file path
33 | * @param inputBlobName the input tensor's name
34 | * @param outputBlobName the output tensor's name
35 | * @param imgSize input images's size
36 | * */
37 | GetTensorflowNet::GetTensorflowNet(String modelName, String inputBlobName, String outputBlobName, Size imgSize) {
38 | _modelName = modelName;
39 | _inputBLobName = inputBlobName;
40 | _outputBlobName = outputBlobName;
41 | _imgSize = imgSize;
42 |
43 | net = dnn::readNetFromTensorflow(_modelName);
44 | if(net.empty()){
45 | cerr<<"Plase Check the model path: "< &imgs, int nClass, int *classId, double *classProb_n) {
50 |
51 | if(imgs.size()!=nClass){
52 | cerr<<"input images size is wrong "<