├── .gitignore
├── CMakeLists.txt
├── COPYING
├── COPYING.LESSER
├── ChangeLog
├── Doxyfile
├── README.md
├── cmake-variants.yaml
├── cvBlob
    ├── cvb_aux.cpp
    ├── cvb_aux.h
    ├── cvb_blob.cpp
    ├── cvb_blob.h
    ├── cvb_blob_list.cpp
    ├── cvb_blob_list.h
    ├── cvb_contour.cpp
    ├── cvb_contour.h
    ├── cvb_defines.h
    ├── cvb_track.cpp
    └── cvb_track.h
├── meson.build
├── samples
    ├── Makefile
    ├── red_object_tracking.cpp
    └── red_object_tracking.txt
├── test
    ├── CMakeLists.txt
    ├── EnterExitCrossingPaths2front_blobs.mpeg
    ├── EnterExitCrossingPaths2front_blobs.txt
    ├── test.cpp
    ├── test.png
    ├── test_random.cpp
    └── test_tracking.cpp
└── vc
    ├── TestDLL
        ├── TestDLL.cpp
        ├── TestDLL.vcxproj
        ├── TestDLL.vcxproj.filters
        └── test.png
    ├── cvBlob.sln
    └── cvBlob
        ├── cvBlob.vcxproj
        └── cvBlob.vcxproj.filters


/.gitignore:
--------------------------------------------------------------------------------
 1 | Specify filepatterns you want git to ignore.
 2 | 
 3 | Example:
 4 | #ignore thumbnails created by windows
 5 | Thumbs.db
 6 | #Ignore files build by Visual Studio
 7 | *.user
 8 | *.aps
 9 | *.pch
10 | *.vspscc
11 | *_i.c
12 | *_p.c
13 | *.ncb
14 | *.suo
15 | *.bak
16 | *.cache
17 | *.ilk
18 | *.log
19 | [Bb]in
20 | [Dd]ebug*/
21 | *.sbr
22 | obj/
23 | [Rr]elease*/
24 | _ReSharper*/
25 | builddir/
26 | build/
27 | build_clang/
28 | .vscode/
29 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright (C) 2021 by Michael de Gans
 2 | # mike@mdegans.dev
 3 | #
 4 | # This file is part of cvBlob.
 5 | #
 6 | # cvBlob is free software: you can redistribute it and/or modify
 7 | # it under the terms of the Lesser GNU General Public License as published by
 8 | # the Free Software Foundation, either version 3 of the License, or
 9 | # (at your option) any later version.
10 | #
11 | # cvBlob is distributed in the hope that it will be useful,
12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | # Lesser GNU General Public License for more details.
15 | #
16 | # You should have received a copy of the Lesser GNU General Public License
17 | # along with cvBlob.  If not, see <https:#www.gnu.org/licenses/>.
18 | #
19 | 
20 | cmake_minimum_required(VERSION 3.1)
21 | project(cvBlob)
22 | 
23 | set(CMAKE_CXX_STANDARD 11)
24 | set(CMAKE_CXX_STANDARD_REQUIRED True)
25 | 
26 | # Dependencies
27 | find_package(OpenCV REQUIRED)
28 | 
29 | set(SRC
30 |   cvBlob/cvb_aux.cpp
31 |   cvBlob/cvb_blob_list.cpp
32 |   cvBlob/cvb_blob.cpp
33 |   cvBlob/cvb_contour.cpp
34 |   # cvBlob/cvb_track.cpp
35 | )
36 | 
37 | set(INCLUDES
38 |   cvBlob/cvb_aux.h
39 |   cvBlob/cvb_blob_list.h
40 |   cvBlob/cvb_blob.h
41 |   cvBlob/cvb_contour.h
42 |   cvBlob/cvb_defines.h
43 |   # cvBlob/cvb_track.h
44 | )
45 | 
46 | # Library target
47 | set(LIB_NAME ${CMAKE_PROJECT_NAME})
48 | add_library(${LIB_NAME} SHARED ${SRC} ${INCLUDES})
49 | target_include_directories(${LIB_NAME} PUBLIC ${OpenCV_INCLUDE_DIRS}
50 |   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/${LIB_NAME}>
51 |   $<INSTALL_INTERFACE:include/${LIB_NAME}>  # <prefix>/include/mylib
52 | )
53 | target_link_libraries(${LIB_NAME} ${OpenCV_LIBS})
54 | 
55 | # Installation
56 | install(TARGETS ${LIB_NAME}
57 |   DESTINATION ${CMAKE_INSTALL_LIBDIR}
58 | )
59 | 
60 | # Somehow, ${CMAKE_INSTALL_INCLUDEDIR} is blank so we use this "custom" path.
61 | install(FILES ${INCLUDES}
62 |   DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${CMAKE_PROJECT_NAME}
63 | )
64 | 


--------------------------------------------------------------------------------
/COPYING:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  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 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
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 <https://www.gnu.org/licenses/>.
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 |     <program>  Copyright (C) <year>  <name of author>
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 | <https://www.gnu.org/licenses/>.
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 | <https://www.gnu.org/licenses/why-not-lgpl.html>.


--------------------------------------------------------------------------------
/COPYING.LESSER:
--------------------------------------------------------------------------------
  1 |                    GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 | 
  9 |   This version of the GNU Lesser General Public License incorporates
 10 | the terms and conditions of version 3 of the GNU General Public
 11 | License, supplemented by the additional permissions listed below.
 12 | 
 13 |   0. Additional Definitions.
 14 | 
 15 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 17 | General Public License.
 18 | 
 19 |   "The Library" refers to a covered work governed by this License,
 20 | other than an Application or a Combined Work as defined below.
 21 | 
 22 |   An "Application" is any work that makes use of an interface provided
 23 | by the Library, but which is not otherwise based on the Library.
 24 | Defining a subclass of a class defined by the Library is deemed a mode
 25 | of using an interface provided by the Library.
 26 | 
 27 |   A "Combined Work" is a work produced by combining or linking an
 28 | Application with the Library.  The particular version of the Library
 29 | with which the Combined Work was made is also called the "Linked
 30 | Version".
 31 | 
 32 |   The "Minimal Corresponding Source" for a Combined Work means the
 33 | Corresponding Source for the Combined Work, excluding any source code
 34 | for portions of the Combined Work that, considered in isolation, are
 35 | based on the Application, and not on the Linked Version.
 36 | 
 37 |   The "Corresponding Application Code" for a Combined Work means the
 38 | object code and/or source code for the Application, including any data
 39 | and utility programs needed for reproducing the Combined Work from the
 40 | Application, but excluding the System Libraries of the Combined Work.
 41 | 
 42 |   1. Exception to Section 3 of the GNU GPL.
 43 | 
 44 |   You may convey a covered work under sections 3 and 4 of this License
 45 | without being bound by section 3 of the GNU GPL.
 46 | 
 47 |   2. Conveying Modified Versions.
 48 | 
 49 |   If you modify a copy of the Library, and, in your modifications, a
 50 | facility refers to a function or data to be supplied by an Application
 51 | that uses the facility (other than as an argument passed when the
 52 | facility is invoked), then you may convey a copy of the modified
 53 | version:
 54 | 
 55 |    a) under this License, provided that you make a good faith effort to
 56 |    ensure that, in the event an Application does not supply the
 57 |    function or data, the facility still operates, and performs
 58 |    whatever part of its purpose remains meaningful, or
 59 | 
 60 |    b) under the GNU GPL, with none of the additional permissions of
 61 |    this License applicable to that copy.
 62 | 
 63 |   3. Object Code Incorporating Material from Library Header Files.
 64 | 
 65 |   The object code form of an Application may incorporate material from
 66 | a header file that is part of the Library.  You may convey such object
 67 | code under terms of your choice, provided that, if the incorporated
 68 | material is not limited to numerical parameters, data structure
 69 | layouts and accessors, or small macros, inline functions and templates
 70 | (ten or fewer lines in length), you do both of the following:
 71 | 
 72 |    a) Give prominent notice with each copy of the object code that the
 73 |    Library is used in it and that the Library and its use are
 74 |    covered by this License.
 75 | 
 76 |    b) Accompany the object code with a copy of the GNU GPL and this license
 77 |    document.
 78 | 
 79 |   4. Combined Works.
 80 | 
 81 |   You may convey a Combined Work under terms of your choice that,
 82 | taken together, effectively do not restrict modification of the
 83 | portions of the Library contained in the Combined Work and reverse
 84 | engineering for debugging such modifications, if you also do each of
 85 | the following:
 86 | 
 87 |    a) Give prominent notice with each copy of the Combined Work that
 88 |    the Library is used in it and that the Library and its use are
 89 |    covered by this License.
 90 | 
 91 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
 92 |    document.
 93 | 
 94 |    c) For a Combined Work that displays copyright notices during
 95 |    execution, include the copyright notice for the Library among
 96 |    these notices, as well as a reference directing the user to the
 97 |    copies of the GNU GPL and this license document.
 98 | 
 99 |    d) Do one of the following:
100 | 
101 |        0) Convey the Minimal Corresponding Source under the terms of this
102 |        License, and the Corresponding Application Code in a form
103 |        suitable for, and under terms that permit, the user to
104 |        recombine or relink the Application with a modified version of
105 |        the Linked Version to produce a modified Combined Work, in the
106 |        manner specified by section 6 of the GNU GPL for conveying
107 |        Corresponding Source.
108 | 
109 |        1) Use a suitable shared library mechanism for linking with the
110 |        Library.  A suitable mechanism is one that (a) uses at run time
111 |        a copy of the Library already present on the user's computer
112 |        system, and (b) will operate properly with a modified version
113 |        of the Library that is interface-compatible with the Linked
114 |        Version.
115 | 
116 |    e) Provide Installation Information, but only if you would otherwise
117 |    be required to provide such information under section 6 of the
118 |    GNU GPL, and only to the extent that such information is
119 |    necessary to install and execute a modified version of the
120 |    Combined Work produced by recombining or relinking the
121 |    Application with a modified version of the Linked Version. (If
122 |    you use option 4d0, the Installation Information must accompany
123 |    the Minimal Corresponding Source and Corresponding Application
124 |    Code. If you use option 4d1, you must provide the Installation
125 |    Information in the manner specified by section 6 of the GNU GPL
126 |    for conveying Corresponding Source.)
127 | 
128 |   5. Combined Libraries.
129 | 
130 |   You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 | 
136 |    a) Accompany the combined library with a copy of the same work based
137 |    on the Library, uncombined with any other library facilities,
138 |    conveyed under the terms of this License.
139 | 
140 |    b) Give prominent notice with the combined library that part of it
141 |    is a work based on the Library, and explaining where to find the
142 |    accompanying uncombined form of the same work.
143 | 
144 |   6. Revised Versions of the GNU Lesser General Public License.
145 | 
146 |   The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 | 
151 |   Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 | 
161 |   If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.


--------------------------------------------------------------------------------
/ChangeLog:
--------------------------------------------------------------------------------
  1 | Version 0.20.0 (2013/07/20)
  2 | 
  3 |   * Rewrote the library to use the OpenCV C++ interface
  4 |   * Breaking changes: will require a C++11-compliant compiler
  5 |   * Added a simpler, more efficient labelling algorithm, does not compute contours
  6 |   * (Temporarily) removed tracking support
  7 | 
  8 | Version 0.10.4 (2011/01/26)
  9 | 
 10 |   * CMakeLists.txt, cvBlobConfig.cmake.in: created "cvBlobConfig.cmake" for
 11 |   easy integration with CMAKE projects. Thanks to zorzalzilba.
 12 | 
 13 |   * cvlabel.cpp: fixed bug in the function cvLabel by which it calculates area
 14 |   off by one.
 15 | 
 16 |   * cvblob.h: removed references to cvCentralMoments. Fixed bug with
 17 |   "cvGreaterBlob".
 18 | 
 19 | Version 0.10.3 (2010/11/12)
 20 | 
 21 |   * cvlabel.cpp: a little optimization in "cvLabel".
 22 | 
 23 |   * cvblob.cpp, cvlabel, cvblob.h: optimization of central moments
 24 |   calculation. Deleted: "cvCentralMoments" function and
 25 |   "centralMoments" member of CvBlob type.
 26 | 
 27 |   * cvblob.cpp, cvblob.h: new function "cvSaveImageBlob".
 28 | 
 29 |   * red_object_tracking.cpp: "cvSaveImageBlob" demo.
 30 | 
 31 |   * cvblob.cpp: fixes in "cvRenderBlobs" function.
 32 | 
 33 |   * cvtrack.cpp: fixes in "cvRenderTracks" function.
 34 | 
 35 |   * cvblob.h: fix problem when using "IPL_DEPTH_LABEL" outside "cvb" namespace.
 36 |   Thanks to recastrodiaz.
 37 | 
 38 |   * cvcountour.cpp: check size in "cvConvertChainCodesToPolygon" (thanks to
 39 |   tengyaogao). New function: cvContourPolygonCircularity.
 40 | 
 41 |   * test.cpp: clear image before render. Thanks to tengyaogao.
 42 | 
 43 |   * test_random.cpp: fixed portability issues and other minor changes.
 44 | 
 45 |   * CMakeLists.cmake, cvBlob/CMakeLists: compile dynamic library. Deleted
 46 |   "FindOpenCV.cmake".
 47 | 
 48 | Version 0.10.2 (2010/06/07)
 49 | 
 50 |   * cvblob.cpp, cvblob.h: new function "cvFilterByLabel".
 51 | 
 52 |   * cvcontour.cpp, cvblob.h: new function: cvContourChainCodePerimeter. Thanks
 53 |   to meonimarco.
 54 | 
 55 |   * cvlabel.cpp: fixed wrong background in cvFilterLabels. Thanks to
 56 |   mathias.ferraton.
 57 | 
 58 |   * cvblob.cpp, ...: fixed some compilation warnings.
 59 | 
 60 |   * cvcontour.cpp: some asserts deleted and/or fixed.
 61 | 
 62 |   * test_random.cpp: test improved.
 63 | 
 64 | Version 0.10.1 (2010/04/19)
 65 | 
 66 |   * cvcontour.cpp: "cvWriteContourPolygonCSV" function.
 67 | 
 68 |   * cvblob.h: new function cvReleaseBlob. Fixed memory leak in
 69 |   "cvReleaseBlobs".
 70 |   
 71 |   * cvblob.cpp: Fixed memory leak in "cvFilterByArea".
 72 | 
 73 | Version 0.10.0 (2010/03/18)
 74 | 
 75 |   * cvlabel.cpp: new labeling algorithm.
 76 | 
 77 |   * cvcontour.cpp: "cvGetContour" function deleted (this functionality is
 78 |   doing now by "cvLabel").
 79 | 
 80 |   * cvcolor.cpp: new file. Function: "cvBlobMeanColor".
 81 | 
 82 |   * cvblob.cpp: new function "cvRenderBlob". Fixed bug in "cvRenderBlobs" (now
 83 |   uses "cvRenderBlob").
 84 | 
 85 |   * cvaux.cpp: bug fixed (change "abs" for "fabs"). Thanks, sircoko.
 86 | 
 87 | Version 0.9.14 (2010/03/10)
 88 | 
 89 |   * cvlabel.cpp, cvblob.h: function "cvGetLabel".
 90 | 
 91 |   * Makefile, red_object_tracking.cpp: sample program.
 92 | 
 93 | Version 0.9.13 (2010/01/01)
 94 | 
 95 |   * several files: namespace "cvb".
 96 | 
 97 |   * cvblob.h, cvcontour.cpp: function to write contour to a SVG file.
 98 | 
 99 |   * cvblob.h, cvtrack.cpp: tracking algorithm rewritten and new mode for
100 |   render tracks.
101 | 
102 | Version 0.9.12 (2009/12/01)
103 | 
104 |   * cvaux.cpp: new file. Auxiliar functions.
105 | 
106 |   * cvcontour.cpp: bug fixed in cvConvertChainCodesToPolygon. Problem with
107 |   blobs of one pixel. New functions.
108 | 
109 |   * cvtrack.cpp: memory leak fixed in cvRenderTracks.
110 | 
111 |   * cvblob.h: doxygen documentation. New functions.
112 | 
113 | Version 0.9.11 (2009/10/01)
114 | 
115 |   * cvblob.cpp, cvlabel.cpp, cvtracker.cpp, cvcontour.cpp: error handling
116 |   OpenCV's style.
117 | 
118 |   * cvlabel.ccp: Fixed another bug about ranges.
119 | 
120 | Version 0.9.10 (2009/09/30)
121 | 
122 |   * cvlabel.cpp: Fixed a mistake in the labeling algorithm.
123 | 
124 |   * cvcontour.cpp: new file. Contours.
125 | 
126 |   * cvblob.h: contours types and functions.
127 | 
128 |   * test.cpp: added ROI and contours for test.
129 | 
130 | Version 0.9.9 (2009/09/11)
131 | 
132 |   * cvblob.cpp, cvlabel.cpp: ImageROI support by Kouichi Nishino.
133 | 
134 |   * cvblob.h, cvtrack.cpp: new features. Tracking implementation.
135 | 
136 |   * test_tracking.cpp: new test for tracking. 
137 | 
138 |   * EnterExitCrossingPaths2front_blobs.mpeg,
139 |   EnterExitCrossingPaths2front_blobs.txt: new files. Video for tracking test
140 |   and info about the video.
141 | 
142 |   * CMakeLists.txt: various files. Updated. Also "Release/Debug" flag added to
143 |   main "CMakeLists.txt".
144 | 
145 |   * README: updated contributors.
146 | 
147 |   * Doxyfile: removed obsolete parameter.
148 | 
149 | Version 0.9.8 (2009/03/13)
150 | 
151 |   * cvblob.h: Doxygen documentation added.
152 | 
153 |   * Doxyfile: new file. Doxygen configuration.
154 | 
155 |   * cvlabel: fixed bounding box area calculation in cvRenderBlobs, and blobs
156 |   structure release.
157 | 
158 |   * cvblob.h, cvblob.cpp:
159 |     + cvReleaseBlobs: new function to release memory.
160 |     + Various: trying some optimization.
161 | 
162 |   * test.cpp: releases blobs.
163 | 
164 | Version 0.9.7 (2009/01/09)
165 | 
166 |   * cvblob.cpp: fixed little bug in cvRenderBlobs.
167 | 
168 |   * cvlabel.cpp: fixed memory bug in cvLabel.
169 | 
170 | Version 0.9.6 (2009/01/07)
171 | 
172 |   * cvblob.cpp:
173 |     + Various: fixed some warnings and indentation.
174 |     + cvRenderBlobs: new features. Now print blob information to log and standard
175 |     out.
176 | 
177 |   * cvblob.h: cvRenderBlobs new features.
178 | 
179 |   * cvlabel.h: fixed issue about the calculation of the blob area.
180 | 
181 | Version 0.9.5 (2009/01/04)
182 | 
183 |   * cvlabel.cpp, cvblob.cpp: fixed bug that appears when images has an odd
184 |   number of columns. "widhtStep", "depth" and "nChannels" are used now. Thanks
185 |   again to Stefan Gachter for give me the solution.
186 | 
187 | Version 0.9.4 (2008/12/18)
188 | 
189 |   * cvblob.cpp:
190 |     + cvCentralMoments: checks if central moments was been calculate before.
191 |     + cvRenderBlobs: new function to render blobs.
192 |     + cvAngle: check if central moments have been caclulated.
193 | 
194 |   * cvlabel.cpp: initialize "centralMoments".
195 | 
196 |   * cvblob.h:
197 |     + IPL_DEPTH_LABEL: now is calculated.
198 |     + CvBlob: new member: "centralMoments".
199 |     + cvCentralMoments: image is keeping constant.
200 |     + cvRenderBlobs: head and "defines".
201 | 
202 |   * test.cpp: now uses the new function "cvRenderBlobs".
203 | 
204 | Version 0.9.3 (2008/12/17)
205 | 
206 |   * cvlabel.cpp: rewritten changes of version 0.9.1.
207 | 
208 | Version 0.9.2 (2008/12/15)
209 | 
210 |   * README: updated instructions for instalation of dependencies.
211 | 
212 |   * CMakeList: new version and line required by CMake 2.6.
213 | 
214 | Version 0.9.1 (2008/12/12)
215 | 
216 |   * Fixed labeling: works with all the pixels of the binary image (even
217 |   borders) and with any number of colunms. Also, the format was fixed. Thanks
218 |   to Stefan Gachter.
219 | 
220 |   * Function "merge": it didn't return anything. Thanks to yostane.
221 | 
222 |   * README: updated.
223 | 
224 | Version 0.9.0 (2008/09/29)
225 | 
226 |   * Test: implemented.
227 | 
228 |   * README: redacted first version.
229 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # cvBlob
 2 | 
 3 | This library allows you to find and track blobs on a picture, using OpenCV.
 4 | 
 5 | ## Dependencies
 6 | 
 7 | In order to compile cvBlob you need the following:
 8 | 
 9 | * CMAKE https://cmake.org
10 | * OpenCV  https://opencv.org
11 | * A recent C++ compiler, that supports some C++11 features
12 | 
13 | ## Compiling and installing
14 | 
15 | ### Linux
16 | 
17 | In Linux, Meson or CMake can be used.
18 | 
19 | #### Meson
20 | 
21 | ```shell
22 | cd $CVBLOB
23 | meson builddir
24 | cd builddir
25 | ninja
26 | (sudo) ninja install
27 | ```
28 | 
29 | #### CMake
30 | 
31 | ```shell
32 | cd $CVBLOB
33 | mkdir build
34 | cd build
35 | cmake -GNinja ..
36 | ninja
37 | (sudo) ninja install
38 | ```
39 | 
40 | ### Windows
41 | 
42 | A Visual Studio 2012 solution is provided in the vc subdirectory. CMake can also be used.
43 | 
44 | ### Installation path
45 | 
46 | #### Meson
47 | 
48 | When configuring with meson, simply provide a `--prefix=/path` like
49 | ```shell
50 | ...
51 | cd builddir
52 | meson --prefix=~/.local ..
53 | ...
54 | ```
55 | 
56 | #### CMake
57 | 
58 | To change the destination path for the installation, set the `CMAKE_INSTALL_PREFIX` variable:
59 | ```shell
60 | cmake . -DCMAKE_INSTALL_PREFIX=<installation_path>
61 | ```
62 | 
63 | ### Problems
64 | 
65 | Encountered an issue? [Tell us about it!](https://github.com/Steelskin/cvblob/issues)
66 | 
67 | ## Information
68 | 
69 | The official home page of cvBlob is https://github.com/Steelskin/cvblob
70 | 
71 | ## Author and contributors
72 | 
73 | Comments, suggestions and, why not, donations to:
74 | 
75 | * [Fabrice de Gans](mailto:fabrice.degans@gmail.com), current maintainer
76 | * [Cristóbal Carnero Liñán](mailto:grendel.ccl@gmail.com), first author
77 | * [Stefan Gachter](http://gachter.name)
78 | * Kouichi Nishino
79 | * [Giandomenico De Sanctis](http://gidesa.altervista.org/)
80 | * [Michael de Gans](https://www.mdegans.dev)
81 | 


--------------------------------------------------------------------------------
/cmake-variants.yaml:
--------------------------------------------------------------------------------
 1 | buildType:
 2 |   default: debug
 3 |   choices:
 4 |     debug:
 5 |       short: Debug
 6 |       long: Emit debug information
 7 |       buildType: Debug
 8 |     release:
 9 |       short: Release
10 |       long: Optimize generated code
11 |       buildType: Release
12 |     asan:
13 |       short: Asan
14 |       long: Instrument with Address Sanitizer
15 |       buildType: Asan
16 | 
17 | linkage:
18 |   default: static
19 |   choices:
20 |     static:
21 |       short: Static
22 |       long: Create static libraries
23 |       linkage: static
24 |     shared:
25 |       short: Shared
26 |       long: Create shared libraries/DLLs
27 |       linkage: shared
28 | 


--------------------------------------------------------------------------------
/cvBlob/cvb_aux.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
 2 | // grendel.ccl@gmail.com
 3 | //
 4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
 5 | // fabrice.degans@gmail.com
 6 | //
 7 | // This file is part of cvBlob.
 8 | //
 9 | // cvBlob is free software: you can redistribute it and/or modify
10 | // it under the terms of the Lesser GNU General Public License as published by
11 | // the Free Software Foundation, either version 3 of the License, or
12 | // (at your option) any later version.
13 | //
14 | // cvBlob is distributed in the hope that it will be useful,
15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 | // Lesser GNU General Public License for more details.
18 | //
19 | // You should have received a copy of the Lesser GNU General Public License
20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
21 | //
22 | 
23 | #include <cmath>
24 | 
25 | #include "cvb_aux.h"
26 | 
27 | using namespace cvb;
28 | 
29 | // https://www.topcoder.com/tc?module=Static&d1=tutorials&d2=geometry1
30 | double cvb::DotProductPoints(const cv::Point &a, const cv::Point &b, const cv::Point &c) {
31 |     double abx = b.x-a.x;
32 |     double aby = b.y-a.y;
33 |     double bcx = c.x-b.x;
34 |     double bcy = c.y-b.y;
35 | 
36 |     return abx*bcx + aby*bcy;
37 | }
38 | 
39 | double cvb::CrossProductPoints(const cv::Point &a, const cv::Point &b, const cv::Point &c) {
40 |     double abx = b.x-a.x;
41 |     double aby = b.y-a.y;
42 |     double acx = c.x-a.x;
43 |     double acy = c.y-a.y;
44 | 
45 |     return abx*acy - aby*acx;
46 | }
47 | 
48 | double cvb::DistancePointPoint(const cv::Point &a, const cv::Point &b) {
49 |     double abx = a.x-b.x;
50 |     double aby = a.y-b.y;
51 | 
52 |     return sqrt(abx*abx + aby*aby);
53 | }
54 | 
55 | double cvb::DistanceLinePoint(const cv::Point &a, const cv::Point &b, const cv::Point &c, bool isSegment) {
56 |     if (isSegment) {
57 |         double dot1 = cvb::DotProductPoints(a, b, c);
58 |         if (dot1>0)
59 |             return cvb::DistancePointPoint(b, c);
60 | 
61 |         double dot2 = cvb::DotProductPoints(b, a, c);
62 |         if(dot2>0)
63 |             return cvb::DistancePointPoint(a, c);
64 |     }
65 | 
66 |     return fabs(cvb::CrossProductPoints(a,b,c) / cvb::DistancePointPoint(a,b));
67 | }
68 | 


--------------------------------------------------------------------------------
/cvBlob/cvb_aux.h:
--------------------------------------------------------------------------------
 1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
 2 | // grendel.ccl@gmail.com
 3 | //
 4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
 5 | // fabrice.degans@gmail.com
 6 | //
 7 | // This file is part of cvBlob.
 8 | //
 9 | // cvBlob is free software: you can redistribute it and/or modify
10 | // it under the terms of the Lesser GNU General Public License as published by
11 | // the Free Software Foundation, either version 3 of the License, or
12 | // (at your option) any later version.
13 | //
14 | // cvBlob is distributed in the hope that it will be useful,
15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 | // Lesser GNU General Public License for more details.
18 | //
19 | // You should have received a copy of the Lesser GNU General Public License
20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
21 | //
22 | 
23 | /// \file cvb_aux.h
24 | /// \brief cvBlob auxiliary functions file.
25 | 
26 | #ifdef SWIG
27 | %module cvblob
28 |     %{
29 | #include "cvb_aux.h"
30 |         %}
31 | #endif
32 | 
33 | #ifndef _CVBLOB_AUX_H_
34 | #define _CVBLOB_AUX_H_
35 | 
36 | #include <opencv2/core/core.hpp>
37 | 
38 | #include "cvb_defines.h"
39 | 
40 | namespace cvb {
41 | 
42 |     /// \brief Dot product of the vectors ab and bc.
43 |     /// \param a First point.
44 |     /// \param b Middle point.
45 |     /// \param c Last point.
46 |     /// \return Dot product of ab and bc.
47 |     CVBLOB_EXPORT double DotProductPoints(const cv::Point &a, const cv::Point &b, const cv::Point &c);
48 | 
49 |     /// \brief Cross product of the vectors ab and bc.
50 |     /// \param a Point.
51 |     /// \param b Point.
52 |     /// \param c Point.
53 |     /// \return Cross product of ab and bc.
54 |     CVBLOB_EXPORT double CrossProductPoints(const cv::Point &a, const cv::Point &b, const cv::Point &c);
55 | 
56 |     /// \brief Distance between two points.
57 |     /// \param a Point.
58 |     /// \param b Point.
59 |     /// \return Distance.
60 |     CVBLOB_EXPORT double DistancePointPoint(const cv::Point &a, const cv::Point &b);
61 | 
62 |     /// \brief Distance between line ab and point c.
63 |     /// \param a First point of the segment.
64 |     /// \param b Second point of the segment.
65 |     /// \param c Point.
66 |     /// \param isSegment If false then the distance will be calculated from the line defined by the points a and b, to the point c.
67 |     /// \return Distance between ab and c.
68 |     CVBLOB_EXPORT double DistanceLinePoint(const cv::Point &a, const cv::Point &b, const cv::Point &c, bool isSegment=true);
69 | 
70 | } // Namespace
71 | 
72 | #endif // _CVBLOB_AUX_H_


--------------------------------------------------------------------------------
/cvBlob/cvb_blob.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | #include <cmath>
 24 | #include <iostream>
 25 | #include <opencv2/highgui/highgui.hpp>
 26 | #include <opencv2/imgproc.hpp>
 27 | 
 28 | #include "cvb_blob.h"
 29 | 
 30 | using namespace cvb;
 31 | 
 32 | Blob::Blob(cv::Point point, Label label) {
 33 |     this->label = label;
 34 |     this->m00 = 1;
 35 |     this->minx = point.x;
 36 |     this->maxx = point.x;
 37 |     this->miny = point.y;
 38 |     this->maxy = point.y;
 39 |     this->m10 = point.x;
 40 |     this->m01 = point.y;
 41 |     this->m11 = point.x * point.y;
 42 |     this->m20 = point.x * point.x;
 43 |     this->m02 = point.y * point.y;
 44 |     this->contour = Contour(point);
 45 | }
 46 | 
 47 | Blob::Blob(unsigned int min_x, unsigned int max_x, unsigned int y, Label label) {
 48 |     this->label = label;
 49 |     unsigned int n = max_x - min_x + 1;           // Number of items
 50 |     double x_sum = n * (min_x + max_x) / 2.; // Sum from min_x to max_x
 51 | 
 52 |     this->m00 = n;
 53 |     this->minx = min_x;
 54 |     this->maxx = max_x;
 55 |     this->miny = y;
 56 |     this->maxy = y;
 57 | 
 58 |     this->m10 = x_sum;
 59 |     this->m01 = y * n;
 60 |     this->m11 = y * x_sum;
 61 |     this->m02 = y * y * n;
 62 | 
 63 |     double sum_min_sq; // sum of squares from 1 to (min_x - 1)
 64 |     if (min_x == 0)
 65 |         sum_min_sq = 0;
 66 |     else
 67 |         sum_min_sq = (min_x - 1.) * (min_x) * (2. * (min_x - 1.) + 1.) / 6.;
 68 |     double sum_max_sq = max_x * (max_x + 1.) * (2. * max_x + 1.) / 6.; // sum of squares from 1 to max_x
 69 |     this->m20 = sum_max_sq - sum_min_sq; // sum of squares from min_x to max_x
 70 | }
 71 | 
 72 | Contour Blob::get_Contour() const {
 73 |     return this->contour;
 74 | }
 75 | 
 76 | ContoursList Blob::get_InternalContours() const {
 77 |     return this->internalContours;
 78 | }
 79 | 
 80 | cv::Point2d Blob::get_Centroid() const {
 81 |     return centroid;
 82 | }
 83 | 
 84 | double Blob::get_Angle() const {
 85 |     return .5 * atan2(2. * u11, u20 - u02);
 86 | }
 87 | 
 88 | unsigned int Blob::get_Area() const {
 89 |     return m00;
 90 | }
 91 | 
 92 | void Blob::SaveImage(const std::string &filename, const cv::Mat &img) const {
 93 |     cv::imwrite(filename, img(get_BoundingBox()));
 94 | }
 95 | 
 96 | cv::Rect Blob::get_BoundingBox() const {
 97 |     return cv::Rect(minx, miny, maxx - minx + 1, maxy - miny + 1);
 98 | }
 99 | 
100 | void Blob::add_ChainCode(ChainCode chainCode) {
101 |     this->contour.add_ChainCode(chainCode);
102 | }
103 | 
104 | void Blob::add_Moment(unsigned int x, unsigned int y) {
105 |     minx = std::min(x, minx);
106 |     maxx = std::max(x, maxx);
107 |     miny = std::min(y, miny);
108 |     maxy = std::max(y, maxy);
109 | 
110 |     m00++;
111 |     m10 += x;
112 |     m01 += y;
113 |     m11 += x * y;
114 |     m20 += x * x;
115 |     m02 += y * y;
116 | }
117 | 
118 | void Blob::add_Moment(unsigned int min_x, unsigned int max_x, unsigned int y) {
119 |     minx = std::min(min_x, minx);
120 |     maxx = std::max(max_x, maxx);
121 |     miny = std::min(y, miny);
122 |     maxy = std::max(y, maxy);
123 | 
124 |     unsigned int n = max_x - min_x + 1;           // Number of items
125 |     double x_sum = n * (min_x + max_x) / 2.; // Sum from min_x to max_x
126 | 
127 |     m00 += n;
128 |     m10 += x_sum;
129 |     m01 += y * n;
130 |     m11 += y * x_sum;
131 |     m02 += y * y * n;
132 | 
133 |     double sum_min_sq; // sum of squares from 1 to (min_x - 1)
134 |     if (min_x == 0)
135 |         sum_min_sq = 0;
136 |     else
137 |         sum_min_sq = (min_x - 1.) * (min_x) * (2. * (min_x - 1.) + 1.) / 6.;
138 |     double sum_max_sq = max_x * (max_x + 1.) * (2. * max_x + 1.) / 6.; // sum of squares from 1 to max_x
139 |     this->m20 = sum_max_sq - sum_min_sq; // sum of squares from min_x to max_x
140 | }
141 | 
142 | void Blob::add_InternalContour(SharedContour contour) {
143 |     this->internalContours.push_back(contour);
144 | }
145 | 
146 | void Blob::ComputeMoments() {
147 |     centroid = cv::Point2d(m10 / m00, m01 / m00);
148 | 
149 |     u11 = m11 - (m10 * m01) / m00;
150 |     u20 = m20 - (m10 * m10) / m00;
151 |     u02 = m02 - (m01 * m01) / m00;
152 | 
153 |     double m00_2 = m00 * m00;
154 | 
155 |     n11 = u11 / m00_2;
156 |     n20 = u20 / m00_2;
157 |     n02 = u02 / m00_2;
158 | 
159 |     p1 = n20 + n02;
160 | 
161 |     double nn = n20 - n02;
162 |     p2 = nn * nn + 4. * (n11 * n11);
163 | }
164 | 
165 | 
166 | cv::Scalar Blob::get_MeanColor(const cv::Mat &imgLabel, const cv::Mat &img) const {
167 |     CV_Assert(imgLabel.type() == CVB_LABEL && imgLabel.isContinuous());
168 |     CV_Assert(img.type() == CV_8UC3);
169 | 
170 |     // Ensure image is continuous
171 |     cv::Mat imgBlob;
172 |     img(get_BoundingBox()).copyTo(imgBlob);
173 | 
174 |     size_t stepLbl = imgLabel.step1();;
175 |     size_t stepImg = imgBlob.step1();;
176 |     unsigned int imgLabel_width = imgLabel.cols;
177 |     unsigned int imgLabel_height = imgLabel.rows;
178 |     unsigned int imgChan = imgBlob.channels();
179 | 
180 |     Label *labels = (Label *)imgLabel.ptr();
181 |     unsigned char *imgData = (unsigned char *)imgBlob.ptr();
182 | 
183 |     double mb = 0;
184 |     double mg = 0;
185 |     double mr = 0;
186 |     double pixels = (double)get_Area();
187 | 
188 |     for (unsigned int r = 0; r < (unsigned int)imgLabel_height; r++, labels += stepLbl, imgData += stepImg) {
189 |         for (unsigned int c = 0; c < imgLabel_width; c++) {
190 |             if (labels[c] == label) {
191 |                 mb += ((double)imgData[imgChan*c+0]) / pixels; // B
192 |                 mg += ((double)imgData[imgChan*c+1]) / pixels; // G
193 |                 mr += ((double)imgData[imgChan*c+2]) / pixels; // R
194 |             }
195 |         }
196 |     }
197 | 
198 |     /*double mb = 0;
199 |     double mg = 0;
200 |     double mr = 0;
201 |     double pixels = (double)blob->get_Area();
202 |     for (unsigned int y=0; y<imgLabel->height; y++)
203 |         for (unsigned int x=0; x<imgLabel->width; x++) {
204 |             if (cvGetLabel(imgLabel, x, y)==blob->label) {
205 |                 CvScalar color = cvGet2D(imgBlob, y, x);
206 |                 mb += color.val[0]/pixels;
207 |                 mg += color.val[1]/pixels;
208 |                 mr += color.val[2]/pixels;
209 |             }
210 |         }*/
211 | 
212 |     return cv::Scalar(mr, mg, mb);
213 | }
214 | 
215 | 
216 | void Blob::RenderBlob(const cv::Mat &imgLabel, const cv::Mat &imgSource, cv::Mat &imgDest, unsigned short mode, const cv::Scalar &color, double alpha) const {
217 |     CV_Assert(imgLabel.type() == CVB_LABEL && imgLabel.isContinuous());
218 |     CV_Assert(imgSource.type() == CV_8UC3);
219 |     CV_Assert(imgDest.type() == CV_8UC3 && imgDest.size() == imgSource.size() && imgDest.isContinuous());
220 | 
221 |     cv::Mat imgSourceCont;
222 |     if (imgSource.isContinuous())
223 |         imgSourceCont = imgSource;
224 |     else
225 |         imgSource.copyTo(imgSourceCont);
226 | 
227 |     if (mode & CV_BLOB_RENDER_COLOR) {
228 |         size_t stepLbl = imgLabel.step1();;
229 |         size_t stepSrc = imgSourceCont.step1();;
230 |         size_t stepDst = imgDest.step1();;
231 |         unsigned int nbchanSrc = imgSourceCont.channels();
232 |         unsigned int nbchanDst = imgDest.channels();
233 | 
234 |         Label *labels = (Label *)imgLabel.ptr() + (miny * stepLbl);
235 |         unsigned char *source = (unsigned char *)imgSourceCont.ptr() + (miny * stepSrc);
236 |         unsigned char *imgData = (unsigned char *)imgDest.ptr() + (miny * stepDst);
237 | 
238 |         for (unsigned int r = miny; r < maxy; r++, labels += stepLbl, source += stepSrc, imgData += stepDst)
239 |             for (unsigned int c = minx; c < maxx; c++) {
240 |                 if (labels[c] == label) {
241 |                     imgData[nbchanDst*c+0] = (unsigned char)((1.-alpha)*source[nbchanSrc*c+0]+alpha*color.val[0]);
242 |                     imgData[nbchanDst*c+1] = (unsigned char)((1.-alpha)*source[nbchanSrc*c+1]+alpha*color.val[1]);
243 |                     imgData[nbchanDst*c+2] = (unsigned char)((1.-alpha)*source[nbchanSrc*c+2]+alpha*color.val[2]);
244 |                 }
245 |             }
246 |     }
247 | 
248 |     if (mode) {
249 |         if (mode & CV_BLOB_RENDER_TO_LOG) {
250 |             std::clog << "Blob " << label << std::endl;
251 |             std::clog << " - Bounding box: (" << minx << ", " << miny << ") - (" << maxx << ", " << maxy << ")" << std::endl;
252 |             std::clog << " - Bounding box get_Area(): " << (1 + maxx - minx) * (1 + maxy - miny) << std::endl;
253 |             std::clog << " - Area: " << get_Area() << std::endl;
254 |             std::clog << " - Centroid: (" << centroid.x << ", " << centroid.y << ")" << std::endl;
255 |             std::clog << std::endl;
256 |         }
257 | 
258 |         if (mode & CV_BLOB_RENDER_TO_STD) {
259 |             std::cout << "Blob " << label << std::endl;
260 |             std::cout << " - Bounding box: (" << minx << ", " << miny << ") - (" << maxx << ", " << maxy << ")" << std::endl;
261 |             std::cout << " - Bounding box get_Area(): " << (1 + maxx - minx) * (1 + maxy - miny) << std::endl;
262 |             std::cout << " - Area: " << get_Area() << std::endl;
263 |             std::cout << " - Centroid: (" << centroid.x << ", " << centroid.y << ")" << std::endl;
264 |             std::cout << std::endl;
265 |         }
266 | 
267 |         if (mode & CV_BLOB_RENDER_BOUNDING_BOX)
268 |             cv::rectangle(imgDest, cv::Point(minx, miny), cv::Point(maxx-1, maxy-1), CV_RGB(255., 0., 0.));
269 | 
270 |         if (mode & CV_BLOB_RENDER_ANGLE) {
271 |             double angle = get_Angle();
272 | 
273 |             double x1,y1,x2,y2;
274 |             double lengthLine = std::max(maxx-minx, maxy - miny) / 2.;
275 | 
276 |             x1=centroid.x-lengthLine*cos(angle);
277 |             y1=centroid.y-lengthLine*sin(angle);
278 |             x2=centroid.x+lengthLine*cos(angle);
279 |             y2=centroid.y+lengthLine*sin(angle);
280 |             cv::line(imgDest, cv::Point(int(x1), int(y1)), cv::Point(int(x2), int(y2)), CV_RGB(0.,255.,0.));
281 |         }
282 | 
283 |         if (mode & CV_BLOB_RENDER_CENTROID) {
284 |             cv::line(imgDest,
285 |                 cv::Point(int(centroid.x) - 3, int(centroid.y)),
286 |                 cv::Point(int(centroid.x) + 3, int(centroid.y)),
287 |                 CV_RGB(0.,0.,255.));
288 |             cv::line(imgDest,
289 |                 cv::Point(int(centroid.x), int(centroid.y) - 3),
290 |                 cv::Point(int(centroid.x), int(centroid.y) + 3),
291 |                 CV_RGB(0.,0.,255.));
292 |         }
293 |     }
294 | 
295 | }
296 | 
297 | void Blob::Print(std::ostream &out) const {
298 |     out << label << ": " << get_Area() << ", (" << centroid.x << ", " << centroid.y << "), [(" << minx << ", " << miny << ") - (" << maxx << ", " << maxy << ")]";
299 | }
300 | 
301 | void Blob::Merge(Blob &a_blob) {
302 |     label = std::min(label, a_blob.label);
303 |     minx = std::min(a_blob.minx, minx);
304 |     maxx = std::max(a_blob.maxx, maxx);
305 |     miny = std::min(a_blob.miny, miny);
306 |     maxy = std::max(a_blob.maxy, maxy);
307 | 
308 |     m00 += a_blob.m00;
309 |     m10 += a_blob.m10;
310 |     m01 += a_blob.m01;
311 |     m11 += a_blob.m11;
312 |     m20 += a_blob.m20;
313 |     m02 += a_blob.m02;
314 | }
315 | 
316 | std::ostream &operator<< (std::ostream &output, const Blob &b) {
317 |     b.Print(output);
318 |     return output;
319 | }
320 | 


--------------------------------------------------------------------------------
/cvBlob/cvb_blob.h:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | /// \file cvb_blob.h
 24 | /// \brief OpenCV Blob header file.
 25 | 
 26 | #ifdef SWIG
 27 | %module cvblob
 28 |     %{
 29 | #include "cvb_blob.h"
 30 |         %}
 31 | #endif
 32 | 
 33 | #ifndef _CVBLOB_BLOB_H_
 34 | #define _CVBLOB_BLOB_H_
 35 | 
 36 | #include <iostream>
 37 | #include <cstdint>
 38 | #include <memory>
 39 | 
 40 | #include <opencv2/core/core.hpp>
 41 | 
 42 | #include "cvb_contour.h"
 43 | #include "cvb_defines.h"
 44 | 
 45 | #define CV_BLOB_RENDER_COLOR            0x0001 ///< Render each blog with a different color. \see RenderBlob
 46 | #define CV_BLOB_RENDER_CENTROID         0x0002 ///< Render centroid. \see RenderBlob
 47 | #define CV_BLOB_RENDER_BOUNDING_BOX     0x0004 ///< Render bounding box. \see RenderBlob
 48 | #define CV_BLOB_RENDER_ANGLE            0x0008 ///< Render angle. \see RenderBlob
 49 | #define CV_BLOB_RENDER_TO_LOG           0x0010 ///< Print blob data to log out. \see RenderBlob
 50 | #define CV_BLOB_RENDER_TO_STD           0x0020 ///< Print blob data to std out. \see RenderBlob
 51 | 
 52 | namespace cvb {
 53 | 
 54 |     /// \brief Type of Label.
 55 |     typedef uint8_t Label;
 56 | #define CVB_LABEL CV_8UC1
 57 | 
 58 |     /// \brief Class that contains information about one blob.
 59 |     class CVBLOB_EXPORT Blob {
 60 |     public:
 61 |         /// \brief Constructor, with one dot.
 62 |         /// \param point   The blob first point.
 63 |         /// \param name    The blob label.
 64 |         Blob(cv::Point point, Label label);
 65 | 
 66 |         /// \brief Constructor, with one line.
 67 |         /// \param min_x   The line first point X-coordinate.
 68 |         /// \param max_x   The line last point X-coordinate.
 69 |         /// \param y       The line Y-coordinate.
 70 |         /// \param name    The blob label.
 71 |         Blob(unsigned int min_x, unsigned int max_x, unsigned int y, Label label);
 72 | 
 73 |         Label label; ///< Label.
 74 | 
 75 |         /// \brief  Gets the contour.
 76 |         /// \returns   The contour.
 77 |         Contour get_Contour() const;
 78 | 
 79 |         /// \brief Gets a copy of the internal contours.
 80 |         /// \return The internal contours.
 81 |         ContoursList get_InternalContours() const;
 82 | 
 83 |         /// \brief Gets the centroid.
 84 |         /// \return The Centroid.
 85 |         cv::Point2d get_Centroid() const;
 86 | 
 87 |         /// \brief Calculates angle orientation of a blob.
 88 |         /// \return Angle orientation in radians.
 89 |         double get_Angle() const;
 90 | 
 91 |         /// \brief Gets the blob area.
 92 |         /// \return The blob area.
 93 |         unsigned int get_Area() const;
 94 | 
 95 |         /// \brief Gets the blob bounding box.
 96 |         /// \return The blob bounding box.
 97 |         cv::Rect get_BoundingBox() const;
 98 | 
 99 |         /// \brief Adds a chain code to the blob contour.
100 |         /// \param chainCode The chain code to be added.
101 |         void add_ChainCode(ChainCode chainCode);
102 | 
103 |         /// \brief Adds a point to the blob moments.
104 |         /// \param x X-coordinate of the point.
105 |         /// \param y Y-coordinate of the point.
106 |         void add_Moment(unsigned int x, unsigned int y);
107 | 
108 |         /// \brief Adds a line the the blob moments.
109 |         /// \param min_x   The line first point X-coordinate.
110 |         /// \param max_x   The line last point X-coordinate.
111 |         /// \param y       The line Y-coordinate.
112 |         void add_Moment(unsigned int min_x, unsigned int max_x, unsigned int y);
113 | 
114 |         /// \brief Adds a contour to the internal contours list.
115 |         /// \param contour The contour to be added.
116 |         void add_InternalContour(SharedContour contour);
117 | 
118 |         /// \brief Computes the central, normalized central and hu moments,
119 |         /// along with the centroid.
120 |         void ComputeMoments();
121 | 
122 |         /// \brief Calculates mean color of a blob in an image.
123 |         /// \param imgLabel Image of labels.
124 |         /// \param img Original image.
125 |         /// \return Average color.
126 |         cv::Scalar get_MeanColor(const cv::Mat &imgLabel, const cv::Mat &img) const;
127 | 
128 |         /// \brief Draws or prints information about a blob.
129 |         /// \param imgLabel Label image (type = CV_16UC3 and continuous).
130 |         /// \param imgSource Input image (type = CV_8UC3).
131 |         /// \param imgDest Output image (type = CV_8UC3 and size identical to imgSource and continuous ).
132 |         /// \param mode Render mode. By default is CV_BLOB_RENDER_COLOR|CV_BLOB_RENDER_CENTROID|CV_BLOB_RENDER_BOUNDING_BOX|CV_BLOB_RENDER_ANGLE.
133 |         /// \param color Color to render (if CV_BLOB_RENDER_COLOR is used).
134 |         /// \param alpha If mode CV_BLOB_RENDER_COLOR is used. 1.0 indicates opaque and 0.0 translucent (1.0 by default).
135 |         /// \see CV_BLOB_RENDER_COLOR
136 |         /// \see CV_BLOB_RENDER_CENTROID
137 |         /// \see CV_BLOB_RENDER_BOUNDING_BOX
138 |         /// \see CV_BLOB_RENDER_ANGLE
139 |         /// \see CV_BLOB_RENDER_TO_LOG
140 |         /// \see CV_BLOB_RENDER_TO_STD
141 |         void RenderBlob(const cv::Mat &imgLabel, const cv::Mat &imgSource, cv::Mat &imgDest, unsigned short mode = 0x000f, cv::Scalar const &color = cv::Scalar(255, 255, 255), double alpha = 1.) const;
142 | 
143 |         /// \brief Save the image of a blob to a file.
144 |         /// The function uses an image (that can be the original pre-processed image or a processed one, or even the result of cvRenderBlobs, for example).
145 |         /// Then the function saves a copy of the part of the image where the blob is.
146 |         /// \param filename Name of the file.
147 |         /// \param img Image.
148 |         void SaveImage(const std::string &filename, const cv::Mat &img) const;
149 | 
150 |         /// \brief Prints the data to the out stream
151 |         /// \param out The output stream
152 |         void Print(std::ostream &out) const;
153 | 
154 |         /// \brief Merges this blob with a_blob. </summary>
155 |         /// \param The blob to merge with. </param>
156 |         void Merge(Blob &a_blob);
157 | 
158 |     protected:
159 |         unsigned int minx; ///< X min.
160 |         unsigned int maxx; ///< X max.
161 |         unsigned int miny; ///< Y min.
162 |         unsigned int maxy; ///< Y max.
163 | 
164 |         unsigned int m00; ///< Moment 00 (area)
165 |         double m01; ///< Moment 01.
166 |         double m10; ///< Moment 10.
167 |         double m11; ///< Moment 11.
168 |         double m02; ///< Moment 02.
169 |         double m20; ///< Moment 20.
170 | 
171 |         double u11; ///< Central moment 11.
172 |         double u20; ///< Central moment 20.
173 |         double u02; ///< Central moment 02.
174 | 
175 |         double n11; ///< Normalized central moment 11.
176 |         double n20; ///< Normalized central moment 20.
177 |         double n02; ///< Normalized central moment 02.
178 | 
179 |         double p1; ///< Hu moment 1.
180 |         double p2; ///< Hu moment 2.
181 | 
182 |         cv::Point2d centroid;          ///< Centroid.
183 |         Contour contour;               ///< Contour.
184 |         ContoursList internalContours; ///< Internal contours.
185 |     };
186 | 
187 |     typedef std::shared_ptr<Blob> SharedBlob; ///< Shared Blob type
188 | 
189 |     /// \brief Overload operator "<<" for printing blob structure.
190 |     /// \return Stream.
191 |     CVBLOB_EXPORT std::ostream &operator<< (std::ostream &output, const Blob &b);
192 | 
193 | } // Namespace
194 | 
195 | #endif // _CVBLOB_BLOB_H_
196 | 


--------------------------------------------------------------------------------
/cvBlob/cvb_blob_list.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | #include <cmath>
 24 | #include <iostream>
 25 | #include <sstream>
 26 | 
 27 | #include <opencv2/highgui/highgui.hpp>
 28 | 
 29 | #include "cvb_blob_list.h"
 30 | 
 31 | using namespace cvb;
 32 | 
 33 | namespace {
 34 |     const Label MaxLabel = std::numeric_limits<Label>::max();
 35 | }
 36 | 
 37 | const std::tuple<cv::Point, unsigned char, ChainCode> movesE[4][3] =
 38 | {
 39 |     { std::make_tuple(cv::Point(-1, -1), 3, ChainCode_up_left),    std::make_tuple(cv::Point( 0, -1), 0, ChainCode_up),    std::make_tuple(cv::Point( 1, -1), 0, ChainCode_up_right)   },
 40 |     { std::make_tuple(cv::Point( 1, -1), 0, ChainCode_up_right),   std::make_tuple(cv::Point( 1,  0), 1, ChainCode_right), std::make_tuple(cv::Point( 1,  1), 1, ChainCode_down_right) },
 41 |     { std::make_tuple(cv::Point( 1,  1), 1, ChainCode_down_right), std::make_tuple(cv::Point( 0,  1), 2, ChainCode_down),  std::make_tuple(cv::Point(-1,  1), 2, ChainCode_down_left)  },
 42 |     { std::make_tuple(cv::Point(-1,  1), 2, ChainCode_down_left),  std::make_tuple(cv::Point(-1,  0), 3, ChainCode_left),  std::make_tuple(cv::Point(-1, -1), 3, ChainCode_up_left)    }
 43 | };
 44 | 
 45 | const std::tuple<cv::Point, unsigned char, ChainCode> movesI[4][3] =
 46 | { 
 47 |     { std::make_tuple(cv::Point( 1, -1), 3, ChainCode_up_right),   std::make_tuple(cv::Point( 0, -1), 0, ChainCode_up),    std::make_tuple(cv::Point(-1, -1), 0, ChainCode_up_left)    },
 48 |     { std::make_tuple(cv::Point(-1, -1), 0, ChainCode_up_left),    std::make_tuple(cv::Point(-1,  0), 1, ChainCode_left),  std::make_tuple(cv::Point(-1,  1), 1, ChainCode_down_left)  },
 49 |     { std::make_tuple(cv::Point(-1,  1), 1, ChainCode_down_left),  std::make_tuple(cv::Point( 0,  1), 2, ChainCode_down),  std::make_tuple(cv::Point(1 ,  1), 2, ChainCode_down_right) },
 50 |     { std::make_tuple(cv::Point( 1,  1), 2, ChainCode_down_right), std::make_tuple(cv::Point( 1,  0), 3, ChainCode_right), std::make_tuple(cv::Point( 1, -1), 3, ChainCode_up_right)   }
 51 | };
 52 | 
 53 | BlobList::BlobList() {
 54 | }
 55 | 
 56 | void BlobList::SimpleLabel(const cv::Mat &img, Label max_label) {
 57 |     CV_Assert(img.type() == CV_8UC1);
 58 | 
 59 |     // Reset
 60 |     blobs.clear();
 61 |     imgLabel = cv::Mat::zeros(img.size(), CVB_LABEL);
 62 | 
 63 |     // Do nothing if image is empty
 64 |     if (img.rows == 0)
 65 |         return;
 66 | 
 67 |     // Ensure matrix is continuous
 68 |     cv::Mat imgInCont;
 69 |     if (img.isContinuous())
 70 |         imgInCont = img;
 71 |     else
 72 |         img.copyTo(imgInCont);
 73 | 
 74 |     Label label = 0;
 75 |     BlobsMap blob_map;
 76 | 
 77 |     unsigned char *imgInBuff = (unsigned char*) imgInCont.ptr();
 78 |     size_t stepIn = imgInCont.step1();
 79 |     auto imageIn = [&imgInBuff, &stepIn] (int x, int y) -> unsigned char& {
 80 |         return imgInBuff[x + y * stepIn];
 81 |     };
 82 | 
 83 |     Label *imgOutBuff = (Label *) imgLabel.ptr();
 84 |     size_t stepOut = imgLabel.step1();
 85 |     auto imageOut = [&imgOutBuff, &stepOut] (int x, int y) -> Label& {
 86 |         return imgOutBuff[x + y * stepOut];
 87 |     };
 88 | 
 89 |     for (int y = 0; y < img.rows; y++) {
 90 |         for (int x = 0; x < img.cols; x++) {
 91 |             // Nothing to label
 92 |             if (!imageIn(x, y))
 93 |                 continue;
 94 | 
 95 |             Label l = 0;
 96 |             SharedBlob blob;
 97 | 
 98 |             // Get the whole line
 99 |             int begin_x = x;     // Beginning of internal blob line
100 |             int end_x = begin_x; // End of internal blob line
101 |             BlobsMap prev_blobs; // Blobs on previous line
102 |             while (end_x != img.cols && imageIn(end_x, y)) {
103 |                 if (y != 0 && (l = imageOut(end_x, y -1))) {
104 |                     if (prev_blobs.find(l) == prev_blobs.end())
105 |                         prev_blobs.insert(*blob_map.find(l));
106 |                 }
107 |                 end_x++;
108 |             }
109 |             x = end_x;
110 | 
111 |             if (prev_blobs.empty()) {
112 |                 // New blob
113 |                 label++;
114 |                 if (label >= max_label)
115 |                     goto SimpleBlobEnd;
116 |                 l = label;
117 |                 blob = SharedBlob(new Blob(begin_x, end_x - 1, y, label));
118 |                 blob_map.insert(blob_map.end(), LabelBlob(label, blob));
119 |             } else {
120 |                 SharedBlob blob = prev_blobs.begin()->second;
121 | 
122 |                 if (prev_blobs.size() > 1)  {
123 |                     // Merge blobs
124 |                     for (auto &a_blob : prev_blobs) {
125 |                         if (blob == a_blob.second)
126 |                             continue;
127 |                         blob->Merge(*a_blob.second.get());
128 |                         blob_map.at(a_blob.second->label) = blob;
129 |                     }
130 |                 }
131 |                 l = blob->label;
132 |                 blob->add_Moment(begin_x, end_x - 1, y);
133 |             }
134 | 
135 |             // Label line
136 |             for (int i_x = begin_x; i_x < end_x; i_x++) {
137 |                 imageOut(i_x, y) = l;
138 |             }
139 |         }
140 |     }
141 | 
142 | SimpleBlobEnd:
143 |     // Remove duplicates
144 |     BlobsMap new_map;
145 |     for (auto &a_blob : blob_map) {
146 |         if (new_map.find(a_blob.second->label) != new_map.end())
147 |             continue;
148 |         new_map.insert(LabelBlob(a_blob.second->label, a_blob.second));
149 |     }
150 | 
151 |     // Generate final list
152 |     for (auto &a_blob : new_map) {
153 |         blobs.push_back(a_blob.second);
154 |         a_blob.second->ComputeMoments();
155 |     }
156 | }
157 | 
158 | void BlobList::LabelImage (const cv::Mat &img, Label max_label) {
159 |     CV_Assert(img.type() == CV_8UC1);
160 | 
161 | 
162 |     // Reset
163 |     blobs.clear();
164 |     imgLabel = cv::Mat::zeros(img.size(), CVB_LABEL);
165 |     // Ensure matrix is continuous
166 |     cv::Mat imgInCont;
167 |     if (img.isContinuous())
168 |         imgInCont = img;
169 |     else
170 |         img.copyTo(imgInCont);
171 | 
172 |     Label label = 0;
173 | 
174 |     unsigned int imgIn_width = imgInCont.cols;
175 |     unsigned int imgIn_height = imgInCont.rows;
176 | 
177 |     Label lastLabel = 0;
178 |     SharedBlob lastBlob;
179 |     BlobsMap blob_map;
180 | 
181 |     unsigned char *imgInBuff = (unsigned char*) imgInCont.ptr();
182 |     size_t stepIn = imgInCont.step1();
183 |     auto imageIn = [&imgInBuff, &stepIn] (int x, int y) -> unsigned char& {
184 |         return imgInBuff[x + y * stepIn];
185 |     };
186 | 
187 |     Label *imgOutBuff = (Label *) imgLabel.ptr();
188 |     size_t stepOut = imgLabel.step1();
189 |     auto imageOut = [&imgOutBuff, &stepOut] (int x, int y) -> Label& {
190 |         return imgOutBuff[x + y * stepOut];
191 |     };
192 | 
193 |     for (unsigned int y = 0; y < imgIn_height; y++) {
194 |         for (unsigned int x = 0; x < imgIn_width; x++) {
195 |             // Ignore if input is 0
196 |             if (!imageIn(x, y))
197 |                 continue;
198 | 
199 |             bool labelled = imageOut(x, y) != 0;
200 |             if (labelled)
201 |                 continue;
202 | 
203 |             if (y == 0 || !imageIn(x, y - 1)) {
204 |                 // Not labelled and previous element wasn't 0
205 |                 // Label contour.
206 |                 labelled = true;
207 |                 label++;
208 | 
209 |                 if (label >= max_label)
210 |                     goto LabelEnd;
211 |                 imageOut(x, y) = label;
212 | 
213 |                 // XXX This is not necessary at all. I only do this for consistency.
214 |                 if (y > 0)
215 |                     imageOut(x, y - 1) = MaxLabel;
216 | 
217 |                 // Create new blob.
218 |                 SharedBlob blob(new Blob(cv::Point(x, y), label));
219 |                 blob_map.insert(LabelBlob(label, blob));
220 |                 lastLabel = label;
221 |                 lastBlob = blob;
222 | 
223 |                 // Now, to find the contour.
224 |                 unsigned char direction = 1;
225 |                 unsigned int xx = x;
226 |                 unsigned int yy = y;
227 |                 bool contourEnd = false;
228 | 
229 |                 while (!contourEnd) {
230 |                     bool found = false;
231 | 
232 |                     for (unsigned char i = 0; i < 3; i++) {
233 |                         // Move to the direction
234 |                         int nx = xx + std::get<0>(movesE[direction][i]).x;
235 |                         int ny = yy + std::get<0>(movesE[direction][i]).y;
236 | 
237 |                         // Boundaries check
238 |                         if (nx < 0 || ny < 0 )
239 |                             continue;
240 |                         if (static_cast<unsigned>(nx) >= imgIn_width ||
241 |                             static_cast<unsigned>(ny) >= imgIn_height)
242 |                           continue;
243 | 
244 |                         if (!imageIn(nx, ny)) {
245 |                             imageOut(nx, ny) = MaxLabel;
246 |                             continue;
247 |                         }
248 | 
249 |                         // Found the next part of the blob contour
250 |                         found = true;
251 |                         blob->add_ChainCode(std::get<2>(movesE[direction][i]));
252 |                         xx = nx;
253 |                         yy = ny;
254 |                         if (imageOut(xx, yy) != label) {
255 |                             imageOut(xx, yy) = label;
256 |                             blob->add_Moment(xx, yy);
257 |                         }
258 |                         direction = std::get<1>(movesE[direction][i]);
259 |                         break;
260 |                     }
261 | 
262 | 
263 |                     if (!found)
264 |                         // New direction
265 |                         direction = (direction + 1) % 4;
266 |                     // Check if we went full circle
267 |                     contourEnd = ((xx == x) && (yy == y) && (direction == 1));
268 |                 } // while (!ContourEnd)
269 |                 continue;
270 |             } // if ((!labelled) && ((y == 0) || (!imageIn(x, y-1))))
271 | 
272 | 
273 |             if ((y + 1 < imgIn_height) && (!imageIn(x, y + 1)) && (!imageOut(x, y + 1))) {
274 |                 // We're in a "hole" inside the blob
275 |                 labelled = true;
276 | 
277 |                 // Label internal contour
278 |                 Label l;
279 |                 SharedBlob blob;
280 | 
281 |                 l = imageOut(x - 1, y);
282 |                 imageOut(x, y) = l;
283 | 
284 |                 if (l == lastLabel)
285 |                     blob = lastBlob;
286 |                 else {
287 |                     blob = blob_map.find(l)->second;
288 |                     lastLabel = l;
289 |                     lastBlob = blob;
290 |                 }
291 | 
292 |                 if (!imageOut(x, y))
293 |                     blob->add_Moment(x, y);
294 | 
295 | 
296 |                 // XXX This is not necessary (I believe). I only do this for consistency.
297 |                 imageOut(x, y + 1) = MaxLabel;
298 | 
299 |                 SharedContour contour(new Contour(cv::Point(x, y), ChainCodes()));
300 | 
301 |                 unsigned char direction = 3;
302 |                 unsigned int xx = x;
303 |                 unsigned int yy = y;
304 |                 bool contourEnd = false;
305 | 
306 |                 while (!contourEnd) {
307 |                     bool found = false;
308 | 
309 |                     for (unsigned char i = 0; i < 3; i++) {
310 |                         // Move to the direction
311 |                         int nx = xx + std::get<0>(movesI[direction][i]).x;
312 |                         int ny = yy + std::get<0>(movesI[direction][i]).y;
313 | 
314 |                         // Boundaries check
315 |                         if (nx < 0 || ny < 0)
316 |                           continue;
317 |                         if (static_cast<unsigned>(nx) >= imgIn_width ||
318 |                             static_cast<unsigned>(ny) >= imgIn_height)
319 |                           continue;
320 | 
321 |                         if (!imageIn(nx, ny)) {
322 |                             imageOut(nx, ny) = MaxLabel;
323 |                             continue;
324 |                         }
325 | 
326 |                         // Found the next part of the internal contour
327 |                         found = true;
328 |                         contour->add_ChainCode(std::get<2>(movesI[direction][i]));
329 |                         xx = nx;
330 |                         yy = ny;
331 |                         if (!imageOut(xx, yy)) {
332 |                             imageOut(xx, yy) = l;
333 |                             blob->add_Moment(xx, yy);
334 |                         }
335 |                         direction = std::get<1>(movesI[direction][i]);
336 |                         // Check if we went full circle
337 |                         contourEnd = (xx == x) && (yy == y);
338 |                         break;
339 |                     }
340 | 
341 |                     if (!found)
342 |                         // New direction
343 |                         direction = (direction + 1) % 4;
344 |                 } // while (!contourEnd)
345 | 
346 |                 // Finally, add the internal contour
347 |                 blob->add_InternalContour(contour);
348 |                 continue;
349 |             } // if ((y + 1 < imgIn_height) && (!imageIn(x, y + 1)) && (!imageOut(x, y + 1)))
350 | 
351 |             //else, element is not labelled
352 |             // Internal pixel
353 |             Label l = imageOut(x - 1, y);
354 | 
355 |             imageOut(x, y) = l;
356 | 
357 |             SharedBlob blob;
358 |             if (l == lastLabel)
359 |                 blob = lastBlob;
360 |             else {
361 |                 blob = blob_map.find(l)->second;
362 |                 lastLabel = l;
363 |                 lastBlob = blob;
364 |             }
365 |             blob->add_Moment(x, y);
366 |         }
367 |     }
368 | 
369 | LabelEnd:
370 |     // Populate list
371 |     for (auto &a_blob : blob_map) {
372 |         blobs.push_back(a_blob.second);
373 |         a_blob.second->ComputeMoments();
374 |     }
375 | 
376 | }
377 | 
378 | void BlobList::FilterLabels(cv::Mat &imgOut) const {
379 |     CV_Assert(imgOut.type() == CV_8UC1 && imgOut.isContinuous());
380 | 
381 |     size_t stepIn = imgLabel.step1();
382 |     size_t stepOut = imgOut.step1();
383 |     int imgIn_width = imgLabel.cols;
384 |     int imgIn_height = imgLabel.rows;
385 | 
386 |     char *imgDataOut = (char *) imgOut.ptr();
387 |     Label *imgDataIn=(Label *)imgLabel.ptr();
388 | 
389 |     // FIXME This is inefficient.
390 |     // We should first zero out the matrix
391 |     // Then get a list of the labels currently in the blobs list and draw them
392 |     // 
393 |     // FIXME This won't work with simplelabel, due to different labelling for one single blob
394 | 
395 |     for (unsigned int r = 0; r < (unsigned int)imgIn_height; r++, imgDataIn += stepIn, imgDataOut += stepOut) {
396 |         for (unsigned int c = 0; c < (unsigned int)imgIn_width; c++) {
397 |             Label l = imgDataIn[c];
398 |             if (l) {
399 |                 // Find the blob and draw it
400 |                 SharedBlob the_blob;
401 |                 for (auto &a_blob : blobs)
402 |                     if (a_blob->label == l)
403 |                         the_blob = a_blob;
404 |                 if (the_blob.get() == nullptr)
405 |                     imgDataOut[c] = 0x00;
406 |                 else
407 |                     imgDataOut[c] = (char)0xff;
408 |             }
409 |             else
410 |                 imgDataOut[c] = 0x00;
411 |         }
412 |     }
413 | }
414 | 
415 | std::list<SharedBlob> BlobList::get_BlobsList() const {
416 |     return this->blobs;
417 | }
418 | 
419 | cv::Mat BlobList::get_ImageLabel() const {
420 |     return this->imgLabel;
421 | }
422 | 
423 | Label BlobList::GetLabel(unsigned int x, unsigned int y) const {
424 |     size_t step = imgLabel.step1();
425 |     unsigned int img_width = imgLabel.cols;
426 |     unsigned int img_height= imgLabel.rows;
427 | 
428 |     CV_Assert((x < img_width) && (y < img_height));
429 | 
430 |     return ((Label *)(imgLabel.ptr()))[x + y * step];
431 | }
432 | 
433 | 
434 | SharedBlob BlobList::get_LargestBlob() const {
435 |     unsigned int maxArea = 0;
436 |     SharedBlob outBlob;
437 | 
438 |     for (auto &a_blob : blobs) {
439 |         if (a_blob->get_Area() > maxArea) {
440 |             maxArea = a_blob->get_Area();
441 |             outBlob = a_blob;
442 |         }
443 |     }
444 | 
445 |     return outBlob;
446 | }
447 | 
448 | void BlobList::FilterByArea(unsigned int minArea, unsigned int maxArea) {
449 |     auto it = blobs.begin();
450 |     while(it != blobs.end()) {
451 |         auto &blob = *it;
452 | 
453 |         if ((blob->get_Area() < minArea) || (blob->get_Area() > maxArea)) {
454 |             auto tmp = it;
455 |             ++it;
456 |             blobs.erase(tmp);
457 |         } else
458 |             ++it;
459 |     }
460 | }
461 | 
462 | void BlobList::FilterByLabel(Label label) {
463 |     auto it = blobs.begin();
464 |     while(it != blobs.end()) {
465 |         auto &blob = *it;
466 | 
467 |         if (blob->label != label) {
468 |             auto &tmp = it;
469 |             ++it;
470 |             blobs.erase(tmp);
471 |         } else
472 |             ++it;
473 |     }
474 | }
475 | 
476 | /*void cvCentralMoments(CvBlob *blob, const cv::Mat &img) {
477 | if (!blob->centralMoments)
478 | {
479 | CV_Assert(img&&(img->depth()==IPL_DEPTH_LABEL)&&(img->nChannels==1));
480 | 
481 | //cvCentroid(blob); // Here?
482 | 
483 | blob->u11=blob->u20=blob->u02=0.;
484 | 
485 | // Only in the bounding box
486 | int stepIn = img->widthStep / (img->depth() / 8);
487 | int img_width = img.cols;
488 | int img_height = img.rows;
489 | int img_offset = 0;
490 | if(0 != img->roi) {
491 | img_width = img->roi.cols;
492 | img_height = img->roi.rows;
493 | img_offset = img->roi->xOffset + (img->roi->yOffset * stepIn);
494 | }
495 | 
496 | Label *imgData=(Label *)img.ptr() + (blob->miny * stepIn) + img_offset;
497 | for (unsigned int r=blob->miny;
498 | r<blob->maxy;
499 | r++,imgData+=stepIn)
500 | for (unsigned int c=blob->minx;c<blob->maxx;c++)
501 | if (imgData[c]==blob->label) {
502 | double tx=(c-blob->centroid.x);
503 | double ty=(r-blob->centroid.y);
504 | blob->u11+=tx*ty;
505 | blob->u20+=tx*tx;
506 | blob->u02+=ty*ty;
507 | }
508 | 
509 | blob->centralMoments = true;
510 | }
511 | }*/
512 | 
513 | 
514 | ///////////////////////////////////////////////////////////////////////////////////////////////////
515 | // Based on http://en.wikipedia.org/wiki/HSL_and_HSV
516 | 
517 | /// \def HSV2RGB(H, S, V, R, G, B)
518 | /// \brief Color translation between HSV and RGB.
519 | inline void HSV2RGB (double H, double S, double V, double &R, double &G, double &B) {
520 |     double _h = H/60.;
521 |     int _hf = (int)floor(_h);
522 |     int _hi = ((int)_h)%6;
523 |     double _f = _h - _hf;
524 | 
525 |     double _p = V * (1. - S);
526 |     double _q = V * (1. - _f * S);
527 |     double _t = V * (1. - (1. - _f) * S);
528 | 
529 |     switch (_hi) {
530 |     case 0:
531 |         R = 255.*V; G = 255.*_t; B = 255.*_p;
532 |         break;
533 |     case 1:
534 |         R = 255.*_q; G = 255.*V; B = 255.*_p;
535 |         break;
536 |     case 2:
537 |         R = 255.*_p; G = 255.*V; B = 255.*_t;
538 |         break;
539 |     case 3:
540 |         R = 255.*_p; G = 255.*_q; B = 255.*V;
541 |         break;
542 |     case 4:
543 |         R = 255.*_t; G = 255.*_p; B = 255.*V;
544 |         break;
545 |     case 5:
546 |         R = 255.*V; G = 255.*_p; B = 255.*_q;
547 |         break;
548 |     }
549 | }
550 | 
551 | void BlobList::RenderBlobs(const cv::Mat &imgSource, cv::Mat &imgDest, unsigned short mode, double alpha) const {
552 |     typedef std::map<Label, cv::Scalar> Palete;
553 | 
554 |     CV_Assert(imgSource.type() == CV_8UC3);
555 |     CV_Assert(imgDest.type() == CV_8UC3 && imgDest.size() == imgSource.size() && imgDest.isContinuous());
556 | 
557 |     Palete pal;
558 |     if (mode & CV_BLOB_RENDER_COLOR) {
559 | 
560 |         unsigned int colorCount = 0;
561 |         for (auto &a_blob : blobs) {
562 |             auto &label = a_blob->label;
563 | 
564 |             double r, g, b;
565 | 
566 |             HSV2RGB((double)((colorCount*77)%360), .5, 1., r, g, b);
567 |             colorCount++;
568 | 
569 |             pal[label] = cv::Scalar(r, g, b);
570 |         }
571 |     }
572 | 
573 |     for (auto &a_blob : blobs)
574 |         a_blob->RenderBlob(imgLabel, imgSource, imgDest, mode, pal[a_blob->label], alpha);
575 | }
576 | 
577 | 
578 | 


--------------------------------------------------------------------------------
/cvBlob/cvb_blob_list.h:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | /// \file cvb_blob_list.h
 24 | /// \brief OpenCV Blob List header file.
 25 | 
 26 | #ifdef SWIG
 27 | %module cvblob
 28 |     %{
 29 | #include "cvb_blob_list.h"
 30 |         %}
 31 | #endif
 32 | 
 33 | #ifndef _CVBLOB_BLOB_LIST_H_
 34 | #define _CVBLOB_BLOB_LIST_H_
 35 | 
 36 | #include <map>
 37 | #include <list>
 38 | #include <vector>
 39 | #include <limits>
 40 | 
 41 | #include "cvb_blob.h"
 42 | #include "cvb_defines.h"
 43 | 
 44 | namespace cvb {
 45 | 
 46 |     /// \brief List of blobs.
 47 |     /// A map is used to access each blob from its label number.
 48 |     /// \see Label
 49 |     /// \see CvBlob
 50 |     typedef std::map<Label, SharedBlob> BlobsMap;
 51 | 
 52 |     /// \brief Pair (label, blob).
 53 |     /// \see Label
 54 |     /// \see CvBlob
 55 |     typedef std::pair<Label, SharedBlob> LabelBlob;
 56 | 
 57 |     /// \brief Class defining a list of blobs, along with labelling
 58 |     class CVBLOB_EXPORT BlobList {
 59 |     public:
 60 |         BlobList(); ///< Default constructor.
 61 | 
 62 |         /// \brief Label the connected parts of a binary image.
 63 |         /// Simple, fast algorithm. Does not compute contours.
 64 |         /// \param img Input binary image (type = CV_8UC1).
 65 |         void SimpleLabel(const cv::Mat &img, Label max_label);
 66 | 
 67 |         /// \brief Label the connected parts of a binary image.
 68 |         /// Algorithm based on paper "A linear-time component-labeling algorithm using contour tracing technique" of Fu Chang, Chun-Jen Chen and Chi-Jen Lu.
 69 |         /// \param img Input binary image (type = CV_8UC1).
 70 |         void LabelImage (const cv::Mat &img, Label max_label);
 71 | 
 72 |         /// \brief Draw a binary image with the blobs.
 73 |         /// \param imgOut Output binary image (type = CV8UC1 and continuous).
 74 |         void FilterLabels(cv::Mat &imgOut) const;
 75 | 
 76 |         /// \brief Gets a copy of the blobs list.
 77 |         /// \return The blobs list.
 78 |         std::list<SharedBlob> get_BlobsList() const;
 79 | 
 80 |         /// \brief Gets the labelled picture.
 81 |         /// \return The labelled picture.
 82 |         cv::Mat get_ImageLabel() const;
 83 | 
 84 |         /// \brief Gets the label at coordinates (x, y)
 85 |         /// \param x X coordinate.
 86 |         /// \param y Y coordinate.
 87 |         /// \return Label value.
 88 |         Label GetLabel(unsigned int x, unsigned int y) const;
 89 | 
 90 |         /// \brief Find largest blob (biggest area).
 91 |         /// \return Largest blob, empty if no blob computed.
 92 |         SharedBlob get_LargestBlob() const;
 93 | 
 94 |         /// \brief Filter blobs by area.
 95 |         /// Those blobs whose areas are not in range will be erased from the internal list of blobs.
 96 |         /// \param minArea Minimun area.
 97 |         /// \param maxArea Maximun area.
 98 |         void FilterByArea(unsigned int minArea, unsigned int maxArea = std::numeric_limits<unsigned int>::max());
 99 | 
100 |         /// \brief Filter blobs by label.
101 |         /// Delete all blobs except those with label l.
102 |         /// \param label Label to leave.
103 |         void FilterByLabel(Label label);
104 | 
105 |         /// \brief Draws or prints information about blobs.
106 |         /// \param imgSource Input image (type = CV_8UC3).
107 |         /// \param imgDest Output image (type = CV_8UC3 and is continuous).
108 |         /// \param mode Render mode. By default is CV_BLOB_RENDER_COLOR|CV_BLOB_RENDER_CENTROID|CV_BLOB_RENDER_BOUNDING_BOX|CV_BLOB_RENDER_ANGLE.
109 |         /// \param alpha If mode CV_BLOB_RENDER_COLOR is used. 1.0 indicates opaque and 0.0 translucent (1.0 by default).
110 |         /// \see CV_BLOB_RENDER_COLOR
111 |         /// \see CV_BLOB_RENDER_CENTROID
112 |         /// \see CV_BLOB_RENDER_BOUNDING_BOX
113 |         /// \see CV_BLOB_RENDER_ANGLE
114 |         /// \see CV_BLOB_RENDER_TO_LOG
115 |         /// \see CV_BLOB_RENDER_TO_STD
116 |         void RenderBlobs(const cv::Mat &imgSource, cv::Mat &imgDest, unsigned short mode = 0x000f, double alpha = 1.) const;
117 | 
118 |     protected:
119 |         cv::Mat imgLabel;            ///< Labelled image
120 |         std::list<SharedBlob> blobs; ///< Blobs list
121 |     };
122 | 
123 | 
124 | } // Namespace
125 | 
126 | #endif // _CVBLOB_LIST_H_


--------------------------------------------------------------------------------
/cvBlob/cvb_contour.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | #include <climits>
 24 | #include <cmath>
 25 | #include <deque>
 26 | #include <iostream>
 27 | #include <fstream>
 28 | #include <sstream>
 29 | 
 30 | #include "cvb_contour.h"
 31 | #include "cvb_aux.h"
 32 | 
 33 | using namespace cvb;
 34 | 
 35 | namespace {
 36 |     const double kPi = std::atan(1) * 4;
 37 | }  // namespace
 38 | 
 39 | /// \brief Move vectors of chain codes.
 40 | const cv::Point ChainCodeMoves[8] = {
 41 |     cv::Point(0, -1),
 42 |     cv::Point(1, -1),
 43 |     cv::Point(1,  0),
 44 |     cv::Point(1,  1),
 45 |     cv::Point(0,  1),
 46 |     cv::Point(-1,  1),
 47 |     cv::Point(-1,  0),
 48 |     cv::Point(-1, -1)
 49 | };
 50 | 
 51 | Contour::Contour() : Contour(cv::Point(0, 0), ChainCodes()) {}
 52 | 
 53 | Contour::Contour(cv::Point startingPoint) : Contour(startingPoint, ChainCodes()) {}
 54 | 
 55 | Contour::Contour(cv::Point startingPoint, ChainCodes chainCodes) {
 56 |     reset(startingPoint, chainCodes);
 57 | }
 58 | 
 59 | // TODO Update to delegating constructore in VC2013
 60 | Contour::Contour(unsigned int x, unsigned int y, ChainCodes chainCodes) {
 61 |     reset(cv::Point(x, y), chainCodes);
 62 | }
 63 | 
 64 | void Contour::reset(cv::Point startingPoint, ChainCodes chainCodes) {
 65 |     starting_point = startingPoint;
 66 |     chain_codes = chainCodes;
 67 |     polygon.clear();
 68 | 
 69 |     // Initializes polygon structure
 70 | 
 71 |     // Push first point
 72 |     cv::Point a_point = starting_point;
 73 |     polygon.push_back(a_point);
 74 | 
 75 |     if (chain_codes.size() != 0) {
 76 |         ChainCode lastCode = chain_codes.front();
 77 |         for (auto &a_chain_code : chain_codes) {
 78 |             if (lastCode != a_chain_code) {
 79 |                 // Direction change, add new point
 80 |                 polygon.push_back(a_point);
 81 |                 lastCode = a_chain_code;
 82 |             }
 83 |             // Update point position
 84 |             a_point += ChainCodeMoves[a_chain_code];
 85 |         }
 86 |     }
 87 | 
 88 | }
 89 | 
 90 | void Contour::add_ChainCode(ChainCode chainCode) {
 91 |     // Update polygon structure
 92 |     if (chain_codes.empty()) {
 93 |         // First element added, add one end point
 94 |         polygon.push_back(starting_point + ChainCodeMoves[chainCode]);
 95 |     } else {
 96 |         ChainCode lastCode = chain_codes.back();
 97 |         if (lastCode == chainCode)
 98 |             // Same direction, change end point
 99 |             polygon.back() += ChainCodeMoves[chainCode];
100 |         else
101 |             // Different direction, add a new point
102 |             polygon.push_back(polygon.back() + ChainCodeMoves[chainCode]);
103 |     }
104 | 
105 |     // Add chainCode to list
106 |     this->chain_codes.push_back(chainCode);
107 | }
108 | 
109 | cv::Point Contour::get_StartingPoint() const {
110 |     return starting_point;
111 | }
112 | 
113 | ChainCodes Contour::get_ChainCodes() const {
114 |     return chain_codes;
115 | }
116 | 
117 | ContourPolygon Contour::get_ContourPolygon() const {
118 |     return polygon;
119 | }
120 | 
121 | double Contour::get_Area() const {
122 |     if (polygon.size() <= 2)
123 |         return 1.;
124 | 
125 |     cv::Point lastPoint = polygon.back();
126 |     double a = 0.;
127 |     for (auto &a_point : polygon) {
128 |         a += lastPoint.x * a_point.y - lastPoint.y * a_point.x;
129 |         lastPoint = a_point;
130 |     }
131 | 
132 |     return a * 0.5;
133 | }
134 | 
135 | double Contour::get_Perimeter() const {
136 |     double perimeter = 0.;
137 |     for (auto &a_chain_code : chain_codes) {
138 |         if (a_chain_code % 2)
139 |             perimeter += std::sqrt(1. + 1.);
140 |         else
141 |             perimeter += 1.;
142 |     }
143 | 
144 |     return perimeter;
145 | }
146 | 
147 | double Contour::get_Circularity() const {
148 |     double l = get_Perimeter();
149 |     double c = (l * l / get_Area()) - 4. * kPi;
150 | 
151 |     if (c >= 0.)
152 |         return c;
153 |     else // This could happen if the blob is only a pixel: the perimeter will be 0. Another solution would be to force "Perimeter" to be 1 or greater.
154 |         return 0.;
155 | }
156 | 
157 | // Utility function
158 | void simplifyPolygonRecursive(const ContourPolygon &p, int const i1, int const i2, std::vector<bool> &pnUseFlag, const double delta) {
159 |     int endIndex = (i2 < 0) ? (int) p.size() : i2;
160 | 
161 |     if (std::abs((int)(i1 - endIndex))<=1)
162 |         return;
163 | 
164 |     cv::Point firstPoint = p[i1];
165 |     cv::Point lastPoint = (i2<0)?p.front():p[i2];
166 | 
167 |     double furtherDistance = 0.;
168 |     int furtherIndex = 0;
169 | 
170 |     for (int i = i1 + 1; i < endIndex; i++) {
171 |         double d = DistanceLinePoint(firstPoint, lastPoint, p[i]);
172 | 
173 |         if ((d >= delta) && (d > furtherDistance)) {
174 |             furtherDistance = d;
175 |             furtherIndex = i;
176 |         }
177 |     }
178 | 
179 |     if (furtherIndex) {
180 |         pnUseFlag[furtherIndex]=true;
181 | 
182 |         simplifyPolygonRecursive(p, i1, furtherIndex, pnUseFlag, delta);
183 |         simplifyPolygonRecursive(p, furtherIndex, i2, pnUseFlag, delta);
184 |     }
185 | }
186 | 
187 | ContourPolygon Contour::get_SimplifiedPolygon(const double delta) const {
188 |     double furtherDistance = 0.;
189 |     unsigned int furtherIndex = 0;
190 | 
191 |     unsigned int i = 1;
192 |     for (auto &a_point : polygon) {
193 |         double d = DistancePointPoint(a_point, polygon.front());
194 | 
195 |         if (d>furtherDistance) {
196 |             furtherDistance = d;
197 |             furtherIndex = i;
198 |         }
199 |     }
200 | 
201 |     if (furtherDistance<delta) {
202 |         ContourPolygon result;
203 |         result.push_back(polygon.front());
204 |         return result;
205 |     }
206 | 
207 |     std::vector<bool> pnUseFlag(polygon.size(), false);
208 | 
209 |     pnUseFlag[0] = pnUseFlag[furtherIndex] = true;
210 | 
211 |     simplifyPolygonRecursive(polygon, 0, furtherIndex, pnUseFlag, delta);
212 |     simplifyPolygonRecursive(polygon, furtherIndex, -1, pnUseFlag, delta);
213 | 
214 |     ContourPolygon result;
215 | 
216 |     for (unsigned int i = 0; i < polygon.size(); i++) {
217 |         if (pnUseFlag[i])
218 |             result.push_back(polygon[i]);
219 |     }
220 | 
221 |     return result;
222 | }
223 | 
224 | ContourPolygon Contour::get_ConvexHull() const {
225 |     if (polygon.size() <= 3) {
226 |         return ContourPolygon(polygon.begin(), polygon.end());
227 |     }
228 | 
229 |     std::deque<cv::Point> dq;
230 | 
231 |     if (CrossProductPoints(polygon[0], polygon[1], polygon[2])>0) {
232 |         dq.push_back(polygon[0]);
233 |         dq.push_back(polygon[1]);
234 |     } else {
235 |         dq.push_back(polygon[1]);
236 |         dq.push_back(polygon[0]);
237 |     }
238 | 
239 |     dq.push_back(polygon[2]);
240 |     dq.push_front(polygon[2]);
241 | 
242 |     for (unsigned int i = 3; i < polygon.size(); i++) {
243 |         size_t s = dq.size();
244 | 
245 |         if ((CrossProductPoints(polygon[i], dq.at(0), dq.at(1))>=0) && (CrossProductPoints(dq.at(s-2), dq.at(s-1), polygon[i])>=0))
246 |             continue; // TODO Optimize.
247 | 
248 |         while (CrossProductPoints(dq.at(s-2), dq.at(s-1), polygon[i]) < 0) {
249 |             dq.pop_back();
250 |             s = dq.size();
251 |         }
252 | 
253 |         dq.push_back(polygon[i]);
254 | 
255 |         while (CrossProductPoints(polygon[i], dq.at(0), dq.at(1))<0)
256 |             dq.pop_front();
257 | 
258 |         dq.push_front(polygon[i]);
259 |     }
260 | 
261 |     return ContourPolygon(dq.begin(), dq.end());
262 | }
263 | 
264 | 
265 | void Contour::RenderContour(cv::Mat &img, const cv::Scalar &color) const {
266 |     CV_Assert(img.type() == CV_8UC3 && img.isContinuous());
267 | 
268 |     size_t stepDst = img.step;
269 |     unsigned char *imgData = (unsigned char *)img.ptr();
270 | 
271 |     cv::Point point = starting_point;
272 |     for (auto &a_chain_code : chain_codes) {
273 |         imgData[point.y * stepDst + point.x * 3 + 0] = (unsigned char)(color.val[0]); // Blue
274 |         imgData[point.y * stepDst + point.x * 3 + 1] = (unsigned char)(color.val[1]); // Green
275 |         imgData[point.y * stepDst + point.x * 3 + 2] = (unsigned char)(color.val[1]); // Red
276 | 
277 |         point += ChainCodeMoves[a_chain_code];
278 |     }
279 | }
280 | 
281 | void Contour::WriteCSV(const std::string &filename) const {
282 |     std::ofstream f(filename);
283 |     f << this << std::endl;
284 | 
285 |     f.close();
286 | }
287 | 
288 | void Contour::WriteSVG(const std::string &filename, const cv::Scalar &stroke, const cv::Scalar &fill) const {
289 |     int minx=INT_MAX;
290 |     int miny=INT_MAX;
291 |     int maxx=INT_MIN;
292 |     int maxy=INT_MIN;
293 | 
294 |     std::stringstream buffer("");
295 | 
296 |     for (auto &a_point : polygon) {
297 |         if (a_point.x > maxx)
298 |             maxx = a_point.x;
299 |         if (a_point.x < minx)
300 |             minx = a_point.x;
301 | 
302 |         if (a_point.y > maxy)
303 |             maxy = a_point.y;
304 |         if (a_point.y < miny)
305 |             miny = a_point.y;
306 | 
307 |         buffer << a_point.x << "," << a_point.y << " ";
308 |     }
309 | 
310 |     std::ofstream f (filename);
311 | 
312 |     f << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"no\"?>" << std::endl;
313 |     f << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 20010904//EN\" \"https://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">" << std::endl;
314 |     f << "<svg xmlns=\"https://www.w3.org/2000/svg\" xmlns:xlink=\"https://www.w3.org/1999/xlink\" xml:space=\"preserve\" width=\"" << maxx-minx << "px\" height=\"" << maxy-miny << "px\" viewBox=\"" << minx << " " << miny << " " << maxx << " " << maxy << "\" zoomAndPan=\"disable\" >" << std::endl;
315 | 
316 |     f << "<polygon fill=\"rgb(" << fill.val[0] << "," << fill.val[1] << "," << fill.val[2] << ")\" stroke=\"rgb(" << stroke.val[0] << "," << stroke.val[1] << "," << stroke.val[2] << ")\" stroke-width=\"1\" points=\"" << buffer.str() << "\"/>" << std::endl;
317 | 
318 |     f << "</svg>" << std::endl;
319 | 
320 |     f.close();
321 | }
322 | 
323 | void Contour::Print(std::ostream &out) const {
324 |     for (auto &a_point : polygon)
325 |         out << a_point.x << ", " << a_point.y << std::endl;
326 | }
327 | 
328 | std::ostream &operator<< (std::ostream &output, const Contour &p) {
329 |     p.Print(output);
330 |     return output;
331 | }
332 | 


--------------------------------------------------------------------------------
/cvBlob/cvb_contour.h:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | /// \file cvb_contour.h
 24 | /// \brief cvBlob contour header file.
 25 | 
 26 | #ifdef SWIG
 27 | %module cvblob
 28 |     %{
 29 | #include "cvb_contour.h"
 30 |         %}
 31 | #endif
 32 | 
 33 | #ifndef _CVBLOB_CONTOUR_H_
 34 | #define _CVBLOB_CONTOUR_H_
 35 | 
 36 | #include <list>
 37 | #include <memory>
 38 | #include <atomic>
 39 | #include <mutex>
 40 | 
 41 | #include <opencv2/core/core.hpp>
 42 | 
 43 | #include "cvb_defines.h"
 44 | 
 45 | namespace cvb {
 46 | 
 47 |     // Chain code:
 48 |     //        7 0 1
 49 |     //        6   2
 50 |     //        5 4 3
 51 |     CVBLOB_EXPORT enum ChainCode {
 52 |         ChainCode_up         = 0, ///< Up.
 53 |         ChainCode_up_right   = 1, ///< Up and right.
 54 |         ChainCode_right      = 2, ///< Right.
 55 |         ChainCode_down_right = 3, ///< Down and right.
 56 |         ChainCode_down       = 4, ///< Down.
 57 |         ChainCode_down_left  = 5, ///< Down and left.
 58 |         ChainCode_left       = 6, ///< Left.
 59 |         ChainCode_up_left    = 7, ///< Up and left.
 60 |     };
 61 | 
 62 |     /// \brief Chain code list.
 63 |     typedef std::list<ChainCode> ChainCodes;
 64 | 
 65 |     /// \brief Polygon based contour.
 66 |     typedef std::vector<cv::Point> ContourPolygon;
 67 | 
 68 |     /// \brief Contour class.
 69 |     class CVBLOB_EXPORT Contour {
 70 |     public:
 71 |         Contour();
 72 | 
 73 |         Contour(cv::Point startingPoint);
 74 | 
 75 |         /// \brief Constructor.
 76 |         /// \param startingPoint  The contour starting point.
 77 |         /// \param chainCodes     Initial chain codes.
 78 |         Contour(cv::Point startingPoint, ChainCodes chainCodes);
 79 | 
 80 |         /// \brief Constructor.
 81 |         /// \param x              The contour starting point X-coordinate.
 82 |         /// \param y              The contour starting point Y-coordinate.
 83 |         /// \param chainCodes     Initial chain codes.
 84 |         Contour(unsigned int x, unsigned int y, ChainCodes chainCodes);
 85 | 
 86 |         /// \brief  Clears this object and resets all internal data structures.
 87 |         /// \param startingPoint  The new starting point.
 88 |         /// \param chainCodes     The new initial chain codes.
 89 |         void reset(cv::Point startingPoint, ChainCodes chainCodes);
 90 | 
 91 |         // \brief Adds a chain code to this object.
 92 |         // \param chainCode       The chain code to be added.
 93 |         void add_ChainCode(ChainCode chainCode);
 94 | 
 95 |         /// \brief Gets the contour starting point.
 96 |         /// \return The contour starting point.
 97 |         cv::Point get_StartingPoint() const;
 98 | 
 99 |         /// \brief Gets the list of chain codes.
100 |         /// \return The list of chain codes
101 |         ChainCodes get_ChainCodes() const;
102 | 
103 |         /// \brief Returns a polygon structure.
104 |         /// \return A polygon.
105 |         ContourPolygon get_ContourPolygon() const;
106 | 
107 |         /// \brief Calculates area of a contour.
108 |         /// \return Area of the contour.
109 |         double get_Area() const;
110 | 
111 |         /// \brief Calculates perimeter of a contour.
112 |         /// \return Perimeter of the contour.
113 |         double get_Perimeter() const;
114 | 
115 |         /// \brief Calculates the circularity of a contour (compactness measure).
116 |         /// \return Circularity: a non-negative value, where 0 correspond with a circumference.
117 |         double get_Circularity() const;
118 | 
119 |         /// \brief Calculates a simplified polygon structure reducing the number of vertex according the distance "delta".
120 |         /// Uses a version of the Ramer-Douglas-Peucker algorithm (http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm).
121 |         /// \param delta Minimun distance.
122 |         /// \return A simplify version of the original polygon.
123 |         ContourPolygon get_SimplifiedPolygon(const double delta = 1.) const;
124 | 
125 |         /// \brief Calculates convex hull of a contour.
126 |         /// Uses the Melkman Algorithm. Code based on the version in http://w3.impa.br/~rdcastan/Cgeometry/.
127 |         /// \return Convex hull.
128 |         ContourPolygon get_ConvexHull() const;
129 | 
130 |         /// \brief Draw a contour.
131 |         /// \param img Image to draw on, must be of type CV_8UC3, and continuous.
132 |         /// \param color Color to draw with (default, white).
133 |         void RenderContour(cv::Mat &img, const cv::Scalar &color = cv::Scalar(255, 255, 255)) const;
134 | 
135 |         /// \brief Write a contour to a CSV (Comma-separated values) file.
136 |         /// \param filename File name.
137 |         void WriteCSV(const std::string &filename) const;
138 | 
139 |         /// \brief Write a contour to a SVG file (http://en.wikipedia.org/wiki/Scalable_Vector_Graphics).
140 |         /// \param filename File name.
141 |         /// \param stroke Stroke color (black by default).
142 |         /// \param fill Fill color (white by default).
143 |         void WriteSVG(const std::string &filename, const cv::Scalar &stroke = cv::Scalar(0,0,0), const cv::Scalar &fill = cv::Scalar(255,255,255)) const;
144 | 
145 |         /// \brief Prints the data to the out stream in CSV format.
146 |         /// \param out The output stream.
147 |         void Print(std::ostream &out) const;
148 | 
149 |     protected:
150 |         cv::Point starting_point;  ///< Point where contour begins.
151 |         ChainCodes chain_codes;    ///< Polygon description based on chain codes.
152 |         ContourPolygon polygon;    ///< Polygon description based on cv::Point.
153 |     };
154 | 
155 |     typedef std::shared_ptr<Contour> SharedContour; ///< Shared contour.
156 |     typedef std::list<SharedContour> ContoursList;  ///< List of contours (chain codes type).
157 | 
158 |     /// \brief Overload operator "<<" for printing polygons in CSV format.
159 |     /// \return Stream.
160 |     CVBLOB_EXPORT std::ostream &operator<< (std::ostream &output, const Contour &p);
161 | 
162 | } // Namespace
163 | 
164 | #endif // _CVBLOB_CONTOUR_H_


--------------------------------------------------------------------------------
/cvBlob/cvb_defines.h:
--------------------------------------------------------------------------------
 1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
 2 | // grendel.ccl@gmail.com
 3 | //
 4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
 5 | // fabrice.degans@gmail.com
 6 | //
 7 | // This file is part of cvBlob.
 8 | //
 9 | // cvBlob is free software: you can redistribute it and/or modify
10 | // it under the terms of the Lesser GNU General Public License as published by
11 | // the Free Software Foundation, either version 3 of the License, or
12 | // (at your option) any later version.
13 | //
14 | // cvBlob is distributed in the hope that it will be useful,
15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 | // Lesser GNU General Public License for more details.
18 | //
19 | // You should have received a copy of the Lesser GNU General Public License
20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
21 | //
22 | 
23 | #ifndef _CVBLOB_DEFINES_H_
24 | #define _CVBLOB_DEFINES_H_
25 | 
26 | #ifdef _MSC_VER // MS VC
27 | 
28 | # ifdef CVBLOB_LIB
29 | #  define CVBLOB_EXPORT __declspec(dllexport)
30 | # else
31 | #  define CVBLOB_EXPORT
32 | # endif
33 | 
34 | #else // Other compilers
35 | 
36 | # define CVBLOB_EXPORT
37 | 
38 | #endif // Compiler
39 | 
40 | #endif  // _CVBLOB_DEFINES_H_


--------------------------------------------------------------------------------
/cvBlob/cvb_track.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | #include <cmath>
 24 | #include <iostream>
 25 | #include <sstream>
 26 | 
 27 | #include "cvb_track.h"
 28 | 
 29 | using namespace cvb;
 30 | 
 31 | double Track::DistanceFromBlob(const Blob &b) const {
 32 |     double d1;
 33 |     cv::Point blob_centroid = b.get_Centroid();
 34 | 
 35 |     if (blob_centroid.x < this->minx) {
 36 |         if (blob_centroid.y < this->miny)
 37 |             d1 = std::max(this->minx - blob_centroid.x, this->miny - blob_centroid.y);
 38 |         else if (blob_centroid.y > this->maxy)
 39 |             d1 = std::max(this->minx - blob_centroid.x, blob_centroid.y - this->maxy);
 40 |         else // if (this->miny < blob_centroid.y)&&(blob_centroid.y < this->maxy)
 41 |             d1 = this->minx - blob_centroid.x;
 42 |     } else if (blob_centroid.x > this->maxx) {
 43 |         if (blob_centroid.y < this->miny)
 44 |             d1 = std::max(blob_centroid.x - this->maxx, this->miny - blob_centroid.y);
 45 |         else if (blob_centroid.y > this->maxy)
 46 |             d1 = std::max(blob_centroid.x - this->maxx, blob_centroid.y - this->maxy);
 47 |         else
 48 |             d1 = blob_centroid.x - this->maxx;
 49 |     } else { //if (this->minx =< blob_centroid.x) && (blob_centroid.x =< this->maxx)
 50 |         if (blob_centroid.y < this->miny)
 51 |             d1 = this->miny - blob_centroid.y;
 52 |         else if (blob_centroid.y > this->maxy)
 53 |             d1 = blob_centroid.y - this->maxy;
 54 |         else 
 55 |             return 0.;
 56 |     }
 57 | 
 58 |     double d2;
 59 |     cv::Rect bounding_box = b.get_BoundingBox();
 60 |     unsigned int blob_minx = bounding_box.x;
 61 |     unsigned int blob_miny = bounding_box.y;
 62 |     unsigned int blob_maxx = blob_minx + bounding_box.width;
 63 |     unsigned int blob_maxy = blob_miny + bounding_box.height;
 64 | 
 65 |     if (this->centroid.x < blob_minx) {
 66 |         if (this->centroid.y < blob_miny)
 67 |             d2 = std::max(blob_minx - this->centroid.x, blob_miny - this->centroid.y);
 68 |         else if (this->centroid.y > blob_maxy)
 69 |             d2 = std::max(blob_minx - this->centroid.x, this->centroid.y - blob_maxy);
 70 |         else // if (blob_miny < this->centroid.y)&&(this->centroid.y < blob_maxy)
 71 |             d2 = minx - this->centroid.x;
 72 |     } else if (this->centroid.x > blob_maxx) {
 73 |         if (this->centroid.y < blob_miny)
 74 |             d2 = std::max(this->centroid.x - blob_maxx, blob_miny - this->centroid.y);
 75 |         else if (this->centroid.y > blob_maxy)
 76 |             d2 = std::max(this->centroid.x - blob_maxx, this->centroid.y - blob_maxy);
 77 |         else
 78 |             d2 = this->centroid.x - blob_maxx;
 79 |     } else { // if (blob_minx =< this->centroid.x) && (this->centroid.x =< blob_maxx)
 80 |         if (this->centroid.y < blob_miny)
 81 |             d2 = blob_miny - this->centroid.y;
 82 |         else if (this->centroid.y > blob_maxy)
 83 |             d2 = this->centroid.y - blob_maxy;
 84 |         else 
 85 |             return 0.;
 86 |     }
 87 | 
 88 |     return std::min(d1, d2);
 89 | }
 90 | 
 91 | // Access to matrix
 92 | //#define C(blob, track) close[((blob) + (track)*(nBlobs+2))]
 93 | 
 94 | // Access to accumulators
 95 | //#define AB(label) C((label), (nTracks))
 96 | //#define AT(id) C((nBlobs), (id))
 97 | 
 98 | // Access to identifications
 99 | #define IB(label) C((label), (nTracks)+1)
100 | #define IT(id) C((nBlobs)+1, (id))
101 | 
102 | // Access to registers
103 | #define B(label) blob_map.find(IB(label))->second
104 | #define T(id) tracks.find(IT(id))->second
105 | 
106 | inline TrackID &C(unsigned int blob, unsigned int track, std::vector<TrackID> &close, unsigned int nBlobs) {
107 |     return close[blob + track * (nBlobs + 2)];
108 | }
109 | 
110 | inline TrackID &AB(unsigned int label, unsigned int nTracks, std::vector<TrackID> &close, unsigned int nBlobs) {
111 |     return C(label, nTracks, close, nBlobs);
112 | }
113 | 
114 | inline TrackID &AT(unsigned int id, unsigned int nTracks, std::vector<TrackID> &close, unsigned int nBlobs) {
115 |     return C(nBlobs, id, close, nBlobs);
116 | }
117 | 
118 | 
119 | void getClusterForTrack(unsigned int trackPos, std::vector<TrackID> &close, unsigned int nBlobs, unsigned int nTracks, const BlobsMap &blob_map, TrackList const &tracks, std::list<SharedBlob> &bb, std::list<SharedTrack> &tt);
120 | 
121 | void getClusterForBlob(unsigned int blobPos, std::vector<TrackID> &close, unsigned int nBlobs, unsigned int nTracks, const BlobsMap &blob_map, TrackList const &tracks, std::list<SharedBlob> &bb, std::list<SharedTrack> &tt) {
122 |     for (unsigned int j = 0; j < nTracks; j++) {
123 |         if (C(blobPos, j, close, nBlobs)) {
124 |             tt.push_back(T(j));
125 | 
126 |             unsigned int c = AT(j);
127 | 
128 |             C(blobPos, j, close, nBlobs) = 0;
129 |             AB(blobPos, nTracks, close, nBlobs)--;
130 |             AT(j)--;
131 | 
132 |             if (c>1) {
133 |                 getClusterForTrack(j, close, nBlobs, nTracks, blob_map, tracks, bb, tt);
134 |             }
135 |         }
136 |     }
137 | }
138 | 
139 | void getClusterForTrack(unsigned int trackPos, std::vector<TrackID> &close, unsigned int nBlobs, unsigned int nTracks, const BlobsMap &blob_map, TrackList const &tracks, std::list<SharedBlob> &bb, std::list<SharedTrack> &tt) {
140 |     for (unsigned int i=0; i<nBlobs; i++) {
141 |         if (C(i, trackPos)) {
142 |             bb.push_back(B(i));
143 | 
144 |             unsigned int c = AB(i);
145 | 
146 |             C(i, trackPos) = 0;
147 |             AB(i)--;
148 |             AT(trackPos)--;
149 | 
150 |             if (c>1) {
151 |                 getClusterForBlob(i, close, nBlobs, nTracks, blob_map, tracks, bb, tt);
152 |             }
153 |         }
154 |     }
155 | }
156 | 
157 | void TrackList::UpdateTracks(const BlobList &blobs, const double thDistance, const unsigned int thInactive, const unsigned int thActive) {
158 |     auto blob_map = blobs.get_BlobsMap();
159 |     size_t nBlobs = blob_map.size();
160 |     size_t nTracks = tracks.size();
161 | 
162 |     // Proximity matrix:
163 |     // Last row/column is for ID/label.
164 |     // Last-1 "/" is for accumulation.
165 |     std::vector<TrackID> close((nBlobs + 2) * (nTracks + 2));
166 | 
167 |     try {
168 |         // Initialization
169 |         unsigned int i=0;
170 |         for (auto & a_blob : blob_map) {
171 |             AB(i) = 0;
172 |             IB(i) = a_blob.second->label;
173 |             i++;
174 |         }
175 | 
176 |         TrackID maxTrackID = 0;
177 | 
178 |         unsigned int j = 0;
179 |         for (auto &a_track : tracks) {
180 |             AT(j) = 0;
181 |             IT(j) = a_track.second->get_ID();
182 |             if (a_track.second->get_ID() > maxTrackID)
183 |                 maxTrackID = a_track.second->get_ID();
184 |             j++;
185 |         }
186 | 
187 |         // Proximity matrix calculation and "used blob" std::list inicialization:
188 |         for (i = 0; i < nBlobs; i++)
189 |             for (j = 0; j < nTracks; j++)
190 |                 if (C(i, j) = T(j)->DistanceFromBlob(*B(i))) {
191 |                     AB(i)++;
192 |                     AT(j)++;
193 |                 }
194 | 
195 |         /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
196 |         // Detect inactive tracks
197 |         for (j=0; j<nTracks; j++) {
198 |             unsigned int c = AT(j);
199 | 
200 |             if (c==0) {
201 |                 //std::cout << "Inactive track: " << j << std::endl;
202 | 
203 |                 // Inactive track.
204 |                 SharedTrack track = T(j);
205 |                 track->inactive++;
206 |                 track->label = 0;
207 |             }
208 |         }
209 | 
210 |         // Detect new tracks
211 |         for (i=0; i<nBlobs; i++) {
212 |             unsigned int c = AB(i);
213 | 
214 |             if (c==0) {
215 |                 //std::cout << "Blob (new track): " << maxTrackID+1 << std::endl;
216 |                 //std::cout << *B(i) << std::endl;
217 | 
218 |                 // New track.
219 |                 maxTrackID++;
220 |                 SharedBlob blob = B(i);
221 |                 SharedTrack track(new Track(blob));
222 |                 track->get_ID() = maxTrackID;
223 |                 track->label = blob->label;
224 |                 track->minx = blob->minx;
225 |                 track->miny = blob->miny;
226 |                 track->maxx = blob->maxx;
227 |                 track->maxy = blob->maxy;
228 |                 track->centroid = blob->centroid;
229 |                 track->lifetime = 0;
230 |                 track->active = 0;
231 |                 track->inactive = 0;
232 |                 tracks.insert(IDTrackPair(maxTrackID, track));
233 |             }
234 |         }
235 | 
236 |         // Clustering
237 |         for (j = 0; j < nTracks; j++) {
238 |             unsigned int c = AT(j);
239 | 
240 |             if (c) {
241 |                 std::list<SharedTrack> tt; tt.push_back(T(j));
242 |                 std::list<SharedBlob> bb;
243 | 
244 |                 getClusterForTrack(j, close, (unsigned int) nBlobs, (unsigned int) nTracks, blob_map, tracks, bb, tt);
245 | 
246 |                 // Select track
247 |                 SharedTrack track;
248 |                 unsigned int area = 0;
249 |                 for (auto &a_track : tt) {
250 |                     // Get area
251 |                     unsigned int a = (a_track->maxx - a_track->minx) * (a_track->maxy - a_track->miny);
252 |                     if (a > area) {
253 |                         area = a;
254 |                         track = a_track;
255 |                     }
256 |                 }
257 | 
258 |                 // Select blob
259 |                 SharedBlob blob;
260 |                 area = 0;
261 |                 //std::cout << "Matching blobs: ";
262 |                 for (auto &a_blob : bb) {
263 |                     //std::cout << a_blob->label << " ";
264 | 
265 |                     if (a_blob->get_Area() > area) {
266 |                         area = a_blob->get_Area();
267 |                         blob = a_blob;
268 |                     }
269 |                 }
270 |                 //std::cout << std::endl;
271 | 
272 |                 // Update track
273 |                 //std::cout << "Matching: track=" << track->get_ID() << ", blob=" << blob->label << std::endl;
274 |                 track->update_Blob(blob);
275 |                 // Move this
276 |                 track->label = blob->label;
277 |                 track->centroid = blob->centroid;
278 |                 track->minx = blob->minx;
279 |                 track->miny = blob->miny;
280 |                 track->maxx = blob->maxx;
281 |                 track->maxy = blob->maxy;
282 |                 if (track->inactive)
283 |                     track->active = 0;
284 |                 track->inactive = 0;
285 | 
286 |                 // Others to inactive
287 |                 for (auto &a_track : tt) {
288 |                     if (a_track != track) {
289 |                         //std::cout << "Inactive: track=" << t->get_ID() << std::endl;
290 |                         a_track->IncreaseInactive();
291 |                         // Move this
292 |                         a_track->inactive++;
293 |                         a_track->label = 0;
294 |                     }
295 |                 }
296 |             }
297 |         }
298 |         /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
299 | 
300 |         for (auto &jt = tracks.begin(); jt != tracks.end();)
301 |             if (jt->second->IsTooOld(thInactive, thActive)) {
302 |             //if ((jt->second->inactive >= thInactive) || ((jt->second->inactive) && (thActive) && (jt->second->active < thActive))) {
303 |                 tracks.erase(jt++);
304 |             } else {
305 |                 jt->second->IncreaseLifetime();
306 |                 // move this
307 |                 jt->second->lifetime++;
308 |                 if (!jt->second->inactive)
309 |                     jt->second->active++;
310 |                 ++jt;
311 |             }
312 |     } catch (...) {
313 |         throw; // TODO: OpenCV style.
314 |     }
315 | }
316 | 
317 | void TrackList::RenderTracks(cv::Mat &imgSource, cv::Mat &imgDest, unsigned short mode, int font) const {
318 |     CV_Assert(imgDest.type() == CV_8UC3);
319 | 
320 |     if (mode) {
321 |         for (auto &a_track : tracks) {
322 |             if (mode & CV_TRACK_RENDER_ID) {
323 |                 if (!a_track.second->inactive) {
324 |                     std::stringstream buffer;
325 |                     buffer << a_track.first;
326 |                     cv::putText(imgDest, buffer.str(), cv::Point((int) a_track.second->centroid.x, (int) a_track.second->centroid.y), font, 1, cv::Scalar(0., 255., 0.));
327 |                 }
328 |             }
329 | 
330 |             if (mode & CV_TRACK_RENDER_BOUNDING_BOX) {
331 |                 if (a_track.second->inactive)
332 |                     cv::rectangle(imgDest, cv::Point(a_track.second->minx, a_track.second->miny), cv::Point(a_track.second->maxx - 1, a_track.second->maxy - 1), cv::Scalar(0., 0., 50.));
333 |                 else
334 |                     cv::rectangle(imgDest, cv::Point(a_track.second->minx, a_track.second->miny), cv::Point(a_track.second->maxx - 1, a_track.second->maxy - 1), cv::Scalar(0., 0., 255.));
335 |             }
336 | 
337 |             if (mode & CV_TRACK_RENDER_TO_LOG) {
338 |                 std::clog << "Track " << a_track.second->get_ID() << std::endl;
339 |                 if (a_track.second->inactive)
340 |                     std::clog << " - Inactive for " << a_track.second->inactive << " frames" << std::endl;
341 |                 else
342 |                     std::clog << " - Associated with blob " << a_track.second->label << std::endl;
343 |                 std::clog << " - Lifetime " << a_track.second->lifetime << std::endl;
344 |                 std::clog << " - Active " << a_track.second->active << std::endl;
345 |                 std::clog << " - Bounding box: (" << a_track.second->minx << ", " << a_track.second->miny << ") - (" << a_track.second->maxx << ", " << a_track.second->maxy << ")" << std::endl;
346 |                 std::clog << " - Centroid: (" << a_track.second->centroid.x << ", " << a_track.second->centroid.y << ")" << std::endl;
347 |                 std::clog << std::endl;
348 |             }
349 | 
350 |             if (mode & CV_TRACK_RENDER_TO_STD) {
351 |                 std::cout << "Track " << a_track.second->get_ID() << std::endl;
352 |                 if (a_track.second->inactive)
353 |                     std::cout << " - Inactive for " << a_track.second->inactive << " frames" << std::endl;
354 |                 else
355 |                     std::cout << " - Associated with blobs " << a_track.second->label << std::endl;
356 |                 std::cout << " - Lifetime " << a_track.second->lifetime << std::endl;
357 |                 std::cout << " - Active " << a_track.second->active << std::endl;
358 |                 std::cout << " - Bounding box: (" << a_track.second->minx << ", " << a_track.second->miny << ") - (" << a_track.second->maxx << ", " << a_track.second->maxy << ")" << std::endl;
359 |                 std::cout << " - Centroid: (" << a_track.second->centroid.x << ", " << a_track.second->centroid.y << ")" << std::endl;
360 |                 std::cout << std::endl;
361 |             }
362 |         }
363 |     }
364 | }
365 | 
366 | 


--------------------------------------------------------------------------------
/cvBlob/cvb_track.h:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // Copyright (C) 2013 by Fabrice de Gans for ProViSys Engineering
  5 | // fabrice.degans@gmail.com
  6 | //
  7 | // This file is part of cvBlob.
  8 | //
  9 | // cvBlob is free software: you can redistribute it and/or modify
 10 | // it under the terms of the Lesser GNU General Public License as published by
 11 | // the Free Software Foundation, either version 3 of the License, or
 12 | // (at your option) any later version.
 13 | //
 14 | // cvBlob is distributed in the hope that it will be useful,
 15 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 | // Lesser GNU General Public License for more details.
 18 | //
 19 | // You should have received a copy of the Lesser GNU General Public License
 20 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 21 | //
 22 | 
 23 | /// \file cvb_track.h
 24 | /// \brief OpenCV Blob header file.
 25 | 
 26 | #ifdef SWIG
 27 | %module cvblob
 28 |     %{
 29 | #include "cvb_track.h"
 30 |         %}
 31 | #endif
 32 | 
 33 | #ifndef _CVBLOB_TRACK_H_
 34 | #define _CVBLOB_TRACK_H_
 35 | 
 36 | #include <cstdint>
 37 | #include <memory>
 38 | 
 39 | #include "cvb_blob_list.h"
 40 | 
 41 | namespace cvb {
 42 | #define CV_TRACK_RENDER_ID            0x0001 ///< Print the ID of each track in the image. \see cvRenderTracks
 43 | #define CV_TRACK_RENDER_BOUNDING_BOX  0x0002 ///< Draw bounding box of each track in the image. \see cvRenderTracks
 44 | #define CV_TRACK_RENDER_TO_LOG        0x0010 ///< Print track info to log out. \see cvRenderTracks
 45 | #define CV_TRACK_RENDER_TO_STD        0x0020 ///< Print track info to log out. \see cvRenderTracks
 46 | 
 47 |     /// \brief Type of identification numbers.
 48 |     typedef uint32_t TrackID;
 49 | 
 50 |     /// \brief Struct that contain information about one track.
 51 |     class Track {
 52 |     public:
 53 |         Track(SharedBlob blob);
 54 | 
 55 |         TrackID get_ID();
 56 |         double DistanceFromBlob(const Blob &b) const;
 57 | 
 58 |     protected:
 59 |         TrackID id; ///< Track identification number.
 60 |         Label label; ///< Label assigned to the blob related to this track.
 61 | 
 62 |         unsigned int minx; ///< X min.
 63 |         unsigned int maxx; ///< X max.
 64 |         unsigned int miny; ///< Y min.
 65 |         unsigned int maxy; ///< y max.
 66 | 
 67 |         cv::Point centroid; ///< Centroid.
 68 | 
 69 |         unsigned int lifetime; ///< Indicates how much frames the object has been in scene.
 70 |         unsigned int active; ///< Indicates number of frames that has been active from last inactive period.
 71 |         unsigned int inactive; ///< Indicates number of frames that has been missing.
 72 |     };
 73 | 
 74 |     typedef std::shared_ptr<Track> SharedTrack;
 75 | 
 76 |     /// \var typedef std::map<TrackID, SharedTrack> TrackList
 77 |     /// \brief List of tracks.
 78 |     /// \see TrackID
 79 |     /// \see Track
 80 |     typedef std::map<TrackID, SharedTrack> TracksMap;
 81 | 
 82 |     /// \var typedef std::pair<TrackID, SharedTrack> CvIDTrack
 83 |     /// \brief Pair (identification number, track).
 84 |     /// \see TrackID
 85 |     /// \see Track
 86 |     typedef std::pair<TrackID, SharedTrack> IDTrackPair;
 87 | 
 88 |     // TODO MOve me to cvb_track_list
 89 |     class TrackList {
 90 |     public:
 91 |         /// \fn UpdateTracks(const BlobList &b, const double thDistance, const unsigned int thInactive, const unsigned int thActive = 0)
 92 |         /// \brief Updates list of tracks based on current blobs.
 93 |         /// Tracking based on:
 94 |         /// A.Senior, A.Hampapur, Y-L Tian, L. Brown, S. Pankanti, R. Bolle. Appearance Models for
 95 |         /// Occlusion Handling. Second International workshop on Performance Evaluation of Tracking and
 96 |         /// Surveillance systems & CVPR'01. December, 2001.
 97 |         /// (https://researcher.watson.ibm.com/researcher/files/us-smiyaza/PETS2001.pdf)
 98 |         /// \param b List of blobs.
 99 |         /// \param thDistance Max distance to determine when a track and a blob match.
100 |         /// \param thInactive Max number of frames a track can be inactive.
101 |         /// \param thActive If a track becomes inactive but it has been active less than thActive frames, the track will be deleted.
102 |         /// \see BlobList
103 |         /// \see Tracks
104 |         void UpdateTracks(const BlobList &b, const double thDistance, const unsigned int thInactive, const unsigned int thActive = 0);
105 | 
106 |         /// \fn void RenderTracks(cv::Mat &imgSource, cv::Mat &imgDest, unsigned short mode=0x00ff, int font = cv::FONT_HERSHEY_DUPLEX) const
107 |         /// \brief Prints tracks information.
108 |         /// \param imgSource Input image (depth=IPL_DEPTH_8U and num. channels=3).
109 |         /// \param imgDest Output image (depth=IPL_DEPTH_8U and num. channels=3).
110 |         /// \param mode Render mode. By default is CV_TRACK_RENDER_ID|CV_TRACK_RENDER_BOUNDING_BOX.
111 |         /// \param font OpenCV font for print on the image.
112 |         /// \see CV_TRACK_RENDER_ID
113 |         /// \see CV_TRACK_RENDER_BOUNDING_BOX
114 |         /// \see CV_TRACK_RENDER_TO_LOG
115 |         /// \see CV_TRACK_RENDER_TO_STD
116 |         void RenderTracks(cv::Mat &imgSource, cv::Mat &imgDest, unsigned short mode=0x000f, int font = cv::FONT_HERSHEY_DUPLEX) const;
117 | 
118 |     protected:
119 |         TracksMap tracks;
120 | 
121 |     };
122 | 
123 | 
124 | 
125 |     /// \fn std::ostream &operator<< (std::ostream &output, const cvb::Track &t)
126 |     /// \brief Overload operator "<<" for printing track structure.
127 |     /// \return Stream.
128 |     std::ostream &operator<< (std::ostream &output, const Track &t);
129 | 
130 | 
131 | } // Namespace
132 | 
133 | #endif // _CVBLOB_TRACK_H_


--------------------------------------------------------------------------------
/meson.build:
--------------------------------------------------------------------------------
 1 | # Copyright (C) 2021 by Michael de Gans
 2 | # mike@mdegans.dev
 3 | #
 4 | # This file is part of cvBlob.
 5 | #
 6 | # cvBlob is free software: you can redistribute it and/or modify
 7 | # it under the terms of the Lesser GNU General Public License as published by
 8 | # the Free Software Foundation, either version 3 of the License, or
 9 | # (at your option) any later version.
10 | #
11 | # cvBlob is distributed in the hope that it will be useful,
12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | # Lesser GNU General Public License for more details.
15 | #
16 | # You should have received a copy of the Lesser GNU General Public License
17 | # along with cvBlob.  If not, see <https:#www.gnu.org/licenses/>.
18 | #
19 | 
20 | project('cvblob', ['cpp'],
21 |   version: '0.20.0',
22 |   meson_version: '>= 0.56.0',
23 |   license: 'LGPL',
24 |   default_options: [
25 |     'cpp_std=c++11',  # c++ 11 only
26 |     'warning_level=2',  # -Wall, -Wextra
27 |     'werror=true',  # -Werror
28 |   ],
29 | )
30 | 
31 | cflags = [
32 |   # '--add', '-Dstrings', 'here',
33 | ]
34 | 
35 | deps = [
36 |   dependency('opencv4', required : false),
37 | ]
38 | 
39 | src = files(
40 |   'cvBlob/cvb_aux.cpp',
41 |   'cvBlob/cvb_blob_list.cpp',
42 |   'cvBlob/cvb_blob.cpp',
43 |   'cvBlob/cvb_contour.cpp',
44 |   # 'cvBlob/cvb_track.cpp',
45 | )
46 | 
47 | includes = files(
48 |   'cvBlob/cvb_aux.h',
49 |   'cvBlob/cvb_blob_list.h',
50 |   'cvBlob/cvb_blob.h',
51 |   'cvBlob/cvb_contour.h',
52 |   'cvBlob/cvb_defines.h',
53 |   # 'cvBlob/cvb_track.h',
54 | )
55 | 
56 | # build shared and/or static targets
57 | # FIXME(mdegans): find a way to do this with just `library`
58 | default_library = get_option('default_library')
59 | if default_library == 'shared' or default_library == 'both'
60 |   libcvblob_so = shared_library(meson.project_name(), [src, includes],
61 |     dependencies: deps,
62 |     cpp_args: [
63 |       cflags,
64 |       '-fvisibility=hidden',
65 |       '-DCVB2_BUILD_SHARED',
66 |     ],
67 |     version: meson.project_version(),
68 |     install: true,
69 |   )
70 | elif default_library == 'static' or default_library == 'both'
71 |   libcvblob_a = static_library(meson.project_name(), src,
72 |     include_directories: includes,
73 |     dependencies: deps,
74 |     cpp_args: cflags,
75 |     version: meson.project_version(),
76 |     install: true,
77 |   )
78 | endif
79 | 
80 | # a dependency object for use as a Meson subproject
81 | cvblob_dep = declare_dependency(
82 |   dependencies: deps,
83 |   link_with: libcvblob_so,
84 | )
85 | 
86 | # generate pkg-config .pc
87 | pkg = import('pkgconfig')
88 | pkg.generate(libcvblob_so,
89 |   description: 'Find and track blobs using OpenCV',
90 |   requires: deps,
91 |   url: 'https://github.com/Steelskin/cvblob',
92 |   subdirs: meson.project_name(),
93 | )
94 | 


--------------------------------------------------------------------------------
/samples/Makefile:
--------------------------------------------------------------------------------
1 | all:	red_object_tracking
2 | 
3 | red_object_tracking: red_object_tracking.cpp
4 | 	g++ `pkg-config opencv cvblob --cflags --libs` red_object_tracking.cpp -o red_object_tracking
5 | 


--------------------------------------------------------------------------------
/samples/red_object_tracking.cpp:
--------------------------------------------------------------------------------
  1 | // Cristóbal Carnero Liñán <grendel.ccl@gmail.com>
  2 | 
  3 | #include <iostream>
  4 | #include <iomanip>
  5 | 
  6 | #if (defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) || (defined(__APPLE__) & defined(__MACH__)))
  7 | #include <cv.h>
  8 | #include <highgui.h>
  9 | #else
 10 | #include <opencv/cv.h>
 11 | #include <opencv/highgui.h>
 12 | #endif
 13 | 
 14 | #include <cvblob.h>
 15 | using namespace cvb;
 16 | 
 17 | int main()
 18 | {
 19 |   CvTracks tracks;
 20 | 
 21 |   cvNamedWindow("red_object_tracking", CV_WINDOW_AUTOSIZE);
 22 | 
 23 |   CvCapture *capture = cvCaptureFromCAM(0);
 24 |   cvGrabFrame(capture);
 25 |   IplImage *img = cvRetrieveFrame(capture);
 26 | 
 27 |   CvSize imgSize = cvGetSize(img);
 28 | 
 29 |   IplImage *frame = cvCreateImage(imgSize, img->depth, img->nChannels);
 30 | 
 31 |   IplConvKernel* morphKernel = cvCreateStructuringElementEx(5, 5, 1, 1, CV_SHAPE_RECT, NULL);
 32 | 
 33 |   //unsigned int frameNumber = 0;
 34 |   unsigned int blobNumber = 0;
 35 | 
 36 |   bool quit = false;
 37 |   while (!quit&&cvGrabFrame(capture))
 38 |   {
 39 |     IplImage *img = cvRetrieveFrame(capture);
 40 | 
 41 |     cvConvertScale(img, frame, 1, 0);
 42 | 
 43 |     IplImage *segmentated = cvCreateImage(imgSize, 8, 1);
 44 |     
 45 |     // Detecting red pixels:
 46 |     // (This is very slow, use direct access better...)
 47 |     for (unsigned int j=0; j<imgSize.height; j++)
 48 |       for (unsigned int i=0; i<imgSize.width; i++)
 49 |       {
 50 | 	CvScalar c = cvGet2D(frame, j, i);
 51 | 
 52 | 	double b = ((double)c.val[0])/255.;
 53 | 	double g = ((double)c.val[1])/255.;
 54 | 	double r = ((double)c.val[2])/255.;
 55 | 	unsigned char f = 255*((r>0.2+g)&&(r>0.2+b));
 56 | 
 57 | 	cvSet2D(segmentated, j, i, CV_RGB(f, f, f));
 58 |       }
 59 | 
 60 |     cvMorphologyEx(segmentated, segmentated, NULL, morphKernel, CV_MOP_OPEN, 1);
 61 | 
 62 |     //cvShowImage("segmentated", segmentated);
 63 | 
 64 |     IplImage *labelImg = cvCreateImage(cvGetSize(frame), IPL_DEPTH_LABEL, 1);
 65 | 
 66 |     CvBlobs blobs;
 67 |     unsigned int result = cvLabel(segmentated, labelImg, blobs);
 68 |     cvFilterByArea(blobs, 500, 1000000);
 69 |     cvRenderBlobs(labelImg, blobs, frame, frame, CV_BLOB_RENDER_BOUNDING_BOX);
 70 |     cvUpdateTracks(blobs, tracks, 200., 5);
 71 |     cvRenderTracks(tracks, frame, frame, CV_TRACK_RENDER_ID|CV_TRACK_RENDER_BOUNDING_BOX);
 72 | 
 73 |     cvShowImage("red_object_tracking", frame);
 74 | 
 75 |     /*std::stringstream filename;
 76 |     filename << "redobject_" << std::setw(5) << std::setfill('0') << frameNumber << ".png";
 77 |     cvSaveImage(filename.str().c_str(), frame);*/
 78 | 
 79 |     cvReleaseImage(&labelImg);
 80 |     cvReleaseImage(&segmentated);
 81 | 
 82 |     char k = cvWaitKey(10)&0xff;
 83 |     switch (k)
 84 |     {
 85 |       case 27:
 86 |       case 'q':
 87 |       case 'Q':
 88 |         quit = true;
 89 |         break;
 90 |       case 's':
 91 |       case 'S':
 92 |         for (CvBlobs::const_iterator it=blobs.begin(); it!=blobs.end(); ++it)
 93 |         {
 94 |           std::stringstream filename;
 95 |           filename << "redobject_blob_" << std::setw(5) << std::setfill('0') << blobNumber << ".png";
 96 |           cvSaveImageBlob(filename.str().c_str(), img, it->second);
 97 |           blobNumber++;
 98 | 
 99 |           std::cout << filename.str() << " saved!" << std::endl;
100 |         }
101 |         break;
102 |     }
103 | 
104 |     cvReleaseBlobs(blobs);
105 | 
106 |     //frameNumber++;
107 |   }
108 | 
109 |   cvReleaseStructuringElement(&morphKernel);
110 |   cvReleaseImage(&frame);
111 | 
112 |   cvDestroyWindow("red_object_tracking");
113 | 
114 |   return 0;
115 | }
116 | 


--------------------------------------------------------------------------------
/samples/red_object_tracking.txt:
--------------------------------------------------------------------------------
1 | This program captures video from default camera and detects and tracks red objects.
2 | 
3 | To compile: compile and install cvBlob, then execute "make" in this directory.
4 | 
5 | Keys:
6 | 
7 |   - Esc or "q": exit.
8 |   - "s": save images of blobs to files named "redobject_blob_#####.png".
9 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright (C) 2007 by Cristóbal Carnero Liñán
 2 | # grendel.ccl@gmail.com
 3 | #
 4 | # This file is part of cvBlob.
 5 | #
 6 | # cvBlob is free software: you can redistribute it and/or modify
 7 | # it under the terms of the Lesser GNU General Public License as published by
 8 | # the Free Software Foundation, either version 3 of the License, or
 9 | # (at your option) any later version.
10 | #
11 | # cvBlob is distributed in the hope that it will be useful,
12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | # Lesser GNU General Public License for more details.
15 | #
16 | # You should have received a copy of the Lesser GNU General Public License
17 | # along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
18 | #
19 | 
20 | find_package(OpenCV REQUIRED)
21 | 
22 | include_directories(${cvBlob_SOURCE_DIR}/cvBlob)
23 | 
24 | # TEST
25 | set(TEST_SRC test.cpp)
26 | 
27 | set_source_files_properties(${TEST_SRC}
28 |                             PROPERTIES
29 |                             COMPILE_FLAGS "-O3"
30 | )
31 | 
32 | add_executable(test ${TEST_SRC})
33 | 
34 | target_link_libraries(test cvblob)
35 | target_link_libraries(test ${OpenCV_LIBS})
36 | 
37 | # TEST_RANDOM
38 | set(TEST_RANDOM_SRC test_random.cpp)
39 | 
40 | set_source_files_properties(${TEST_RANDOM_SRC}
41 |                             PROPERTIES
42 |                             COMPILE_FLAGS "-O3"
43 | )
44 | 
45 | add_executable(test_random ${TEST_RANDOM_SRC})
46 | 
47 | target_link_libraries(test_random cvblob)
48 | target_link_libraries(test_random ${OpenCV_LIBS})
49 | 
50 | # TEST TRACKING
51 | set(TEST_TRACKING_SRC test_tracking.cpp)
52 | 
53 | set_source_files_properties(${TEST_TRACKING_SRC}
54 |                             PROPERTIES
55 |                             COMPILE_FLAGS "-O3"
56 | )
57 | 
58 | add_executable(test_tracking ${TEST_TRACKING_SRC})
59 | 
60 | target_link_libraries(test_tracking cvblob)
61 | target_link_libraries(test_tracking ${OpenCV_LIBS})
62 | 


--------------------------------------------------------------------------------
/test/EnterExitCrossingPaths2front_blobs.mpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Steelskin/cvblob/fedb45399c22d8dde44efd5d9853881a3c2e6330/test/EnterExitCrossingPaths2front_blobs.mpeg


--------------------------------------------------------------------------------
/test/EnterExitCrossingPaths2front_blobs.txt:
--------------------------------------------------------------------------------
1 | "EnterExitCrossingPaths2front_blobs.mpeg" is the result of foreground segmentation of the "EnterExitCrossingPaths2front" video
2 | from EC Funded CAVIAR project/IST 2001 37540, found at URL: http://homepages.inf.ed.ac.uk/rbf/CAVIAR/.
3 | 
4 | 


--------------------------------------------------------------------------------
/test/test.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // This file is part of cvBlob.
  5 | //
  6 | // cvBlob is free software: you can redistribute it and/or modify
  7 | // it under the terms of the Lesser GNU General Public License as published by
  8 | // the Free Software Foundation, either version 3 of the License, or
  9 | // (at your option) any later version.
 10 | //
 11 | // cvBlob is distributed in the hope that it will be useful,
 12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14 | // Lesser GNU General Public License for more details.
 15 | //
 16 | // You should have received a copy of the Lesser GNU General Public License
 17 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 18 | //
 19 | 
 20 | #include <iostream>
 21 | //#include <iomanip>
 22 | using namespace std;
 23 | 
 24 | #if (defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) || (defined(__APPLE__) & defined(__MACH__)))
 25 | #include <cv.h>
 26 | #include <highgui.h>
 27 | #else
 28 | #include <opencv/cv.h>
 29 | #include <opencv/highgui.h>
 30 | #endif
 31 | 
 32 | #include <cvblob.h>
 33 | using namespace cvb;
 34 | 
 35 | int main()
 36 | {
 37 |   IplImage *img = cvLoadImage("test.png", 1);
 38 | 
 39 |   cvSetImageROI(img, cvRect(100, 100, 800, 500));
 40 | 
 41 |   IplImage *grey = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1);
 42 |   cvCvtColor(img, grey, CV_BGR2GRAY);
 43 |   cvThreshold(grey, grey, 100, 255, CV_THRESH_BINARY);
 44 | 
 45 |   IplImage *labelImg = cvCreateImage(cvGetSize(grey),IPL_DEPTH_LABEL,1);
 46 | 
 47 |   CvBlobs blobs;
 48 |   unsigned int result = cvLabel(grey, labelImg, blobs);
 49 | 
 50 |   IplImage *imgOut = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 3); cvZero(imgOut);
 51 |   cvRenderBlobs(labelImg, blobs, img, imgOut);
 52 | 
 53 |   //unsigned int i = 0;
 54 | 
 55 |   // Render contours:
 56 |   for (CvBlobs::const_iterator it=blobs.begin(); it!=blobs.end(); ++it)
 57 |   {
 58 |     //cvRenderBlob(labelImg, (*it).second, img, imgOut);
 59 |     
 60 |     CvScalar meanColor = cvBlobMeanColor((*it).second, labelImg, img);
 61 |     cout << "Mean color: r=" << (unsigned int)meanColor.val[0] << ", g=" << (unsigned int)meanColor.val[1] << ", b=" << (unsigned int)meanColor.val[2] << endl;
 62 | 
 63 |     CvContourPolygon *polygon = cvConvertChainCodesToPolygon(&(*it).second->contour);
 64 | 
 65 |     CvContourPolygon *sPolygon = cvSimplifyPolygon(polygon, 10.);
 66 |     CvContourPolygon *cPolygon = cvPolygonContourConvexHull(sPolygon);
 67 | 
 68 |     cvRenderContourChainCode(&(*it).second->contour, imgOut);
 69 |     cvRenderContourPolygon(sPolygon, imgOut, CV_RGB(0, 0, 255));
 70 |     cvRenderContourPolygon(cPolygon, imgOut, CV_RGB(0, 255, 0));
 71 | 
 72 |     delete cPolygon;
 73 |     delete sPolygon;
 74 |     delete polygon;
 75 | 
 76 |     // Render internal contours:
 77 |     for (CvContoursChainCode::const_iterator jt=(*it).second->internalContours.begin(); jt!=(*it).second->internalContours.end(); ++jt)
 78 |       cvRenderContourChainCode((*jt), imgOut);
 79 | 
 80 |     //stringstream filename;
 81 |     //filename << "blob_" << setw(2) << setfill('0') << i++ << ".png";
 82 |     //cvSaveImageBlob(filename.str().c_str(), imgOut, (*it).second);
 83 |   }
 84 | 
 85 |   cvNamedWindow("test", 1);
 86 |   cvShowImage("test", imgOut);
 87 |   //cvShowImage("grey", grey);
 88 |   cvWaitKey(0);
 89 |   cvDestroyWindow("test");
 90 | 
 91 |   cvReleaseImage(&imgOut);
 92 |   cvReleaseImage(&grey);
 93 |   cvReleaseImage(&labelImg);
 94 |   cvReleaseImage(&img);
 95 | 
 96 |   cvReleaseBlobs(blobs);
 97 | 
 98 |   return 0;
 99 | }
100 | 


--------------------------------------------------------------------------------
/test/test.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Steelskin/cvblob/fedb45399c22d8dde44efd5d9853881a3c2e6330/test/test.png


--------------------------------------------------------------------------------
/test/test_random.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
  2 | // grendel.ccl@gmail.com
  3 | //
  4 | // This file is part of cvBlob.
  5 | //
  6 | // cvBlob is free software: you can redistribute it and/or modify
  7 | // it under the terms of the Lesser GNU General Public License as published by
  8 | // the Free Software Foundation, either version 3 of the License, or
  9 | // (at your option) any later version.
 10 | //
 11 | // cvBlob is distributed in the hope that it will be useful,
 12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14 | // Lesser GNU General Public License for more details.
 15 | //
 16 | // You should have received a copy of the Lesser GNU General Public License
 17 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
 18 | //
 19 | 
 20 | #include <iostream>
 21 | using namespace std;
 22 | 
 23 | #if (defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) || (defined(__APPLE__) & defined(__MACH__)))
 24 | #include <cv.h>
 25 | #include <highgui.h>
 26 | #else
 27 | #include <opencv/cv.h>
 28 | #include <opencv/highgui.h>
 29 | #endif
 30 | 
 31 | #ifndef _WIN32
 32 | #include <sys/time.h>
 33 | #else
 34 | #include <ctime>
 35 | #include <windows.h>
 36 | 
 37 | int gettimeofday (struct timeval *tv, void* tz)
 38 | {
 39 |   union
 40 |   {
 41 |     long long ns100;
 42 |     FILETIME ft;
 43 |   } now;
 44 | 
 45 |   GetSystemTimeAsFileTime (&now.ft);
 46 |   tv->tv_usec = (long) ((now.ns100 / 10LL) % 1000000LL);
 47 |   tv->tv_sec = (long) ((now.ns100 - 116444736000000000LL) / 10000000LL);
 48 |   return (0);
 49 | }
 50 | #endif
 51 | 
 52 | int diff_ms(timeval t1, timeval t2)
 53 | {
 54 |   return (((t1.tv_sec - t2.tv_sec) * 1000000) + (t1.tv_usec - t2.tv_usec) + 500)/1000;
 55 | }
 56 | 
 57 | #include <cvblob.h>
 58 | using namespace cvb;
 59 | 
 60 | int main()
 61 | {
 62 |   const unsigned int size = 500;
 63 |   const unsigned int numPixels = 100000;
 64 |   const unsigned int max_iter = 100;
 65 | 
 66 |   srand(time(NULL));
 67 | 
 68 |   IplImage *randomImg = cvCreateImage(cvSize(size, size), 8, 3);
 69 |   IplImage *randomBinImg = cvCreateImage(cvSize(size, size), 8, 1);
 70 | 
 71 |   IplImage *labelImg = cvCreateImage(cvGetSize(randomBinImg), IPL_DEPTH_LABEL, 1);
 72 | 
 73 |   cvNamedWindow("test", CV_WINDOW_AUTOSIZE);
 74 | 
 75 |   unsigned int iter = 0;
 76 | 
 77 |   double averTime = 0.;
 78 |   do
 79 |   {
 80 |     cvSet(randomBinImg, cvScalar(0));
 81 | 
 82 |     for (unsigned int i=1; i<numPixels; i++)
 83 |       cvSet2D(randomBinImg, rand() % size, rand() % size, cvScalar(255));
 84 | 
 85 |     cvSaveImage("test_random.png", randomBinImg);
 86 | 
 87 |     CvBlobs blobs;
 88 | 
 89 |     timeval tim1;
 90 |     gettimeofday(&tim1, NULL);
 91 |     unsigned int result = cvLabel(randomBinImg, labelImg, blobs);
 92 |     timeval tim2;
 93 |     gettimeofday(&tim2, NULL);
 94 | 
 95 |     unsigned int elapseTime = diff_ms(tim2, tim1);
 96 | 
 97 |     cout << " - " << blobs.size() << " blobs and " << result << " pixels: " << elapseTime << " miliseconds elapsed." << endl;
 98 | 
 99 |     iter++;
100 |     averTime = (1. - 1/((double)iter))*averTime + (1/((double)iter))*elapseTime;
101 | 
102 |     cvZero(randomImg);
103 | 
104 |     cvRenderBlobs(labelImg, blobs, randomImg, randomImg, CV_BLOB_RENDER_COLOR);
105 |     cvShowImage("test", randomImg);
106 | 
107 |     cvReleaseBlobs(blobs);
108 | 
109 |     if (((cvWaitKey(10)&0xff)==27)||(iter>=max_iter))
110 |       break;
111 |   }
112 |   while(true);
113 | 
114 |   cvDestroyWindow("test");
115 | 
116 |   cvReleaseImage(&randomBinImg);
117 |   cvReleaseImage(&randomImg);
118 |   cvReleaseImage(&labelImg);
119 | 
120 |   cout << endl;
121 |   cout << iter << " iterations." << endl;
122 |   cout << "Average cvLabel time: " << averTime << " miliseconds." << endl;
123 | 
124 |   return 0;
125 | }
126 | 


--------------------------------------------------------------------------------
/test/test_tracking.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (C) 2007 by Cristóbal Carnero Liñán
 2 | // grendel.ccl@gmail.com
 3 | //
 4 | // This file is part of cvBlob.
 5 | //
 6 | // cvBlob is free software: you can redistribute it and/or modify
 7 | // it under the terms of the Lesser GNU General Public License as published by
 8 | // the Free Software Foundation, either version 3 of the License, or
 9 | // (at your option) any later version.
10 | //
11 | // cvBlob is distributed in the hope that it will be useful,
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | // Lesser GNU General Public License for more details.
15 | //
16 | // You should have received a copy of the Lesser GNU General Public License
17 | // along with cvBlob.  If not, see <https://www.gnu.org/licenses/>.
18 | //
19 | 
20 | #include <iostream>
21 | 
22 | #if (defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) || (defined(__APPLE__) & defined(__MACH__)))
23 | #include <cv.h>
24 | #include <highgui.h>
25 | #else
26 | #include <opencv/cv.h>
27 | #include <opencv/highgui.h>
28 | #endif
29 | 
30 | #include <cvblob.h>
31 | using namespace cvb;
32 | 
33 | int main()
34 | {
35 |   CvTracks tracks;
36 | 
37 |   cvNamedWindow("test_tracking", CV_WINDOW_AUTOSIZE);
38 | 
39 |   CvCapture *capture=cvCreateFileCapture("EnterExitCrossingPaths2front_blobs.mpeg");
40 | 
41 |   cvGrabFrame(capture);
42 |   IplImage *img = cvRetrieveFrame(capture);
43 | 
44 |   IplImage *frame = cvCreateImage(cvGetSize(img), img->depth, img->nChannels);
45 | 
46 |   while (cvGrabFrame(capture))
47 |   {
48 |     IplImage *img = cvRetrieveFrame(capture);
49 | 
50 |     cvResetImageROI(frame);
51 |     cvConvertScale(img, frame, 1, 0);
52 |     cvThreshold(frame, frame, 100, 200, CV_THRESH_BINARY);
53 | 
54 |     cvSetImageROI(frame, cvRect(0, 25, 383, 287));
55 | 
56 |     IplImage *chB=cvCreateImage(cvGetSize(frame),8,1);
57 |     cvSplit(frame,chB,NULL,NULL,NULL);
58 | 
59 |     IplImage *labelImg = cvCreateImage(cvGetSize(frame), IPL_DEPTH_LABEL, 1);
60 | 
61 |     CvBlobs blobs;
62 |     unsigned int result = cvLabel(chB, labelImg, blobs);
63 | 
64 |     cvFilterByArea(blobs, 500, 1000);
65 | 
66 |     cvUpdateTracks(blobs, tracks, 5., 10);
67 |     //cvUpdateTracks(blobs, tracks, 10., 5);
68 | 
69 |     cvRenderBlobs(labelImg, blobs, frame, frame, CV_BLOB_RENDER_CENTROID|CV_BLOB_RENDER_BOUNDING_BOX);
70 |     cvRenderTracks(tracks, frame, frame, CV_TRACK_RENDER_ID|CV_TRACK_RENDER_BOUNDING_BOX|CV_TRACK_RENDER_TO_LOG);
71 | 
72 |     cvShowImage("test_tracking", frame);
73 | 
74 |     cvReleaseBlobs(blobs);
75 | 
76 |     cvReleaseImage(&chB);
77 |     cvReleaseImage(&labelImg);
78 | 
79 |     if ((cvWaitKey(10)&0xff)==27)
80 |       break;
81 |   }
82 | 
83 |   cvReleaseImage(&frame);
84 | 
85 |   cvDestroyWindow("test_tracking");
86 | 
87 |   return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/vc/TestDLL/TestDLL.cpp:
--------------------------------------------------------------------------------
 1 | // TestDLL.c : test of CvBlob DLL
 2 | //
 3 | 
 4 | #include <opencv2/highgui/highgui.hpp>
 5 | #include <opencv2/imgproc/imgproc.hpp>
 6 | #include <opencv2/features2d/features2d.hpp>
 7 | 
 8 | #include <cvb_blob_list.h>
 9 | 
10 | #include <Windows.h>
11 | 
12 | int main(int argc, char* argv[]) {
13 |     cv::Mat img = cv::imread("test.png", 1);
14 |     cv::Mat grey;
15 |     grey.create(img.size(), CV_8UC1);
16 |     cv::cvtColor(img, grey, CV_BGR2GRAY, 1);
17 |     cv::threshold(grey, grey, 0, 255, CV_THRESH_BINARY_INV + CV_THRESH_OTSU);
18 | 
19 |     LARGE_INTEGER freq;
20 |     LARGE_INTEGER t0, tF, tDiff;
21 |     double elapsedTime;
22 | 
23 |     // cvblob
24 |     QueryPerformanceFrequency(&freq);
25 |     QueryPerformanceCounter(&t0);
26 | 
27 |     cvb::BlobList blobs;
28 |     blobs.SimpleLabel(grey);
29 |     blobs.FilterByArea(50, img.cols * img.rows / 4);
30 | 
31 |     QueryPerformanceCounter(&tF);
32 |     tDiff.QuadPart = tF.QuadPart - t0.QuadPart;
33 |     elapsedTime = tDiff.QuadPart / (double) freq.QuadPart;
34 |     std::cout << "cvblob:" << elapsedTime << std::endl;
35 | 
36 |     for (auto &a_blob : blobs.get_BlobsList()) {
37 |         // extract and draws blob contour
38 |         auto contours = a_blob->get_Contour().get_ContourPolygon();
39 |         if (contours.size() != 1) {
40 |             for (auto &iter = contours.begin(); iter != contours.end(); iter++) {
41 |                 auto next_iter = iter;
42 |                 next_iter++;
43 |                 if (next_iter == contours.end())
44 |                     cv::line(img, *iter, contours[0], cv::Scalar(0, 0, 255), 1, 8);
45 |                 else
46 |                     cv::line(img, *iter, *next_iter, cv::Scalar(0, 0, 255), 1, 8);
47 |             }
48 |         }
49 | 
50 |         // extract and draws every blob internal hole contour
51 |         auto internal_contours = a_blob->get_InternalContours();
52 |         for (auto &a_contour : internal_contours) {
53 |             auto contour_dot = a_contour->get_ContourPolygon();
54 |             if (contour_dot.size() == 1)
55 |                 continue;
56 |             for (auto &iter = contour_dot.begin(); iter != contour_dot.end(); iter++) {
57 |                 auto next_iter = iter;
58 |                 next_iter++;
59 |                 if (next_iter == contour_dot.end())
60 |                     cv::line(img, *iter, contour_dot[0], cv::Scalar(0, 255, 0), 1, 8);
61 |                 else
62 |                     cv::line(img, *iter, *next_iter, cv::Scalar(0, 255, 0), 1, 8);
63 |             }
64 |         }
65 | 
66 |         // draws bounding box
67 |         cv::rectangle(img, a_blob->get_BoundingBox(), cv::Scalar(255, 0, 255));
68 | 
69 |         // draws centroid
70 |         cv::circle(img, a_blob->get_Centroid(), 2, cv::Scalar(255, 0, 0), 2);
71 |     };
72 | 
73 |     cv::imwrite("imggray.png", grey);
74 |     cv::imwrite("imgout.png", img);
75 |     cv::imwrite("imglabel.png", blobs.get_ImageLabel());
76 |     return 0;
77 | }
78 | 
79 | 
80 | 


--------------------------------------------------------------------------------
/vc/TestDLL/TestDLL.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Debug|x64">
  9 |       <Configuration>Debug</Configuration>
 10 |       <Platform>x64</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Release|Win32">
 13 |       <Configuration>Release</Configuration>
 14 |       <Platform>Win32</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <ProjectGuid>{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}</ProjectGuid>
 23 |     <RootNamespace>TestDLL</RootNamespace>
 24 |     <Keyword>Win32Proj</Keyword>
 25 |   </PropertyGroup>
 26 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 27 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 28 |     <ConfigurationType>Application</ConfigurationType>
 29 |     <PlatformToolset>v110_xp</PlatformToolset>
 30 |     <CharacterSet>Unicode</CharacterSet>
 31 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 32 |   </PropertyGroup>
 33 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 34 |     <ConfigurationType>Application</ConfigurationType>
 35 |     <PlatformToolset>v110</PlatformToolset>
 36 |     <CharacterSet>Unicode</CharacterSet>
 37 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 38 |   </PropertyGroup>
 39 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 40 |     <ConfigurationType>Application</ConfigurationType>
 41 |     <PlatformToolset>v110_xp</PlatformToolset>
 42 |     <CharacterSet>Unicode</CharacterSet>
 43 |   </PropertyGroup>
 44 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 45 |     <ConfigurationType>Application</ConfigurationType>
 46 |     <PlatformToolset>v110</PlatformToolset>
 47 |     <CharacterSet>Unicode</CharacterSet>
 48 |   </PropertyGroup>
 49 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 50 |   <ImportGroup Label="ExtensionSettings">
 51 |   </ImportGroup>
 52 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
 53 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 54 |   </ImportGroup>
 55 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
 56 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 57 |   </ImportGroup>
 58 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
 59 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 60 |   </ImportGroup>
 61 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
 62 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 63 |   </ImportGroup>
 64 |   <PropertyGroup Label="UserMacros" />
 65 |   <PropertyGroup>
 66 |     <_ProjectFileVersion>11.0.60610.1</_ProjectFileVersion>
 67 |   </PropertyGroup>
 68 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 69 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 70 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 71 |     <LinkIncremental>true</LinkIncremental>
 72 |   </PropertyGroup>
 73 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 74 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 75 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 76 |     <LinkIncremental>true</LinkIncremental>
 77 |   </PropertyGroup>
 78 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 79 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 80 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 81 |     <LinkIncremental>false</LinkIncremental>
 82 |   </PropertyGroup>
 83 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 84 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 85 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 86 |     <LinkIncremental>false</LinkIncremental>
 87 |   </PropertyGroup>
 88 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 89 |     <ClCompile>
 90 |       <Optimization>Disabled</Optimization>
 91 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;$(SolutionDir)..\cvBlob\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
 92 |       <MinimalRebuild>true</MinimalRebuild>
 93 |       <OpenMPSupport>false</OpenMPSupport>
 94 |       <PrecompiledHeader />
 95 |       <WarningLevel>Level3</WarningLevel>
 96 |     </ClCompile>
 97 |     <Link>
 98 |       <AdditionalDependencies>cvBlob.lib;opencv_core246d.lib;opencv_highgui246d.lib;opencv_imgproc246d.lib;opencv_features2d246d.lib;%(AdditionalDependencies)</AdditionalDependencies>
 99 |       <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Configuration)_$(Platform)\;$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
100 |       <GenerateDebugInformation>true</GenerateDebugInformation>
101 |       <SubSystem>Console</SubSystem>
102 |       <TargetMachine>MachineX86</TargetMachine>
103 |     </Link>
104 |   </ItemDefinitionGroup>
105 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
106 |     <ClCompile>
107 |       <Optimization>Disabled</Optimization>
108 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;$(SolutionDir)..\cvBlob\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
109 |       <OpenMPSupport>false</OpenMPSupport>
110 |       <PrecompiledHeader>
111 |       </PrecompiledHeader>
112 |       <WarningLevel>Level3</WarningLevel>
113 |     </ClCompile>
114 |     <Link>
115 |       <AdditionalDependencies>cvBlob.lib;opencv_core246d.lib;opencv_highgui246d.lib;opencv_imgproc246d.lib;opencv_features2d246d.lib;%(AdditionalDependencies)</AdditionalDependencies>
116 |       <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Configuration)_$(Platform)\;$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
117 |       <GenerateDebugInformation>true</GenerateDebugInformation>
118 |       <SubSystem>Console</SubSystem>
119 |     </Link>
120 |   </ItemDefinitionGroup>
121 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
122 |     <ClCompile>
123 |       <Optimization>MaxSpeed</Optimization>
124 |       <IntrinsicFunctions>true</IntrinsicFunctions>
125 |       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
126 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;$(SolutionDir)..\cvBlob\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
127 |       <FunctionLevelLinking>true</FunctionLevelLinking>
128 |       <OpenMPSupport>true</OpenMPSupport>
129 |       <PrecompiledHeader />
130 |       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
131 |       <WarningLevel>Level3</WarningLevel>
132 |     </ClCompile>
133 |     <Link>
134 |       <AdditionalDependencies>cvBlob.lib;opencv_core246.lib;opencv_highgui246.lib;opencv_imgproc246.lib;opencv_features2d246.lib;%(AdditionalDependencies)</AdditionalDependencies>
135 |       <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Configuration)_$(Platform)\;$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
136 |       <GenerateDebugInformation>true</GenerateDebugInformation>
137 |       <SubSystem>Console</SubSystem>
138 |       <OptimizeReferences>true</OptimizeReferences>
139 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
140 |       <TargetMachine>MachineX86</TargetMachine>
141 |     </Link>
142 |   </ItemDefinitionGroup>
143 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
144 |     <ClCompile>
145 |       <Optimization>MaxSpeed</Optimization>
146 |       <IntrinsicFunctions>true</IntrinsicFunctions>
147 |       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
148 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;$(SolutionDir)..\cvBlob\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
149 |       <FunctionLevelLinking>true</FunctionLevelLinking>
150 |       <OpenMPSupport>true</OpenMPSupport>
151 |       <PrecompiledHeader>
152 |       </PrecompiledHeader>
153 |       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
154 |       <WarningLevel>Level3</WarningLevel>
155 |     </ClCompile>
156 |     <Link>
157 |       <AdditionalDependencies>cvBlob.lib;opencv_core246.lib;opencv_highgui246.lib;opencv_imgproc246.lib;opencv_features2d246.lib;%(AdditionalDependencies)</AdditionalDependencies>
158 |       <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Configuration)_$(Platform)\;$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
159 |       <GenerateDebugInformation>true</GenerateDebugInformation>
160 |       <SubSystem>Console</SubSystem>
161 |       <OptimizeReferences>true</OptimizeReferences>
162 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
163 |     </Link>
164 |   </ItemDefinitionGroup>
165 |   <ItemGroup>
166 |     <ClCompile Include="TestDLL.cpp" />
167 |   </ItemGroup>
168 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
169 |   <ImportGroup Label="ExtensionTargets">
170 |   </ImportGroup>
171 | </Project>


--------------------------------------------------------------------------------
/vc/TestDLL/TestDLL.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |   </ItemGroup>
13 |   <ItemGroup>
14 |     <ClCompile Include="TestDLL.cpp">
15 |       <Filter>Source Files</Filter>
16 |     </ClCompile>
17 |   </ItemGroup>
18 | </Project>


--------------------------------------------------------------------------------
/vc/TestDLL/test.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Steelskin/cvblob/fedb45399c22d8dde44efd5d9853881a3c2e6330/vc/TestDLL/test.png


--------------------------------------------------------------------------------
/vc/cvBlob.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 2012
 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TestDLL", "TestDLL\TestDLL.vcxproj", "{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}"
 5 | 	ProjectSection(ProjectDependencies) = postProject
 6 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A} = {6C6BC40E-2890-4FAB-9130-C6805FADD06A}
 7 | 	EndProjectSection
 8 | EndProject
 9 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cvBlob", "cvBlob\cvBlob.vcxproj", "{6C6BC40E-2890-4FAB-9130-C6805FADD06A}"
10 | EndProject
11 | Global
12 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
13 | 		Debug|Win32 = Debug|Win32
14 | 		Debug|x64 = Debug|x64
15 | 		Release|Win32 = Release|Win32
16 | 		Release|x64 = Release|x64
17 | 	EndGlobalSection
18 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
19 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Debug|Win32.ActiveCfg = Debug|Win32
20 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Debug|Win32.Build.0 = Debug|Win32
21 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Debug|x64.ActiveCfg = Debug|x64
22 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Debug|x64.Build.0 = Debug|x64
23 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Release|Win32.ActiveCfg = Release|Win32
24 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Release|Win32.Build.0 = Release|Win32
25 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Release|x64.ActiveCfg = Release|x64
26 | 		{6AEDAC52-A641-466A-80EC-E9B4942DE4BB}.Release|x64.Build.0 = Release|x64
27 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Debug|Win32.ActiveCfg = Debug|Win32
28 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Debug|Win32.Build.0 = Debug|Win32
29 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Debug|x64.ActiveCfg = Debug|x64
30 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Debug|x64.Build.0 = Debug|x64
31 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Release|Win32.ActiveCfg = Release|Win32
32 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Release|Win32.Build.0 = Release|Win32
33 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Release|x64.ActiveCfg = Release|x64
34 | 		{6C6BC40E-2890-4FAB-9130-C6805FADD06A}.Release|x64.Build.0 = Release|x64
35 | 	EndGlobalSection
36 | 	GlobalSection(SolutionProperties) = preSolution
37 | 		HideSolutionNode = FALSE
38 | 	EndGlobalSection
39 | EndGlobal
40 | 


--------------------------------------------------------------------------------
/vc/cvBlob/cvBlob.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Debug|x64">
  9 |       <Configuration>Debug</Configuration>
 10 |       <Platform>x64</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Release|Win32">
 13 |       <Configuration>Release</Configuration>
 14 |       <Platform>Win32</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <ProjectGuid>{6C6BC40E-2890-4FAB-9130-C6805FADD06A}</ProjectGuid>
 23 |     <RootNamespace>cvBlob</RootNamespace>
 24 |   </PropertyGroup>
 25 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 26 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 27 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 28 |     <UseDebugLibraries>true</UseDebugLibraries>
 29 |     <PlatformToolset>v110_xp</PlatformToolset>
 30 |     <CharacterSet>Unicode</CharacterSet>
 31 |   </PropertyGroup>
 32 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 33 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 34 |     <UseDebugLibraries>true</UseDebugLibraries>
 35 |     <PlatformToolset>v110</PlatformToolset>
 36 |     <CharacterSet>Unicode</CharacterSet>
 37 |   </PropertyGroup>
 38 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 39 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 40 |     <UseDebugLibraries>false</UseDebugLibraries>
 41 |     <PlatformToolset>v110_xp</PlatformToolset>
 42 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 43 |     <CharacterSet>Unicode</CharacterSet>
 44 |   </PropertyGroup>
 45 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 46 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 47 |     <UseDebugLibraries>false</UseDebugLibraries>
 48 |     <PlatformToolset>v110</PlatformToolset>
 49 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 50 |     <CharacterSet>Unicode</CharacterSet>
 51 |   </PropertyGroup>
 52 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 53 |   <ImportGroup Label="ExtensionSettings">
 54 |   </ImportGroup>
 55 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 56 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 57 |   </ImportGroup>
 58 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
 59 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 60 |   </ImportGroup>
 61 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 62 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 63 |   </ImportGroup>
 64 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
 65 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 66 |   </ImportGroup>
 67 |   <PropertyGroup Label="UserMacros" />
 68 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 69 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 70 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 71 |   </PropertyGroup>
 72 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 73 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 74 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 75 |   </PropertyGroup>
 76 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 77 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 78 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 79 |   </PropertyGroup>
 80 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 81 |     <OutDir>$(SolutionDir)bin\$(Configuration)_$(Platform)\</OutDir>
 82 |     <IntDir>obj\$(Configuration)_$(Platform)\</IntDir>
 83 |   </PropertyGroup>
 84 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 85 |     <ClCompile>
 86 |       <WarningLevel>Level3</WarningLevel>
 87 |       <Optimization>Disabled</Optimization>
 88 |       <SDLCheck>true</SDLCheck>
 89 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
 90 |       <DisableSpecificWarnings>4251</DisableSpecificWarnings>
 91 |       <PreprocessorDefinitions>CVBLOB_LIB;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 92 |     </ClCompile>
 93 |     <Link>
 94 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 95 |       <AdditionalLibraryDirectories>$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
 96 |       <AdditionalDependencies>opencv_core246d.lib;opencv_highgui246d.lib;%(AdditionalDependencies)</AdditionalDependencies>
 97 |     </Link>
 98 |   </ItemDefinitionGroup>
 99 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
100 |     <ClCompile>
101 |       <WarningLevel>Level3</WarningLevel>
102 |       <Optimization>Disabled</Optimization>
103 |       <SDLCheck>true</SDLCheck>
104 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
105 |       <DisableSpecificWarnings>4251</DisableSpecificWarnings>
106 |       <PreprocessorDefinitions>CVBLOB_LIB;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
107 |     </ClCompile>
108 |     <Link>
109 |       <GenerateDebugInformation>true</GenerateDebugInformation>
110 |       <AdditionalLibraryDirectories>$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
111 |       <AdditionalDependencies>opencv_core246d.lib;opencv_highgui246d.lib;%(AdditionalDependencies)</AdditionalDependencies>
112 |     </Link>
113 |   </ItemDefinitionGroup>
114 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
115 |     <ClCompile>
116 |       <WarningLevel>Level3</WarningLevel>
117 |       <Optimization>MaxSpeed</Optimization>
118 |       <FunctionLevelLinking>true</FunctionLevelLinking>
119 |       <IntrinsicFunctions>true</IntrinsicFunctions>
120 |       <SDLCheck>true</SDLCheck>
121 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
122 |       <DisableSpecificWarnings>4251</DisableSpecificWarnings>
123 |       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
124 |       <OpenMPSupport>true</OpenMPSupport>
125 |       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
126 |       <PreprocessorDefinitions>CVBLOB_LIB;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
127 |     </ClCompile>
128 |     <Link>
129 |       <GenerateDebugInformation>true</GenerateDebugInformation>
130 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
131 |       <OptimizeReferences>true</OptimizeReferences>
132 |       <AdditionalLibraryDirectories>$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
133 |       <AdditionalDependencies>opencv_core246.lib;opencv_highgui246.lib;%(AdditionalDependencies)</AdditionalDependencies>
134 |     </Link>
135 |   </ItemDefinitionGroup>
136 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
137 |     <ClCompile>
138 |       <WarningLevel>Level3</WarningLevel>
139 |       <Optimization>MaxSpeed</Optimization>
140 |       <FunctionLevelLinking>true</FunctionLevelLinking>
141 |       <IntrinsicFunctions>true</IntrinsicFunctions>
142 |       <SDLCheck>true</SDLCheck>
143 |       <AdditionalIncludeDirectories>$(OPENCV_DIR)\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
144 |       <DisableSpecificWarnings>4251</DisableSpecificWarnings>
145 |       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
146 |       <OpenMPSupport>true</OpenMPSupport>
147 |       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
148 |       <PreprocessorDefinitions>CVBLOB_LIB;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
149 |     </ClCompile>
150 |     <Link>
151 |       <GenerateDebugInformation>true</GenerateDebugInformation>
152 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
153 |       <OptimizeReferences>true</OptimizeReferences>
154 |       <AdditionalLibraryDirectories>$(OPENCV_DIR)\$(PlatformShortName)\$(PlatformToolset)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
155 |       <AdditionalDependencies>opencv_core246.lib;opencv_highgui246.lib;%(AdditionalDependencies)</AdditionalDependencies>
156 |     </Link>
157 |   </ItemDefinitionGroup>
158 |   <ItemGroup>
159 |     <ClCompile Include="..\..\cvBlob\cvb_aux.cpp" />
160 |     <ClCompile Include="..\..\cvBlob\cvb_blob.cpp" />
161 |     <ClCompile Include="..\..\cvBlob\cvb_blob_list.cpp" />
162 |     <ClCompile Include="..\..\cvBlob\cvb_contour.cpp" />
163 |   </ItemGroup>
164 |   <ItemGroup>
165 |     <ClInclude Include="..\..\cvBlob\cvb_aux.h" />
166 |     <ClInclude Include="..\..\cvBlob\cvb_blob_list.h" />
167 |     <ClInclude Include="..\..\cvBlob\cvb_contour.h" />
168 |     <ClInclude Include="..\..\cvBlob\cvb_blob.h" />
169 |     <ClInclude Include="..\..\cvBlob\cvb_defines.h" />
170 |   </ItemGroup>
171 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
172 |   <ImportGroup Label="ExtensionTargets">
173 |   </ImportGroup>
174 | </Project>


--------------------------------------------------------------------------------
/vc/cvBlob/cvBlob.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |   </ItemGroup>
13 |   <ItemGroup>
14 |     <ClCompile Include="..\..\cvBlob\cvb_aux.cpp">
15 |       <Filter>Source Files</Filter>
16 |     </ClCompile>
17 |     <ClCompile Include="..\..\cvBlob\cvb_blob.cpp">
18 |       <Filter>Source Files</Filter>
19 |     </ClCompile>
20 |     <ClCompile Include="..\..\cvBlob\cvb_blob_list.cpp">
21 |       <Filter>Source Files</Filter>
22 |     </ClCompile>
23 |     <ClCompile Include="..\..\cvBlob\cvb_contour.cpp">
24 |       <Filter>Source Files</Filter>
25 |     </ClCompile>
26 |   </ItemGroup>
27 |   <ItemGroup>
28 |     <ClInclude Include="..\..\cvBlob\cvb_aux.h">
29 |       <Filter>Header Files</Filter>
30 |     </ClInclude>
31 |     <ClInclude Include="..\..\cvBlob\cvb_blob_list.h">
32 |       <Filter>Header Files</Filter>
33 |     </ClInclude>
34 |     <ClInclude Include="..\..\cvBlob\cvb_contour.h">
35 |       <Filter>Header Files</Filter>
36 |     </ClInclude>
37 |     <ClInclude Include="..\..\cvBlob\cvb_blob.h">
38 |       <Filter>Header Files</Filter>
39 |     </ClInclude>
40 |     <ClInclude Include="..\..\cvBlob\cvb_defines.h">
41 |       <Filter>Header Files</Filter>
42 |     </ClInclude>
43 |   </ItemGroup>
44 | </Project>


--------------------------------------------------------------------------------