ocrad-0.22/AUTHORS0000644000076400001440000000015710164067322012153 0ustar yousersGNU Ocrad was written by Antonio Diaz Diaz. Thanks to Klaas Freitag for his ideas about the ORF file feature. ocrad-0.22/COPYING0000644000076400001440000010437410641002347012140 0ustar yousers GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . ocrad-0.22/ChangeLog0000644000076400001440000001611412166633570012665 0ustar yousers2013-07-09 Antonio Diaz Diaz * Version 0.22 released. * Scaling and smoothing are now made before thresholding. * Improvements in character recognition. * ocradlib.h: Added new function OCRAD_set_utf8_format. * Small improvements have been made in manual and man page. * Changed quote characters in messages as advised by GNU Standards. * configure: Options now accept a separate argument. * configure: 'datadir' renamed to 'datarootdir'. * Makefile.in: Added new target 'install-bin'. 2011-01-10 Antonio Diaz Diaz * Version 0.21 released. * Fixed some internal errors triggered by noisy input. * ocrad.texinfo: Added chapter 'OCR Results File'. * main.cc: Set stdin/stdout in binary mode on MSVC and OS2. 2010-07-16 Antonio Diaz Diaz * Version 0.20 released. * ocradlib.h: Added new function OCRAD_scale. * ocradlib.h: Added new function OCRAD_result_chars_total. * ocradlib.h: Added new function OCRAD_result_chars_block. * ocradlib.h: Added new function OCRAD_result_chars_line. 2010-01-27 Antonio Diaz Diaz * Version 0.19 released. * Added library interface (ocradlib.h). * Option '--crop' replaced with similar but different option '--cut', which can accept coordinates taken from the ORF file. * Recognition of files with a single character and without white space at the edges has been fixed. * testsuite/check.sh: Added new tests for the library interface and for single character images. * New files ocradlib.h, ocradlib.cc, ocrcheck.cc. * Makefile.in: Added '--name' option to help2man invocation. 2009-05-08 Antonio Diaz Diaz * Version 0.18 released. * Added a layout analyser able to process arbitrary pages. * Added new option '--quiet'. * The '--layout' option no more accepts an argument. * The '--crop' option now accepts negative coordinates. * New recognized letter; 'a' with ring above. * Fixed recognition on files with a single big character. * Fixed bug that didn't write maxval when saving pgm or ppm. * Fixed some includes that prevented compilation with GCC 4.3.0. * 'make install-info' should now work on Debian and OS X. * Makefile.in: Man page is now installed by default. * New file testsuite/check.sh. * Arg_parser updated to 1.2. * Verbosity control of messages has been modified. 2007-06-29 Antonio Diaz Diaz * Version 0.17 released. * License updated to GPL version 3 or later. * '--scale' no more suppresses ORF output. * Improved removal of thick frames. * Changed 'Textline' to accept more than one big initial. * Class 'Block' renamed to 'Blob'. * 'configure' and 'Makefile.in' have been modified to be more GNU-standards compliant. 2006-10-20 Antonio Diaz Diaz * Version 0.16 released. * Added new option '--filter'. * Better algorithm for vertical space detection (blank lines). * Some fixes made to 'configure' script. * Added two new debug levels. * Improvements in character recognition. 2006-04-03 Antonio Diaz Diaz * Version 0.15 released. * Added new argument parser that replaces 'getopt_long'. * Fixed a bug that prevented compilation with GCC 4.1. 2006-02-15 Antonio Diaz Diaz * Version 0.14 released. * Ocrad is now able to read ppm files. * Added new class 'Page_image' (256-level greymap). * Added automatic and adaptive binarization by Otsu's method. * Added new option '--crop'. * Added two new chapters 'Image Format Conversion' and 'Algorithm' to the texinfo file. * Target 'check' added to Makefile. * Changed 'ocrad.png' icon to color, one line. 2005-10-10 Antonio Diaz Diaz * Version 0.13 released. * Ocrad is now able to read pgm files. * Added new rational number class. * Use rationals instead of integers in space detection algorithm. * Better algorithm for space detection in tables. * 'vector' replaced by 'vector' in bitmap (faster). * Variable-size arrays replaced by vectors in block.cc. * Fixed sizeof(size_t) != sizeof(int) on some 64 bit systems. * Improved number recognition (mainly in textline_r2.cc). * Overflow detection when loading or scaling file. * Fixed a miscompilation with GCC 3.3.1. * Class 'Vrhomboid' merged into files 'track.h' and 'track.cc'. 2005-06-07 Antonio Diaz Diaz * Version 0.12 released. * Change in internal representation; Blockmap has been eliminated. * Text inside tables of solid lines is now recognized. * Improvements in character recognition. * Fixed possible integer overflow when loading pbm file. 2005-02-12 Antonio Diaz Diaz * Version 0.11 released. * Added new option '--scale'. * Improvements in character recognition. * Fixed bug in '--transform' (introduced in 0.10). 2004-12-09 Antonio Diaz Diaz * Version 0.10 released. * Added new suboption '-D7X'. * Change in internal representation; only 1 Blockmap per Textpage. * Use of absolute coordinates in ORF file. * Improved space detection algorithm. * Improvements in character recognition and separation. 2004-10-23 Antonio Diaz Diaz * Version 0.9 released. * Added new option '--transform'. * 'DESTDIR' now works as expected. * New class 'Textpage' is top of internal representation. 2004-05-23 Antonio Diaz Diaz * Version 0.8 released. * Better algorithm for line detection. * New feature '-x -' (export ORF file to stdout). * Small improvements in picture elimination. 2004-02-09 Antonio Diaz Diaz * Version 0.7 released. * Internal change to UCS instead of ISO 8859-1. * Default charset is now ISO 8859-15 (latin9). * Ocrad now recognizes Turkish characters (ISO 8859-9). * Added new output format (UTF-8). * Added new options '--charset' and '--format'. * Added man page. 2003-12-18 Antonio Diaz Diaz * Version 0.6 released. * 'configure' is now compatible with 'sh'. * Better algorithm for lowercase-uppercase decision. * Small changes to line detector. * Fixed bug (output of char 0 when separating some merged chars). 2003-10-18 Antonio Diaz Diaz * Version 0.5 released. * Corrected bug when creating ORF file from stdin. * Added the ability to read multiple files from stdin. * Use 'vector' instead of 'list' due to problem with GCC 3.3.1. * Faster 'processing' of pictures. 2003-09-03 Antonio Diaz Diaz * Version 0.4 released. * More standard configure and Makefile. * Added info file. * Small changes to layout detector. * Character codes > 127 now in ISO_8859_1:: format. * Added new option '--invert'. 2003-07-19 Antonio Diaz Diaz * Version 0.3 released. * ORF file feature added. * Recursive 'layout detector' added. Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This file is a collection of facts, and thus it is not copyrightable, but just in case, you have unlimited permission to copy, distribute and modify it. ocrad-0.22/INSTALL0000644000076400001440000000336512154113151012131 0ustar yousersRequirements ------------ You will need a C++ compiler. I use gcc 4.8.1 and 3.3.6, but the code should compile with any standards compliant compiler. Gcc is available at http://gcc.gnu.org. Procedure --------- 1. Unpack the archive if you have not done so already: lzip -cd ocrad[version].tar.lz | tar -xf - or gzip -cd ocrad[version].tar.gz | tar -xf - This creates the directory ./ocrad[version] containing the source from the main archive. 2. Change to ocrad directory and run configure. (Try 'configure --help' for usage instructions). cd ocrad[version] ./configure 3. Run make. make 4. Optionally, type 'make check' to run the tests that come with ocrad. 5. Type 'make install' to install the program, the library and any data files and documentation. You can install only the program, the info manual or the man page typing 'make install-bin', 'make install-info' or 'make install-man' respectively. Another way ----------- You can also compile ocrad into a separate directory. To do this, you must use a version of 'make' that supports the 'VPATH' variable, such as GNU 'make'. 'cd' to the directory where you want the object files and executables to go and run the 'configure' script. 'configure' automatically checks for the source code in '.', in '..' and in the directory that 'configure' is in. 'configure' recognizes the option '--srcdir=DIR' to control where to look for the sources. Usually 'configure' can determine that directory automatically. After running 'configure', you can run 'make' and 'make install' as explained above. Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This file is free documentation: you have unlimited permission to copy, distribute and modify it. ocrad-0.22/Makefile.in0000644000076400001440000001263412150250067013150 0ustar yousers DISTNAME = $(pkgname)-$(pkgversion) AR = ar INSTALL = install INSTALL_PROGRAM = $(INSTALL) -p -m 755 INSTALL_DATA = $(INSTALL) -p -m 644 INSTALL_DIR = $(INSTALL) -d -m 755 SHELL = /bin/sh lib_objs = ocradlib.o ocr_objs = common.o segment.o mask.o rational.o rectangle.o track.o \ ucs.o page_image.o page_image_io.o \ bitmap.o blob.o profile.o feats.o feats_test0.o feats_test1.o \ character.o character_r11.o character_r12.o character_r13.o \ textline.o textline_r2.o textblock.o textpage.o objs = arg_parser.o main.o .PHONY : all install install-bin install-info install-man install-strip \ uninstall uninstall-bin uninstall-info uninstall-man \ doc info man check dist clean distclean all : $(progname) lib$(libname).a lib$(libname).a: $(ocr_objs) $(lib_objs) $(AR) -rcs $@ $(ocr_objs) $(lib_objs) $(progname) : $(ocr_objs) $(objs) $(CXX) $(LDFLAGS) -o $@ $(ocr_objs) $(objs) $(progname)_profiled : $(ocr_objs) $(objs) $(CXX) $(LDFLAGS) -pg -o $@ $(ocr_objs) $(objs) ocrcheck : ocrcheck.o lib$(libname).a $(CXX) $(LDFLAGS) -o $@ ocrcheck.o lib$(libname).a ocrcheck.o : ocrcheck.cc $(CXX) $(CPPFLAGS) $(CXXFLAGS) -DPROGVERSION=\"$(pkgversion)\" -c -o $@ $< main.o : main.cc $(CXX) $(CPPFLAGS) $(CXXFLAGS) -DPROGVERSION=\"$(pkgversion)\" -c -o $@ $< %.o : %.cc $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $< $(lib_objs) : Makefile ocradlib.h $(ocr_objs) : Makefile bitmap.h blob.h common.h rectangle.h ucs.h $(objs) : Makefile arg_parser.h character.o : character.h character_r11.o : segment.h character.h profile.h feats.h character_r12.o : segment.h character.h profile.h feats.h character_r13.o : segment.h character.h profile.h feats.h feats.o : segment.h profile.h feats.h feats_test0.o : segment.h profile.h feats.h feats_test1.o : segment.h profile.h feats.h main.o : common.h rational.h rectangle.h page_image.h textpage.h mask.o : segment.h mask.h ocradlib.o : common.h rectangle.h ucs.h track.h bitmap.h blob.h character.h page_image.h textline.h textblock.h textpage.h page_image.o : ocradlib.h rational.h segment.h mask.h track.h page_image.h page_image_io.o : rational.h page_image.h profile.o : profile.h rational.o : rational.h segment.o : segment.h textblock.o : rational.h track.h character.h page_image.h textline.h textblock.h textline.o : rational.h track.h character.h page_image.h textline.h textline_r2.o : track.h character.h textline.h textpage.o : segment.h mask.h track.h character.h page_image.h textline.h textblock.h textpage.h track.o : track.h ocrcheck.o : Makefile ocradlib.h doc : info man info : $(VPATH)/doc/$(pkgname).info $(VPATH)/doc/$(pkgname).info : $(VPATH)/doc/$(pkgname).texinfo cd $(VPATH)/doc && makeinfo $(pkgname).texinfo man : $(VPATH)/doc/$(progname).1 $(VPATH)/doc/$(progname).1 : $(progname) help2man -n 'command line text recognition tool' \ -o $@ ./$(progname) Makefile : $(VPATH)/configure $(VPATH)/Makefile.in ./config.status check : all ocrcheck @$(VPATH)/testsuite/check.sh $(VPATH)/testsuite $(pkgversion) install : install-bin install-info install-man install-bin : all if [ ! -d "$(DESTDIR)$(bindir)" ] ; then $(INSTALL_DIR) "$(DESTDIR)$(bindir)" ; fi if [ ! -d "$(DESTDIR)$(includedir)" ] ; then $(INSTALL_DIR) "$(DESTDIR)$(includedir)" ; fi if [ ! -d "$(DESTDIR)$(libdir)" ] ; then $(INSTALL_DIR) "$(DESTDIR)$(libdir)" ; fi $(INSTALL_PROGRAM) ./$(progname) "$(DESTDIR)$(bindir)/$(progname)" $(INSTALL_DATA) $(VPATH)/$(libname)lib.h "$(DESTDIR)$(includedir)/$(libname)lib.h" $(INSTALL_DATA) ./lib$(libname).a "$(DESTDIR)$(libdir)/lib$(libname).a" install-info : if [ ! -d "$(DESTDIR)$(infodir)" ] ; then $(INSTALL_DIR) "$(DESTDIR)$(infodir)" ; fi $(INSTALL_DATA) $(VPATH)/doc/$(pkgname).info "$(DESTDIR)$(infodir)/$(pkgname).info" -install-info --info-dir="$(DESTDIR)$(infodir)" "$(DESTDIR)$(infodir)/$(pkgname).info" install-man : if [ ! -d "$(DESTDIR)$(mandir)/man1" ] ; then $(INSTALL_DIR) "$(DESTDIR)$(mandir)/man1" ; fi $(INSTALL_DATA) $(VPATH)/doc/$(progname).1 "$(DESTDIR)$(mandir)/man1/$(progname).1" install-strip : all $(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' install uninstall : uninstall-bin uninstall-info uninstall-man uninstall-bin : -rm -f "$(DESTDIR)$(bindir)/$(progname)" -rm -f "$(DESTDIR)$(includedir)/$(libname)lib.h" -rm -f "$(DESTDIR)$(libdir)/lib$(libname).a" uninstall-info : -install-info --info-dir="$(DESTDIR)$(infodir)" --remove "$(DESTDIR)$(infodir)/$(pkgname).info" -rm -f "$(DESTDIR)$(infodir)/$(pkgname).info" uninstall-man : -rm -f "$(DESTDIR)$(mandir)/man1/$(progname).1" dist : doc ln -sf $(VPATH) $(DISTNAME) tar -cvf $(DISTNAME).tar \ $(DISTNAME)/AUTHORS \ $(DISTNAME)/COPYING \ $(DISTNAME)/ChangeLog \ $(DISTNAME)/INSTALL \ $(DISTNAME)/Makefile.in \ $(DISTNAME)/NEWS \ $(DISTNAME)/README \ $(DISTNAME)/configure \ $(DISTNAME)/doc/$(progname).1 \ $(DISTNAME)/doc/$(pkgname).info \ $(DISTNAME)/doc/$(pkgname).texinfo \ $(DISTNAME)/testsuite/check.sh \ $(DISTNAME)/testsuite/test.pbm \ $(DISTNAME)/testsuite/test.txt \ $(DISTNAME)/testsuite/test_utf8.txt \ $(DISTNAME)/ocrad.png \ $(DISTNAME)/*.h \ $(DISTNAME)/*.cc rm -f $(DISTNAME) lzip -v -9 $(DISTNAME).tar clean : -rm -f $(progname) $(progname)_profiled $(objs) -rm -f ocrcheck ocrcheck.o $(ocr_objs) $(lib_objs) *.a distclean : clean -rm -f Makefile config.status *.tar *.tar.lz ocrad-0.22/NEWS0000644000076400001440000000107412160310700011566 0ustar yousersChanges in version 0.22: Scaling and smoothing are now made before thresholding. Character recognition has been improved. (D - O, H - N, O - Q, V - Y, merged TT). New library function OCRAD_set_utf8_format. Small improvements have been made in the manual and in the man page. Quote characters in messages have been changed as advised by GNU Coding Standards. "configure" now accepts options with a separate argument. Configure option "--datadir" has been renamed to "--datarootdir" to follow GNU Standards. The target "install-bin" has been added to the Makefile. ocrad-0.22/README0000644000076400001440000000402512166633570011771 0ustar yousersDescription GNU Ocrad is an OCR (Optical Character Recognition) program and library based on a feature extraction method. It reads images in pbm (bitmap), pgm (greyscale) or ppm (color) formats and produces text in byte (8-bit) or UTF-8 formats. The pbm, pgm and ppm formats are collectively known as pnm. Ocrad includes a layout analyser able to separate the columns or blocks of text normally found on printed pages. See the file INSTALL for compilation and installation instructions. Try "ocrad --help" for usage instructions. Caveats. For better results the characters should be at least 20 pixels high. If they are smaller, try the --scale option. Merged characters are always a problem. Try to avoid them. Very bold or very light (broken) characters are also a problem. Always see with your own eyes the pnm file before blaming ocrad for the results. Remember the saying, "garbage in, garbage out". Ideas, comments, patches, donations (hardware, money, etc), etc, are welcome. --------------------------- Debug levels ( option -D ) 100 - Show raw block list. 99 - Show recursive block list. 98 - Show main block list. 96..97 - reserved. 95 - Show all blocks from every character before recognition. 94 - Show main black blocks from every character before recognition. 90..93 - reserved. 89 - Show all blocks from every character. 88 - Show main black blocks from every character. 87 - Show guess list for every character. 86 - Show best guess for every character. 80..85 - reserved. 78..79 - reserved. 7X - X = 0 Show page as bitmap. X = 1 Show page as bitmap with marked zones. X = 2 Show page as bitmap with marked lines. X = 4 Show page as bitmap with marked characters. Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This file is free documentation: you have unlimited permission to copy, distribute and modify it. The file Makefile.in is a data file used by configure to produce the Makefile. It has the same copyright owner and permissions that configure itself. ocrad-0.22/configure0000755000076400001440000001422112166635101013007 0ustar yousers#! /bin/sh # configure script for GNU Ocrad - Optical Character Recognition program # Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, # 2012, 2013 Antonio Diaz Diaz. # # This configure script is free software: you have unlimited permission # to copy, distribute and modify it. pkgname=ocrad pkgversion=0.22 progname=ocrad libname=ocrad srctrigger=${libname}lib.h # clear some things potentially inherited from environment. LC_ALL=C export LC_ALL srcdir= prefix=/usr/local exec_prefix='$(prefix)' bindir='$(exec_prefix)/bin' datarootdir='$(prefix)/share' includedir='${prefix}/include' infodir='$(datarootdir)/info' libdir='${exec_prefix}/lib' mandir='$(datarootdir)/man' CXX=g++ CPPFLAGS= CXXFLAGS='-Wall -W -O2' LDFLAGS= # checking whether we are using GNU C++. ${CXX} --version > /dev/null 2>&1 if [ $? != 0 ] ; then CXX=c++ CXXFLAGS='-W -O2' fi # Loop over all args args= no_create= while [ $# != 0 ] ; do # Get the first arg, and shuffle option=$1 ; arg2=no shift # Add the argument quoted to args args="${args} \"${option}\"" # Split out the argument for options that take them case ${option} in *=*) optarg=`echo ${option} | sed -e 's,^[^=]*=,,;s,/$,,'` ;; esac # Process the options case ${option} in --help | -h) echo "Usage: configure [options]" echo echo "Options: [defaults in brackets]" echo " -h, --help display this help and exit" echo " -V, --version output version information and exit" echo " --srcdir=DIR find the sources in DIR [. or ..]" echo " --prefix=DIR install into DIR [${prefix}]" echo " --exec-prefix=DIR base directory for arch-dependent files [${exec_prefix}]" echo " --bindir=DIR user executables directory [${bindir}]" echo " --datarootdir=DIR base directory for doc and data [${datarootdir}]" echo " --includedir=DIR C header files [${includedir}]" echo " --infodir=DIR info files directory [${infodir}]" echo " --libdir=DIR object code libraries [${libdir}]" echo " --mandir=DIR man pages directory [${mandir}]" echo " CXX=COMPILER C++ compiler to use [g++]" echo " CPPFLAGS=OPTIONS command line options for the preprocessor [${CPPFLAGS}]" echo " CXXFLAGS=OPTIONS command line options for the C++ compiler [${CXXFLAGS}]" echo " LDFLAGS=OPTIONS command line options for the linker [${LDFLAGS}]" echo exit 0 ;; --version | -V) echo "Configure script for GNU ${pkgname} version ${pkgversion}" exit 0 ;; --srcdir) srcdir=$1 ; arg2=yes ;; --prefix) prefix=$1 ; arg2=yes ;; --exec-prefix) exec_prefix=$1 ; arg2=yes ;; --bindir) bindir=$1 ; arg2=yes ;; --datarootdir) datarootdir=$1 ; arg2=yes ;; --includedir) includedir=$1 ; arg2=yes ;; --infodir) infodir=$1 ; arg2=yes ;; --libdir) libdir=$1 ; arg2=yes ;; --mandir) mandir=$1 ; arg2=yes ;; --srcdir=*) srcdir=${optarg} ;; --prefix=*) prefix=${optarg} ;; --exec-prefix=*) exec_prefix=${optarg} ;; --bindir=*) bindir=${optarg} ;; --datarootdir=*) datarootdir=${optarg} ;; --includedir=*) includedir=${optarg} ;; --infodir=*) infodir=${optarg} ;; --libdir=*) libdir=${optarg} ;; --mandir=*) mandir=${optarg} ;; --no-create) no_create=yes ;; CXX=*) CXX=${optarg} ;; CPPFLAGS=*) CPPFLAGS=${optarg} ;; CXXFLAGS=*) CXXFLAGS=${optarg} ;; LDFLAGS=*) LDFLAGS=${optarg} ;; --*) echo "configure: WARNING: unrecognized option: '${option}'" 1>&2 ;; *=* | *-*-*) ;; *) echo "configure: unrecognized option: '${option}'" 1>&2 echo "Try 'configure --help' for more information." 1>&2 exit 1 ;; esac # Check if the option took a separate argument if [ "${arg2}" = yes ] ; then if [ $# != 0 ] ; then args="${args} \"$1\"" ; shift else echo "configure: Missing argument to '${option}'" 1>&2 exit 1 fi fi done # Find the source files, if location was not specified. srcdirtext= if [ -z "${srcdir}" ] ; then srcdirtext="or . or .." ; srcdir=. if [ ! -r "${srcdir}/${srctrigger}" ] ; then srcdir=.. ; fi if [ ! -r "${srcdir}/${srctrigger}" ] ; then ## the sed command below emulates the dirname command srcdir=`echo $0 | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` fi fi if [ ! -r "${srcdir}/${srctrigger}" ] ; then echo "configure: Can't find sources in ${srcdir} ${srcdirtext}" 1>&2 echo "configure: (At least ${srctrigger} is missing)." 1>&2 exit 1 fi # Set srcdir to . if that's what it is. if [ "`pwd`" = "`cd "${srcdir}" ; pwd`" ] ; then srcdir=. ; fi echo if [ -z "${no_create}" ] ; then echo "creating config.status" rm -f config.status cat > config.status << EOF #! /bin/sh # This file was generated automatically by configure. Do not edit. # Run this file to recreate the current configuration. # # This script is free software: you have unlimited permission # to copy, distribute and modify it. exec /bin/sh $0 ${args} --no-create EOF chmod +x config.status fi echo "creating Makefile" echo "VPATH = ${srcdir}" echo "prefix = ${prefix}" echo "exec_prefix = ${exec_prefix}" echo "bindir = ${bindir}" echo "datarootdir = ${datarootdir}" echo "includedir = ${includedir}" echo "infodir = ${infodir}" echo "libdir = ${libdir}" echo "mandir = ${mandir}" echo "CXX = ${CXX}" echo "CPPFLAGS = ${CPPFLAGS}" echo "CXXFLAGS = ${CXXFLAGS}" echo "LDFLAGS = ${LDFLAGS}" rm -f Makefile cat > Makefile << EOF # Makefile for GNU Ocrad - Optical Character Recognition program # Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, # 2012, 2013 Antonio Diaz Diaz. # This file was generated automatically by configure. Do not edit. # # This Makefile is free software: you have unlimited permission # to copy, distribute and modify it. pkgname = ${pkgname} pkgversion = ${pkgversion} progname = ${progname} libname = ${libname} VPATH = ${srcdir} prefix = ${prefix} exec_prefix = ${exec_prefix} bindir = ${bindir} datarootdir = ${datarootdir} includedir = ${includedir} infodir = ${infodir} libdir = ${libdir} mandir = ${mandir} CXX = ${CXX} CPPFLAGS = ${CPPFLAGS} CXXFLAGS = ${CXXFLAGS} LDFLAGS = ${LDFLAGS} EOF cat "${srcdir}/Makefile.in" >> Makefile echo "OK. Now you can run make." ocrad-0.22/doc/ocrad.10000644000076400001440000000550712166635142013033 0ustar yousers.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.37.1. .TH OCRAD "1" "July 2013" "Ocrad 0.22" "User Commands" .SH NAME Ocrad \- command line text recognition tool .SH SYNOPSIS .B ocrad [\fIoptions\fR] [\fIfiles\fR] .SH DESCRIPTION GNU Ocrad is an OCR (Optical Character Recognition) program based on a feature extraction method. It reads images in pbm (bitmap), pgm (greyscale) or ppm (color) formats and produces text in byte (8\-bit) or UTF\-8 formats. The pbm, pgm and ppm formats are collectively known as pnm. .PP Ocrad includes a layout analyser able to separate the columns or blocks of text normally found on printed pages. .SH OPTIONS .TP \fB\-h\fR, \fB\-\-help\fR display this help and exit .TP \fB\-V\fR, \fB\-\-version\fR output version information and exit .TP \fB\-a\fR, \fB\-\-append\fR append text to output file .TP \fB\-c\fR, \fB\-\-charset=\fR try '\-\-charset=help' for a list of names .TP \fB\-e\fR, \fB\-\-filter=\fR try '\-\-filter=help' for a list of names .TP \fB\-f\fR, \fB\-\-force\fR force overwrite of output file .TP \fB\-F\fR, \fB\-\-format=\fR output format (byte, utf8) .TP \fB\-i\fR, \fB\-\-invert\fR invert image levels (white on black) .TP \fB\-l\fR, \fB\-\-layout\fR perform layout analysis .TP \fB\-o\fR, \fB\-\-output=\fR place the output into .TP \fB\-q\fR, \fB\-\-quiet\fR suppress all messages .TP \fB\-s\fR, \fB\-\-scale\fR=\fI[\-]\fR scale input image by [1/] .TP \fB\-t\fR, \fB\-\-transform=\fR try '\-\-transform=help' for a list of names .TP \fB\-T\fR, \fB\-\-threshold=\fR threshold for binarization (0\-100%) .TP \fB\-u\fR, \fB\-\-cut=\fR cut input image by given rectangle .TP \fB\-v\fR, \fB\-\-verbose\fR be verbose .TP \fB\-x\fR, \fB\-\-export=\fR export results in ORF format to .PP If no files are specified, ocrad reads the image from standard input. If the \fB\-o\fR option is not specified, ocrad sends text to standard output. .PP Exit status: 0 for a normal exit, 1 for environmental problems (file not found, invalid flags, I/O errors, etc), 2 to indicate a corrupt or invalid input file, 3 for an internal consistency error (eg, bug) which caused ocrad to panic. .SH "REPORTING BUGS" Report bugs to bug\-ocrad@gnu.org .br Ocrad home page: http://www.gnu.org/software/ocrad/ocrad.html .br General help using GNU software: http://www.gnu.org/gethelp .SH COPYRIGHT Copyright \(co 2013 Antonio Diaz Diaz. License GPLv3+: GNU GPL version 3 or later .br This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. .SH "SEE ALSO" The full documentation for .B Ocrad is maintained as a Texinfo manual. If the .B info and .B Ocrad programs are properly installed at your site, the command .IP .B info Ocrad .PP should give you access to the complete manual. ocrad-0.22/doc/ocrad.info0000644000076400001440000005167312166633572013640 0ustar yousersThis is ocrad.info, produced by makeinfo version 4.13 from ocrad.texinfo. INFO-DIR-SECTION GNU Packages START-INFO-DIR-ENTRY * Ocrad: (ocrad). The GNU OCR program END-INFO-DIR-ENTRY  File: ocrad.info, Node: Top, Next: Character sets, Up: (dir) GNU Ocrad Manual **************** This manual is for GNU Ocrad (version 0.22, 9 July 2013). GNU Ocrad is an OCR (Optical Character Recognition) program and library based on a feature extraction method. It reads images in pbm (bitmap), pgm (greyscale) or ppm (color) formats and produces text in byte (8-bit) or UTF-8 formats. The pbm, pgm and ppm formats are collectively known as pnm. Ocrad includes a layout analyser able to separate the columns or blocks of text normally found on printed pages. * Menu: * Character sets:: Input charsets and output formats * Invoking ocrad:: Command line interface * Library version:: Checking library version * Library functions:: Descriptions of the library functions * Library error codes:: Meaning of codes returned by functions * Image format conversion:: How to convert other formats to pnm * Algorithm:: How ocrad does its job * OCR results file:: Description of the ORF file format * Problems:: Reporting bugs * Concept index:: Index of concepts Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This manual is free documentation: you have unlimited permission to copy, distribute and modify it.  File: ocrad.info, Node: Character sets, Next: Invoking ocrad, Prev: Top, Up: Top 1 Character sets **************** The character set internally used by ocrad is ISO 10646, also known as UCS (Universal Character Set), which can represent over two thousand million characters (2^31). As it is unpractical to try to recognize one among so many different characters, you can tell ocrad what character sets to recognize. You do this with the `--charset' option. If the input page contains characters from only one character set, say `ISO-8859-15', you can use the default `byte' output format. But in a page with `ISO-8859-9' and `ISO-8859-15' characters, you can't tell if a code of 0xFD represents a 'latin small letter i dotless' or a 'latin small letter y with acute'. You should use `--format=utf8' instead. Of course, you may request UTF-8 output in any case. NOTE: 10^9 is a thousand millions, a billion is a million millions (million^2), a trillion is a million million millions (million^3), and so on. Please, don't "embrace and extend" the meaning of prefixes, making communication among all people difficult. Thanks.  File: ocrad.info, Node: Invoking ocrad, Next: Library version, Prev: Character sets, Up: Top 2 Invoking ocrad **************** The format for running ocrad is: ocrad [OPTIONS] [FILES] Ocrad supports the following options: `-h' `--help' Print an informative help message describing the options and exit. `ocrad --verbose --help' describes also hidden options. `-V' `--version' Print the version number of ocrad on the standard output and exit. `-a' `--append' Append generated text to the output file instead of overwriting it. `-c NAME' `--charset=NAME' Enable recognition of the characters belonging to the given character set. You can repeat this option multiple times with different names for processing a page with characters from different character sets. If no charset is specified, `iso-8859-15' (latin9) is assumed. Try `--charset=help' for a list of valid charset names. `-e NAME' `--filter=NAME' Pass the output text through the given postprocessing filter. `--filter=letters' forces every character that resembles a letter to be recognized as a letter. Other characters will be output without change. `--filter=letters_only', same as `--filter=letters', but other characters will be discarded. `--filter=numbers' forces every character that resembles a number to be recognized as a number. Other characters will be output without change. `--filter=numbers_only', same as `--filter=numbers' but other characters will be discarded. Try `--filter=help' for a list of valid filter names. `-f' `--force' Force overwrite of output files. `-F NAME' `--format=NAME' Select the output format. The valid names are `byte' and `utf8'. If no output format is specified, `byte' (8 bit) is assumed. `-i' `--invert' Invert image levels (white on black). `-l' `--layout' Enable page layout analysis. Ocrad is able to separate blocks of text of arbitrary shape as long as they are clearly delimited by white space. `-o FILE' `--output=FILE' Place the output into FILE instead of into the standard output. `-q' `--quiet' Quiet operation. `-s VALUE' `--scale=VALUE' Scale up the input image by VALUE before layout analysis and recognition. If VALUE is negative, the input image is scaled down by -VALUE. `-t NAME' `--transform=NAME' Perform given transformation (rotation or mirroring) on the input image before scaling, layout analysis and recognition. Try `--transform=help' for a list of valid transformation names. `-T VALUE' `--threshold=VALUE' Set binarization threshold for pgm or ppm files or for `--scale' option (only for scaled down images). VALUE should be a rational number between 0 and 1, and may be given as a percentage (50%), a fraction (1/2), or a decimal value (0.5). Image values greater than threshold are converted to white. The default value is 0.5. `-u LEFT,TOP,WIDTH,HEIGHT' `--cut=LEFT,TOP,WIDTH,HEIGHT' Cut the input image by the rectangle defined by LEFT, TOP, WIDTH and HEIGHT. Values may be relative to the image size (-1.0 <= value <= +1.0), or absolute (abs( value ) > 1). Negative values of LEFT, TOP are relative to the right-bottom corner of the image. Values of WIDTH and HEIGHT must be positive. Absolute and relative values can be mixed. For example `ocrad --cut 700,960,1,1' will extract from `700,960' to the right-bottom corner of the image. The cutting is performed before any other transformation (rotation or mirroring) on the input image, and before scaling, layout analysis and recognition. `-v' `--verbose' Verbose mode. `-x FILE' `--export=FILE' Write (export) OCR results file to FILE (*note OCR results file::). `-x -' writes to stdout, overriding text output except if output has been also redirected with the `-o' option. Exit status: 0 for a normal exit, 1 for environmental problems (file not found, invalid flags, I/O errors, etc), 2 to indicate a corrupt or invalid input file, 3 for an internal consistency error (eg, bug) which caused ocrad to panic.  File: ocrad.info, Node: Library version, Next: Library functions, Prev: Invoking ocrad, Up: Top 3 Library version ***************** -- Function: const char * OCRAD_version ( void ) Returns the library version as a string. -- Constant: const char * OCRAD_version_string This constant is defined in the header file `ocradlib.h'. The application should compare OCRAD_version and OCRAD_version_string for consistency. If the first character differs, the library code actually used may be incompatible with the `ocradlib.h' header file used by the application. if( OCRAD_version()[0] != OCRAD_version_string[0] ) error( "bad library version" );  File: ocrad.info, Node: Library functions, Next: Library error codes, Prev: Library version, Up: Top 4 Library functions ******************* These are the OCRAD library functions. In case of error, all of them return -1 or a null pointer, except `OCRAD_open' whose return value must be verified by calling `OCRAD_get_errno' before using it. -- Function: struct OCRAD_Descriptor * OCRAD_open ( void ) Initializes the internal library state and returns a pointer that can only be used as the OCRDES argument for the other OCRAD functions, or a null pointer if the descriptor could not be allocated. The returned pointer must be verified by calling `OCRAD_get_errno' before using it. If `OCRAD_get_errno' does not return `OCRAD_ok', the returned pointer must not be used and should be freed with `OCRAD_close' to avoid memory leaks. -- Function: int OCRAD_close ( struct OCRAD_Descriptor * const OCRDES ) Frees all dynamically allocated data structures for this descriptor. After a call to `OCRAD_close', OCRDES can no more be used as an argument to any OCRAD function. -- Function: enum OCRAD_Errno OCRAD_get_errno ( struct OCRAD_Descriptor * const OCRDES ) Returns the current error code for OCRDES (*note Library error codes::). -- Function: int OCRAD_set_image ( struct OCRAD_Descriptor * const OCRDES, const struct OCRAD_Pixmap * const IMAGE, const bool INVERT ) Loads IMAGE into the internal buffer. If INVERT is true, image levels are inverted (white on black). Loading a new image deletes any previous text results. -- Function: int OCRAD_set_image_from_file ( struct OCRAD_Descriptor * const OCRDES, const char * const FILENAME, const bool INVERT ) Loads a image from the file FILENAME into the internal buffer. If INVERT is true, image levels are inverted (white on black). Loading a new image deletes any previous text results. -- Function: int OCRAD_set_utf8_format ( struct OCRAD_Descriptor * const OCRDES, const bool UTF8 ) Set the output format to `byte' (if UTF8=false) or to `utf8'. By default ocrad produces `byte' (8 bit) output. -- Function: int OCRAD_set_threshold ( struct OCRAD_Descriptor * const OCRDES, const int THRESHOLD ) Set binarization threshold for greymap or RGB images. THRESHOLD values between 0 and 255 set a fixed threshold. A value of -1 sets an automatic threshold. Pixel values greater than the resulting threshold are converted to white. The default threshold value if this function is not called is 127. -- Function: int OCRAD_scale ( struct OCRAD_Descriptor * const OCRDES, const int VALUE ) Scale up the image in the internal buffer by VALUE. If VALUE is negative, the image is scaled down by -VALUE. -- Function: int OCRAD_recognize ( struct OCRAD_Descriptor * const OCRDES, const bool LAYOUT ) Recognize the image loaded in the internal buffer and produce text results which can be later retrieved with the `OCRAD_result' functions. The same image can be recognized as many times as desired, for example setting a new threshold each time for 3D greymap recognition. Every time this function is called, the produced text results replace any previous ones. If LAYOUT is true, page layout analysis is enabled, probably producing more than one text block. -- Function: int OCRAD_result_blocks ( struct OCRAD_Descriptor * const OCRDES ) Returns the number of text blocks found in the image by the layout analyser or 1 if no layout analysis was requested. -- Function: int OCRAD_result_lines ( struct OCRAD_Descriptor * const OCRDES, const int BLOCKNUM ) Returns the number of text lines contained in the given text block. -- Function: int OCRAD_result_chars_total ( struct OCRAD_Descriptor * const OCRDES ) Returns the total number of text characters contained in the recognized image. -- Function: int OCRAD_result_chars_block ( struct OCRAD_Descriptor * const OCRDES, const int BLOCKNUM ) Returns the number of text characters contained in the given text block. -- Function: int OCRAD_result_chars_line ( struct OCRAD_Descriptor * const OCRDES, const int BLOCKNUM, const int LINENUM ) Returns the number of text characters contained in the given text line. -- Function: const char * OCRAD_result_line ( struct OCRAD_Descriptor * const OCRDES, const int BLOCKNUM, const int LINENUM ) Returns the line of text specified by BLOCKNUM and LINENUM. -- Function: int OCRAD_result_first_character ( struct OCRAD_Descriptor * const OCRDES ) Returns the byte result for the first character in the image. Returns 0 if the image has no characters or if the first character could not be recognized. This function is a convenient short cut to the result for images containing a single character.  File: ocrad.info, Node: Library error codes, Next: Image format conversion, Prev: Library functions, Up: Top 5 Library error codes ********************* Most library functions return -1 or a null pointer to indicate that they have failed. But this return value only tells you that an error has occurred. To find out what kind of error it was, you need to verify the error code by calling `OCRAD_get_errno'. Library functions do not change the value returned by `OCRAD_get_errno' when they succeed; thus, the value returned by `OCRAD_get_errno' after a successful call is not necessarily OCRAD_ok, and you should not use `OCRAD_get_errno' to determine whether a call failed. If the call failed, then you can examine `OCRAD_get_errno'. The error codes are defined in the header file `ocradlib.h'. -- Constant: enum OCRAD_Errno OCRAD_ok The value of this constant is 0 and is used to indicate that there is no error. -- Constant: enum OCRAD_Errno OCRAD_bad_argument At least one of the arguments passed to the library function was invalid. -- Constant: enum OCRAD_Errno OCRAD_mem_error No memory available. The system cannot allocate more virtual memory because its capacity is full. -- Constant: enum OCRAD_Errno OCRAD_sequence_error A library function was called in the wrong order. For example `OCRAD_result_line' was called before `OCRAD_recognize'. -- Constant: enum OCRAD_Errno OCRAD_library_error A bug was detected in the library. Please, report it (*note Problems::).  File: ocrad.info, Node: Image format conversion, Next: Algorithm, Prev: Library error codes, Up: Top 6 Image format conversion ************************* There are a lot of image formats, but ocrad is able to decode only three of them; pbm, pgm and ppm. In this chapter you will find command examples and advice about how to convert image files to a format that ocrad can manage. `.png' Portable Network Graphics file. Use the command `pngtopnm filename.png | ocrad'. In some cases, like the ocrad.png icon, you have to invert the image with the `-i' option: `pngtopnm filename.png | ocrad -i'. `.ps' `.pdf' Postscript or Portable Document Format file. Use the command `gs -sPAPERSIZE=a4 -sDEVICE=pnmraw -r300 -dNOPAUSE -dBATCH -sOutputFile=- -q filename.ps | ocrad'. You may also use the command `pstopnm -stdout -dpi=300 -pgm filename.ps | ocrad', but it seems not to work with pdf files. Also old versions of `pstopnm' don't recognize the `-dpi' option and produce an image too small for OCR. `.tiff' TIFF file. Use the command `tifftopnm filename.tiff | ocrad'. `.jpg' JPEG file. Use the command `djpeg -greyscale -pnm filename.jpg | ocrad'. JPEG is a lossy format and is in general not recommended for text images. `.pnm.gz' Pnm file compressed with gzip. Use the command `gzip -cd filename.pnm.gz | ocrad' `.pnm.lz' Pnm file compressed with lzip. Use the command `lzip -cd filename.pnm.lz | ocrad'  File: ocrad.info, Node: Algorithm, Next: OCR results file, Prev: Image format conversion, Up: Top 7 Algorithm *********** Ocrad is mainly a research project. Many of the algorithms ocrad uses are ad hoc, and will change in successive releases as I myself gain understanding about OCR issues. The overall working of ocrad may be described as follows: 1) read the image. 2) optionally, perform some transformations (cut, rotate, scale, etc). 3) optionally, perform layout detection. 4) remove frames and pictures. 5) detect characters and group them in lines. 6) recognize characters (very ad hoc; one algorithm per character). 7) correct some errors (transform l.OOO into 1.000, etc). 8) output result. Ocrad recognizes characters by its shape, and the reason it is so fast is that it does not compare the shape of every character against some sort of database of shapes and then chooses the best match. Instead of this, ocrad only compares the shape differences that are relevant to choose between two character categories, mostly like a binary search. As there is no such thing as a free lunch, this approach has some drawbacks. It makes ocrad very sensitive to character defects, and makes difficult to modify ocrad to recognize new characters.  File: ocrad.info, Node: OCR results file, Next: Problems, Prev: Algorithm, Up: Top 8 OCR results file ****************** Calling ocrad with option `-x' produces an OCR results file (ORF), that is, a parsable file containing the OCR results. The ORF format is as follows: - Any line beginning with `#' is a comment line. - The first non-comment line has the form `source file FILENAME', where FILENAME is the name of the file being processed (`-' for stdin). This is the only line guaranteed to exist for every input file read without errors. If the file, or any block or line, has no text, the corresponding part in the ORF file will be missing. - The second non-comment line has the form `total text blocks N', where N is the total number of text blocks in the source image. For each text block in the source image, the following data follows: - A line in the form `text block I X Y W H'. Where I is the block number and X Y W H are the block position and size as described below for character boxes. - A line in the form `lines N'. Where N is the number of lines in this block. For each line in every text block, the following data follows: - A line in the form `line I chars N height H', where I is the line number, N is the number of characters in this line, and H is the mean height of the characters in this line (in pixels). - N lines (one for every character) in the form `X Y W H; G[, 'C'V]...', where: X is the left border (x-coordinate) of the char bounding box in the source image (in pixels). Y is the top border (y-coordinate). W is the width of the bounding box. H is the height of the bounding box. G is the number of different recognition guesses for this character. The result characters follow after the number of guesses in the form of a comma-separated list of pairs. Every pair is formed by the actual recognised char C enclosed in single quotes, followed by the confidence value V, without space between them. The higher the value of confidence, the more confident is the result. Running `./ocrad -x test.orf examples/test.pbm' in the source directory will give you an example ORF file.  File: ocrad.info, Node: Problems, Next: Concept index, Prev: OCR results file, Up: Top 9 Reporting Bugs **************** There are probably bugs in ocrad. There are certainly errors and omissions in this manual. If you report them, they will get fixed. If you don't, no one will ever know about them and they will remain unfixed for all eternity, if not longer. If you find a bug in GNU Ocrad, please send electronic mail to . Include the version number, which you can find by running `ocrad --version'.  File: ocrad.info, Node: Concept index, Prev: Problems, Up: Top Concept index ************* [index] * Menu: * algorithm: Algorithm. (line 6) * bugs: Problems. (line 6) * getting help: Problems. (line 6) * image format conversion: Image format conversion. (line 6) * input charsets: Character sets. (line 6) * invoking: Invoking ocrad. (line 6) * library error codes: Library error codes. (line 6) * library functions: Library functions. (line 6) * library version: Library version. (line 6) * OCR results file: OCR results file. (line 6) * options: Invoking ocrad. (line 6) * output format: Character sets. (line 6) * usage: Invoking ocrad. (line 6) * version: Invoking ocrad. (line 6)  Tag Table: Node: Top198 Node: Character sets1598 Node: Invoking ocrad2743 Node: Library version6972 Node: Library functions7651 Node: Library error codes12716 Node: Image format conversion14267 Node: Algorithm15791 Node: OCR results file17060 Node: Problems19328 Node: Concept index19864  End Tag Table  Local Variables: coding: iso-8859-15 End: ocrad-0.22/doc/ocrad.texinfo0000644000076400001440000005034412166633570014351 0ustar yousers\input texinfo @c -*-texinfo-*- @c %**start of header @setfilename ocrad.info @documentencoding ISO-8859-15 @settitle GNU Ocrad Manual @finalout @c %**end of header @set UPDATED 9 July 2013 @set VERSION 0.22 @dircategory GNU Packages @direntry * Ocrad: (ocrad). The GNU OCR program @end direntry @ifnothtml @titlepage @title GNU Ocrad @subtitle The GNU OCR Program @subtitle for GNU Ocrad version @value{VERSION}, @value{UPDATED} @author by Antonio Diaz Diaz @page @vskip 0pt plus 1filll @end titlepage @contents @end ifnothtml @node Top @top This manual is for GNU Ocrad (version @value{VERSION}, @value{UPDATED}). @sp 1 GNU Ocrad is an OCR (Optical Character Recognition) program and library based on a feature extraction method. It reads images in pbm (bitmap), pgm (greyscale) or ppm (color) formats and produces text in @w{byte (8-bit)} or UTF-8 formats. The pbm, pgm and ppm formats are collectively known as pnm. Ocrad includes a layout analyser able to separate the columns or blocks of text normally found on printed pages. @menu * Character sets:: Input charsets and output formats * Invoking ocrad:: Command line interface * Library version:: Checking library version * Library functions:: Descriptions of the library functions * Library error codes:: Meaning of codes returned by functions * Image format conversion:: How to convert other formats to pnm * Algorithm:: How ocrad does its job * OCR results file:: Description of the ORF file format * Problems:: Reporting bugs * Concept index:: Index of concepts @end menu @sp 1 Copyright @copyright{} 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This manual is free documentation: you have unlimited permission to copy, distribute and modify it. @node Character sets @chapter Character sets @cindex input charsets @cindex output format The character set internally used by ocrad is ISO 10646, also known as UCS (Universal Character Set), which can represent over two thousand million characters (2^31). As it is unpractical to try to recognize one among so many different characters, you can tell ocrad what character sets to recognize. You do this with the @samp{--charset} option. If the input page contains characters from only one character set, say @w{@samp{ISO-8859-15}}, you can use the default @samp{byte} output format. But in a page with @w{@samp{ISO-8859-9}} and @w{@samp{ISO-8859-15}} characters, you can't tell if a code of 0xFD represents a 'latin small letter i dotless' or a 'latin small letter y with acute'. You should use @w{@samp{--format=utf8}} instead.@* Of course, you may request UTF-8 output in any case. @sp 1 NOTE: 10^9 is a thousand millions, a billion is a million millions (million^2), a trillion is a million million millions (million^3), and so on. Please, don't "embrace and extend" the meaning of prefixes, making communication among all people difficult. Thanks. @node Invoking ocrad @chapter Invoking ocrad @cindex invoking @cindex options @cindex usage @cindex version The format for running ocrad is: @example ocrad [@var{options}] [@var{files}] @end example Ocrad supports the following options: @table @samp @item -h @itemx --help Print an informative help message describing the options and exit. @w{@samp{ocrad --verbose --help}} describes also hidden options. @item -V @itemx --version Print the version number of ocrad on the standard output and exit. @item -a @itemx --append Append generated text to the output file instead of overwriting it. @item -c @var{name} @itemx --charset=@var{name} Enable recognition of the characters belonging to the given character set. You can repeat this option multiple times with different names for processing a page with characters from different character sets.@* If no charset is specified, @w{@samp{iso-8859-15}} (latin9) is assumed.@* Try @w{@samp{--charset=help}} for a list of valid charset names. @item -e @var{name} @itemx --filter=@var{name} Pass the output text through the given postprocessing filter.@* @w{@samp{--filter=letters}} forces every character that resembles a letter to be recognized as a letter. Other characters will be output without change.@* @w{@samp{--filter=letters_only}}, same as @w{@samp{--filter=letters}}, but other characters will be discarded.@* @w{@samp{--filter=numbers}} forces every character that resembles a number to be recognized as a number. Other characters will be output without change.@* @w{@samp{--filter=numbers_only}}, same as @w{@samp{--filter=numbers}} but other characters will be discarded.@* Try @w{@samp{--filter=help}} for a list of valid filter names. @item -f @itemx --force Force overwrite of output files. @item -F @var{name} @itemx --format=@var{name} Select the output format. The valid names are @samp{byte} and @samp{utf8}.@* If no output format is specified, @samp{byte} (8 bit) is assumed. @item -i @itemx --invert Invert image levels (white on black). @item -l @itemx --layout Enable page layout analysis. Ocrad is able to separate blocks of text of arbitrary shape as long as they are clearly delimited by white space. @item -o @var{file} @itemx --output=@var{file} Place the output into @var{file} instead of into the standard output. @item -q @itemx --quiet Quiet operation. @item -s @var{value} @itemx --scale=@var{value} Scale up the input image by @var{value} before layout analysis and recognition. If @var{value} is negative, the input image is scaled down by @var{-value}. @item -t @var{name} @itemx --transform=@var{name} Perform given transformation (rotation or mirroring) on the input image before scaling, layout analysis and recognition.@* Try @w{@samp{--transform=help}} for a list of valid transformation names. @item -T @var{value} @itemx --threshold=@var{value} Set binarization threshold for pgm or ppm files or for @samp{--scale} option (only for scaled down images). @var{value} should be a rational number between 0 and 1, and may be given as a percentage (50%), a fraction (1/2), or a decimal value (0.5). Image values greater than threshold are converted to white. The default value is 0.5. @item -u @var{left},@var{top},@var{width},@var{height} @itemx --cut=@var{left},@var{top},@var{width},@var{height} Cut the input image by the rectangle defined by @var{left}, @var{top}, @var{width} and @var{height}. Values may be relative to the image size @w{(-1.0 <= value <= +1.0)}, or absolute @w{(abs( value ) > 1)}. Negative values of @var{left}, @var{top} are relative to the right-bottom corner of the image. Values of @var{width} and @var{height} must be positive. Absolute and relative values can be mixed. For example @w{@samp{ocrad --cut 700,960,1,1}} will extract from @samp{700,960} to the right-bottom corner of the image.@* The cutting is performed before any other transformation (rotation or mirroring) on the input image, and before scaling, layout analysis and recognition. @item -v @itemx --verbose Verbose mode. @item -x @var{file} @itemx --export=@var{file} Write (export) OCR results file to @var{file} (@pxref{OCR results file}). @w{@samp{-x -}} writes to stdout, overriding text output except if output has been also redirected with the @samp{-o} option. @end table Exit status: 0 for a normal exit, 1 for environmental problems (file not found, invalid flags, I/O errors, etc), 2 to indicate a corrupt or invalid input file, 3 for an internal consistency error (eg, bug) which caused ocrad to panic. @node Library version @chapter Library version @cindex library version @deftypefun {const char *} OCRAD_version ( void ) Returns the library version as a string. @end deftypefun @deftypevr Constant {const char *} OCRAD_version_string This constant is defined in the header file @samp{ocradlib.h}. @end deftypevr The application should compare OCRAD_version and OCRAD_version_string for consistency. If the first character differs, the library code actually used may be incompatible with the @samp{ocradlib.h} header file used by the application. @example if( OCRAD_version()[0] != OCRAD_version_string[0] ) error( "bad library version" ); @end example @node Library functions @chapter Library functions @cindex library functions These are the OCRAD library functions. In case of error, all of them return -1 or a null pointer, except @samp{OCRAD_open} whose return value must be verified by calling @samp{OCRAD_get_errno} before using it. @deftypefun {struct OCRAD_Descriptor *} OCRAD_open ( void ) Initializes the internal library state and returns a pointer that can only be used as the @var{ocrdes} argument for the other OCRAD functions, or a null pointer if the descriptor could not be allocated. The returned pointer must be verified by calling @samp{OCRAD_get_errno} before using it. If @samp{OCRAD_get_errno} does not return @samp{OCRAD_ok}, the returned pointer must not be used and should be freed with @samp{OCRAD_close} to avoid memory leaks. @end deftypefun @deftypefun int OCRAD_close ( struct OCRAD_Descriptor * const @var{ocrdes} ) Frees all dynamically allocated data structures for this descriptor. After a call to @samp{OCRAD_close}, @var{ocrdes} can no more be used as an argument to any OCRAD function. @end deftypefun @deftypefun {enum OCRAD_Errno} OCRAD_get_errno ( struct OCRAD_Descriptor * const @var{ocrdes} ) Returns the current error code for @var{ocrdes} (@pxref{Library error codes}). @end deftypefun @deftypefun int OCRAD_set_image ( struct OCRAD_Descriptor * const @var{ocrdes}, const struct OCRAD_Pixmap * const @var{image}, const bool @var{invert} ) Loads @var{image} into the internal buffer. If @var{invert} is true, image levels are inverted (white on black). Loading a new image deletes any previous text results. @end deftypefun @deftypefun int OCRAD_set_image_from_file ( struct OCRAD_Descriptor * const @var{ocrdes}, const char * const @var{filename}, const bool @var{invert} ) Loads a image from the file @var{filename} into the internal buffer. If @var{invert} is true, image levels are inverted (white on black). Loading a new image deletes any previous text results. @end deftypefun @deftypefun int OCRAD_set_utf8_format ( struct OCRAD_Descriptor * const @var{ocrdes}, const bool @var{utf8} ) Set the output format to @samp{byte} (if @var{utf8}=false) or to @samp{utf8}. By default ocrad produces @samp{byte} (8 bit) output. @end deftypefun @deftypefun int OCRAD_set_threshold ( struct OCRAD_Descriptor * const @var{ocrdes}, const int @var{threshold} ) Set binarization threshold for greymap or RGB images. @var{threshold} values between 0 and 255 set a fixed threshold. A value of -1 sets an automatic threshold. Pixel values greater than the resulting threshold are converted to white. The default threshold value if this function is not called is 127. @end deftypefun @deftypefun int OCRAD_scale ( struct OCRAD_Descriptor * const @var{ocrdes}, const int @var{value} ) Scale up the image in the internal buffer by @var{value}. If @var{value} is negative, the image is scaled down by @var{-value}. @end deftypefun @deftypefun int OCRAD_recognize ( struct OCRAD_Descriptor * const @var{ocrdes}, const bool @var{layout} ) Recognize the image loaded in the internal buffer and produce text results which can be later retrieved with the @samp{OCRAD_result} functions. The same image can be recognized as many times as desired, for example setting a new threshold each time for 3D greymap recognition. Every time this function is called, the produced text results replace any previous ones. If @var{layout} is true, page layout analysis is enabled, probably producing more than one text block. @end deftypefun @deftypefun int OCRAD_result_blocks ( struct OCRAD_Descriptor * const @var{ocrdes} ) Returns the number of text blocks found in the image by the layout analyser or 1 if no layout analysis was requested. @end deftypefun @deftypefun int OCRAD_result_lines ( struct OCRAD_Descriptor * const @var{ocrdes}, const int @var{blocknum} ) Returns the number of text lines contained in the given text block. @end deftypefun @deftypefun int OCRAD_result_chars_total ( struct OCRAD_Descriptor * const @var{ocrdes} ) Returns the total number of text characters contained in the recognized image. @end deftypefun @deftypefun int OCRAD_result_chars_block ( struct OCRAD_Descriptor * const @var{ocrdes}, const int @var{blocknum} ) Returns the number of text characters contained in the given text block. @end deftypefun @deftypefun int OCRAD_result_chars_line ( struct OCRAD_Descriptor * const @var{ocrdes}, const int @var{blocknum}, const int @var{linenum} ) Returns the number of text characters contained in the given text line. @end deftypefun @deftypefun {const char *} OCRAD_result_line ( struct OCRAD_Descriptor * const @var{ocrdes}, const int @var{blocknum}, const int @var{linenum} ) Returns the line of text specified by @var{blocknum} and @var{linenum}. @end deftypefun @deftypefun int OCRAD_result_first_character ( struct OCRAD_Descriptor * const @var{ocrdes} ) Returns the byte result for the first character in the image. Returns 0 if the image has no characters or if the first character could not be recognized. This function is a convenient short cut to the result for images containing a single character. @end deftypefun @node Library error codes @chapter Library error codes @cindex library error codes Most library functions return -1 or a null pointer to indicate that they have failed. But this return value only tells you that an error has occurred. To find out what kind of error it was, you need to verify the error code by calling @samp{OCRAD_get_errno}. Library functions do not change the value returned by @samp{OCRAD_get_errno} when they succeed; thus, the value returned by @samp{OCRAD_get_errno} after a successful call is not necessarily OCRAD_ok, and you should not use @samp{OCRAD_get_errno} to determine whether a call failed. If the call failed, then you can examine @samp{OCRAD_get_errno}. The error codes are defined in the header file @samp{ocradlib.h}. @deftypevr Constant {enum OCRAD_Errno} OCRAD_ok The value of this constant is 0 and is used to indicate that there is no error. @end deftypevr @deftypevr Constant {enum OCRAD_Errno} OCRAD_bad_argument At least one of the arguments passed to the library function was invalid. @end deftypevr @deftypevr Constant {enum OCRAD_Errno} OCRAD_mem_error No memory available. The system cannot allocate more virtual memory because its capacity is full. @end deftypevr @deftypevr Constant {enum OCRAD_Errno} OCRAD_sequence_error A library function was called in the wrong order. For example @samp{OCRAD_result_line} was called before @samp{OCRAD_recognize}. @end deftypevr @deftypevr Constant {enum OCRAD_Errno} OCRAD_library_error A bug was detected in the library. Please, report it (@pxref{Problems}). @end deftypevr @node Image format conversion @chapter Image format conversion @cindex image format conversion There are a lot of image formats, but ocrad is able to decode only three of them; pbm, pgm and ppm. In this chapter you will find command examples and advice about how to convert image files to a format that ocrad can manage. @table @samp @item .png Portable Network Graphics file. Use the command @w{@code{pngtopnm filename.png | ocrad}}.@* In some cases, like the ocrad.png icon, you have to invert the image with the @samp{-i} option: @w{@code{pngtopnm filename.png | ocrad -i}}. @item .ps @itemx .pdf Postscript or Portable Document Format file. Use the command @w{@code{gs -sPAPERSIZE=a4 -sDEVICE=pnmraw -r300 -dNOPAUSE -dBATCH -sOutputFile=- -q filename.ps | ocrad}}.@* You may also use the command @w{@code{pstopnm -stdout -dpi=300 -pgm filename.ps | ocrad}},@* but it seems not to work with pdf files. Also old versions of @code{pstopnm} don't recognize the @samp{-dpi} option and produce an image too small for OCR. @item .tiff TIFF file. Use the command@* @w{@code{tifftopnm filename.tiff | ocrad}}. @item .jpg JPEG file. Use the command @w{@code{djpeg -greyscale -pnm filename.jpg | ocrad}}.@* JPEG is a lossy format and is in general not recommended for text images. @item .pnm.gz Pnm file compressed with gzip. Use the command @w{@code{gzip -cd filename.pnm.gz | ocrad}} @item .pnm.lz Pnm file compressed with lzip. Use the command @w{@code{lzip -cd filename.pnm.lz | ocrad}} @end table @node Algorithm @chapter Algorithm @cindex algorithm Ocrad is mainly a research project. Many of the algorithms ocrad uses are ad hoc, and will change in successive releases as I myself gain understanding about OCR issues. The overall working of ocrad may be described as follows:@* 1) read the image.@* 2) optionally, perform some transformations (cut, rotate, scale, etc).@* 3) optionally, perform layout detection.@* 4) remove frames and pictures.@* 5) detect characters and group them in lines.@* 6) recognize characters (very ad hoc; one algorithm per character).@* 7) correct some errors (transform l.OOO into 1.000, etc).@* 8) output result. @sp 1 Ocrad recognizes characters by its shape, and the reason it is so fast is that it does not compare the shape of every character against some sort of database of shapes and then chooses the best match. Instead of this, ocrad only compares the shape differences that are relevant to choose between two character categories, mostly like a binary search. As there is no such thing as a free lunch, this approach has some drawbacks. It makes ocrad very sensitive to character defects, and makes difficult to modify ocrad to recognize new characters. @node OCR results file @chapter OCR results file @cindex OCR results file Calling ocrad with option @samp{-x} produces an OCR results file (ORF), that is, a parsable file containing the OCR results. The ORF format is as follows: @itemize @minus @item Any line beginning with @samp{#} is a comment line. @item The first non-comment line has the form @w{@samp{source file @var{filename}}}, where @var{filename} is the name of the file being processed (@samp{-} for stdin). This is the only line guaranteed to exist for every input file read without errors. If the file, or any block or line, has no text, the corresponding part in the ORF file will be missing. @item The second non-comment line has the form @w{@samp{total text blocks @var{n}}}, where @var{n} is the total number of text blocks in the source image. @end itemize @noindent For each text block in the source image, the following data follows: @itemize @minus @item A line in the form @w{@samp{text block @var{i} @var{x y w h}}}. Where @var{i} is the block number and @var{x y w h} are the block position and size as described below for character boxes. @item A line in the form @samp{lines @var{n}}. Where @var{n} is the number of lines in this block. @end itemize @noindent For each line in every text block, the following data follows: @itemize @minus @item A line in the form @samp{line @var{i} chars @var{n} height @var{h}}, where @var{i} is the line number, @var{n} is the number of characters in this line, and @var{h} is the mean height of the characters in this line (in pixels). @item N lines (one for every character) in the form @w{@samp{@var{x} @var{y} @var{w} @var{h}; @var{g}[, '@var{c}'@var{v}]...}}, where:@* @var{x} is the left border (x-coordinate) of the char bounding box in the source image (in pixels).@* @var{y} is the top border (y-coordinate).@* @var{w} is the width of the bounding box.@* @var{h} is the height of the bounding box.@* @var{g} is the number of different recognition guesses for this character.@* The result characters follow after the number of guesses in the form of a comma-separated list of pairs. Every pair is formed by the actual recognised char @var{c} enclosed in single quotes, followed by the confidence value @var{v}, without space between them. The higher the value of confidence, the more confident is the result. @end itemize Running @code{./ocrad -x test.orf examples/test.pbm} in the source directory will give you an example ORF file. @node Problems @chapter Reporting Bugs @cindex bugs @cindex getting help There are probably bugs in ocrad. There are certainly errors and omissions in this manual. If you report them, they will get fixed. If you don't, no one will ever know about them and they will remain unfixed for all eternity, if not longer. If you find a bug in GNU Ocrad, please send electronic mail to @email{bug-ocrad@@gnu.org}. Include the version number, which you can find by running @w{@samp{ocrad --version}}. @node Concept index @unnumbered Concept index @printindex cp @bye ocrad-0.22/testsuite/check.sh0000755000076400001440000001041012150373664014547 0ustar yousers#! /bin/sh # check script for GNU Ocrad - Optical Character Recognition program # Copyright (C) 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. # # This script is free software: you have unlimited permission # to copy, distribute and modify it. LC_ALL=C export LC_ALL objdir=`pwd` testdir=`cd "$1" ; pwd` OCRAD="${objdir}"/ocrad OCRCHECK="${objdir}"/ocrcheck framework_failure() { echo "failure in testing framework" ; exit 1 ; } if [ ! -x "${OCRAD}" ] ; then echo "${OCRAD}: cannot execute" exit 1 fi if [ -d tmp ] ; then rm -rf tmp ; fi mkdir tmp cd "${objdir}"/tmp in="${testdir}"/test.pbm txt="${testdir}"/test.txt utxt="${testdir}"/test_utf8.txt fail=0 printf "testing ocrad-%s..." "$2" "${OCRAD}" -q -T-0.1 ${in} > /dev/null if [ $? != 1 ] ; then fail=1 ; printf - ; else printf . ; fi "${OCRAD}" -q -T 1.1 ${in} > /dev/null if [ $? != 1 ] ; then fail=1 ; printf - ; else printf . ; fi "${OCRAD}" -q -u -2,-1,1,1 ${in} > /dev/null if [ $? != 1 ] ; then fail=1 ; printf - ; else printf . ; fi "${OCRAD}" -q -u 1,1,1,1 ${in} > /dev/null if [ $? != 1 ] ; then fail=1 ; printf - ; else printf . ; fi "${OCRAD}" -q ${in} > out || fail=1 cmp ${txt} out || fail=1 printf . "${OCRAD}" -q -u 0,0,1,1 ${in} > out cmp ${txt} out || fail=1 printf . "${OCRAD}" -q -u -1,-1,1,1 ${in} > out cmp ${txt} out || fail=1 printf . test_chars() { for coord in ${coords} ; do produced_chars="${produced_chars}`"${OCRAD}" -q -u${coord} ${in}`" || fail=1 done if [ "${produced_chars}" != "${expected_chars}" ] ; then echo echo "expected \"${expected_chars}\"" echo "produced \"${produced_chars}\"" fail=1 fi printf . } coords=' 71,109,17,26 92,109,17,26 114,109,15,26 132,109,17,26 152,109,18,26 172,109,19,26 193,109,17,26 214,109,17,26 234,108,17,27 253,109,18,26 274,109,17,26 68,153,29,27 97,153,24,27 126,153,23,27 153,153,27,27 183,153,24,27 210,153,23,27 237,153,27,27 266,153,30,27 298,153,13,27 313,153,20,27 335,153,29,27 365,153,23,27 391,153,34,27 426,153,30,27 69,189,30,35 102,197,26,27 132,197,24,27 159,197,26,34 188,197,26,27 217,197,20,27 241,197,24,27 266,197,30,27 297,197,28,27 326,197,37,27 364,197,27,27 390,197,28,27 420,197,21,27' expected_chars="0ol23456789ABcDEFGHIJKLMNÑopQRsTuvwxYz" produced_chars= test_chars coords=' 71,250,18,18 90,240,20,28 112,250,15,18 131,240,19,28 152,250,17,18 170,241,16,27 183,249,20,27 204,240,23,28 227,241,11,27 236,241,11,35 251,240,22,28 274,240,11,28 287,250,32,18 321,250,22,18 70,288,22,25 92,295,17,18 111,295,19,26 132,295,20,26 152,295,16,18 169,295,14,18 185,288,13,25 200,295,22,18 221,295,20,18 242,295,27,18 270,295,20,18 289,295,20,26 310,295,16,18' expected_chars="abcdefghijklmnñopqrstuvwxyz" produced_chars= test_chars coords=' 68,366,29,36 97,366,24,36 124,366,13,36 140,366,26,36 168,366,30,36 208,366,29,36 237,366,24,36 265,366,13,36 281,366,26,36 308,366,30,36 349,368,29,34 378,368,24,34 405,368,13,34 421,368,26,34 449,368,30,34 68,410,29,36 97,410,24,36 124,410,13,36 140,410,26,36 167,410,30,36 71,463,18,27 91,463,17,27 109,463,11,27 123,463,17,27 142,463,22,27 177,463,18,27 198,463,17,27 216,463,11,27 229,463,17,27 249,463,22,27 284,466,18,24 305,466,17,24 323,466,12,24 336,466,17,24 356,466,22,24 391,463,18,27 411,463,17,27 431,463,10,27 443,463,17,27 462,463,22,27' expected_chars="ÁÉÍóúÀÈÌòùÄËÏöüÂÊÎôûáéíóúàèìòùäëïöüâêîôû" produced_chars= test_chars coords='137,516,19,19 174,508,15,15 192,508,11,27 245,509,19,26 268,505,17,35 322,508,27,27 353,508,10,31 367,508,9,31 70,558,15,29 86,552,14,27 104,552,9,31 128,552,15,27 158,552,9,31 173,552,17,15 195,552,8,31 215,552,3,27 228,552,9,31 252,560,19,19 275,560,19,19 347,561,15,26 364,552,23,35 391,552,25,27 72,612,18,6 94,613,19,11 114,602,19,22 134,597,12,15 150,597,11,15' expected_chars="+*/#$&()¿?[\\]^{|}<>çÇ@~¬±ªº" produced_chars= test_chars "${OCRCHECK}" ${in} > out || fail=1 cmp ${txt} out || fail=1 printf . "${OCRCHECK}" ${in} --utf8 > out || fail=1 cmp ${utxt} out || fail=1 printf . echo if [ ${fail} = 0 ] ; then echo "tests completed successfully." cd "${objdir}" && rm -r tmp else echo "tests failed." fi exit ${fail} ocrad-0.22/testsuite/test.pbm0000644000076400001440000015423310214362660014617 0ustar yousersP4 560 792 @€ À>pøà€ðÿàÀøðÿ€àÿÀþàÿüÿà?ðþÀà<€p<€ààø<€Àøð>ÁÀÀð>€ðàx<€Àà>8À<Àà~pàx>€Àà8À<Àà~pà€x€Àà0à<ààïxà€ø€3ÀÀð8<ààïxà€ø3ÀøÀü8<àáÏxàðcÀ?þÇàÿà<àáÏxààüÃÀàãxààüÃÀ8ƒøx?ðàãxàÀƒÀ0ƒð<?øàçxà€À Ãà>8óüýàçxà†ÀÃà8À~ñàîxàÆÀÃÀ8Ààîxà88Ïÿþ8ÃÀx€àüxà`|Ïÿþ|ÃÀx€ÀüpàÀüÀÀ|ÃÀø€ Àø€ðà€øÀÀ|Áàø€Àx€àà8øÀÀxà>ø€>€p€ààÿøà€Àp€ð<øÀ>?ÿŸÿøøüðàðàðpÿðþ0ÿðÿÿü?ÿÿ€þ ?þÿ?þùÿñÿçÿÀÿ€ÿ¿àÿpÿøÿðÿüÿÿü?ÿÿ€ÿð?þÿ?þùÿñÿçÿÀÿÀÿ¿ðÿð€~ð€þüÀ€~ðÀàà€?|Àðððø€8ð€<À€øðÀàà€<xÀðøðø€xx€€À€ððÀàà€pxàðü`ü€ðx€ÀÀððÀàà€`xàðþ`¼€ðx€à ÀƒàpÀàà€Àxàð¾`¾€ð8€à ÀáƒàpÀàà€€xð ðŸ`>€ð8€à Àá‡à0Ààà€xð ð€`€à8€ðÀà‡à0Ààà€xððÀ`€à€ðÁàÀÀàà€xøð‡À`€øà€ðÃàÀÀàà€?xøðƒà`€ÿàà€ðÿÿàÀÿÿàà€xx8ðð` €ÿøà€ðÿÿàÀÿÿàà€ï€x|0ð€ð` €€üà€ðÃàÀÿÀàà€ÇÀx|0ð€ø`À€à€ðÀàÀÿÀàà€‡Àx>pð€|`ÿÀ€à€ðÀàÀÿÀàà€àx>`ð€>`?ÿà€ƒà€ðÀàÀðÀàà€ðx8>`ð€`0à€ð€àÀàÀðÀàà?€øx0àð€`0ð€ð€àÀàðÀàà€øx0Àð€àpð€ð8€ÀÀàðÀàà€|x0Àð€à`ð€€ø0€ÀÀàðÀàà~€~xpÀð€ààø€€xp€€ÀððÀàà`€>xp€ðÀààø€<à€ÀøðÀààpxð<€ðÀàð|À~À€~þÀ~ðÀàà8?€|ð>€ðààþÿ¿ÿüÿ€ÿüÿÿþ?þ?þ0?þÿ?þþÿñÿ÷ÿÿñÿÇÿŸü`þÿ¿ÿðþÿàÿÿü?þø0?þÿ?þøÿñÿ÷ÿÿñÿÃÿŸü`@ø`ÿÀ€üÿàþÿþÿÿüþ0ÿÿ?þÿüûÿŸüïÿûÿáÿÇÿÿ€þÿàÿ€ÿÿ€ÿÀÿÿÿðÿÿ?þÿüûÿŸüïÿûÿáÿÇÿÿ~>>àðÀðð€ð|?àøÀà|àðà~>à?xððà<xðÀðxàxÀÀ|àø€>€>?€ øxðð<<ðà8ðpàpÀ€<ð|<?À ð|ððx>ðà8ppà0à€>ð|€8|7À ð<ððøðà8p`à0à€>ð>€pø3à ð>ððøðà<0`à0ðð À`ð1ð à>ððøðà<0`à0ðø ààð1ø àðñð€ðÀ?0`à0ðø¸àÀà0ø àðáð€ðÀðÀà0øxðñÀÀ0| àðÁð€ð€þà0øƒ|àñ€À0> àðð€ÿþÿÀà0| ‡<8àû€€0 àÿÿð€ÿðÿàà0| †<0ð€0 àÿüð€ð|ÿðà0<†>0ð?0Œàðð€ððà0>Îpø>>0Ìàðð€ð@øà0>8Ìp|>0Ìàðð|ð`xà00Ì`~|€0ìà>ðùþð`8à00ü` >ø€0üð>ðùÇð`8à0pøàø€0üð<ð{ƒžð€p8àpàøÀ8€ð€0|ð|ð{üðŒp8ð`àøÀp€à€8|xxð?üðŒx8ðàÀðÀ`Ààx<|ððøðÌ|pøÀÀð€ààÀü?àðððø€à>þ€Àð€ðð>€?ÿ€ ÿ€ÿ€ÿàÿ‡øwÿÀÿà?ÿ€p€þ?þÿàÿÿÿ€ þÿ€ÿàÿƒðaÿÿàü€`þ?þÿàÿÿðñ€ñ€ù€ÿ€>€àðàÀ?€à?€ðÀ à?À?€àÿÀðàà?À€àãÀðààÀ€àÃÀðÀ àÀ€àÁÀðàÀ€àÀðàÀ€àÀðàÀ€àÀðàÀ€àÀÀðàÀàŸ€ðùàð?üóàñðàçþÀ|€ø¿àüýàø?üþðóüáþçþÁýþ?À?Àð|ñðà<À>>àþ<áþàøÁÿqàãÀà<Àø<>à<À<@øàààÀ>Áðàð<Àxx>àxÀxøàáÀÀ>Àððð<€|x>àxÀxðàã€À>Àððà<€|ðàxÀxðàçÀ<€ððü€<ðàøƒÀxðàïÀ<€ððü€<ðàÿÿƒÀ|ðàÿ€À<€ðð><€<ðàÿÿƒÀ<ðà÷€À<€ððp<€<ðàøÀ|ðàóÀÀ<€ððð<€<ðàøÀððàãàÀ<€ððà<€<øàxÀ<ðàáðÀ<€ððà<ÀxxàxÀ`ðààðÀ<€ððà|Àp| à|À`ðààxÀ<€ðððü‡ñà>‡à>Àþðàà|À<€ððÿßÆÀøýüüøÿþïüûÿŸùÿ¿÷þçþ ?€àùüðø?ÿ‡þïüûÿŸùÿ¿÷þçþ8?€ð€à€à€à€<ø8þðøàÆü0øøø|ü~ <Ìø>Çü¿Ïóûÿ¿çùÿøùþÿýþÿ˜þ~üÿøþÇü¿Ïóûÿ¿çùÿøÿãÁÿãøþß0|þÁðÀpüáàø|à>ƒ€øŸ`Àð À`|ÁÀð|‡€ð>‡€ø` ÀðÀ`>€Áàx‡€ð>Ç€x p ÀxƒàÀ0ƒàxx<Ïx|ÀxƒàÀ`ÁƒÀxx<ÏxàÀ<0†ðÀÀÀ€xx<Ïx?øÀ<0Æñ€ÀÃxx<ÏxüÀ0Æq€àãxx<ÏxþÀ`ì{€àæxx<Ïx`> À`ì{ðö<x€ø<Ï€ø` ÀÀø? øþxx‡€ð>‡€øp ÀÀø>x|xx‡€à>‡Àøx À€ø0<|ðxƒãÀ?áø~ À€pp?xàxÿ?ñÿ€=þÿxÿÀøðûü€pþÿÀ8ÿøÿ?ð<ü~xÿÀgðàãüp þÿÀ8ÿø<x0<x0<x`<xx`<xxÀ<xy€ÿ€ÿÿ€ÿ>` `0à€à<ð8ðÀà<xx€<xàƒ0`ƒ €pàÀ<ðÇ€pðÇ€88àÀ`8Ç€xðÇ€` `€0€ ƒ0`ƒ €€€@pÿÿÿ€øÿøüÿÿðüÀÿÿÀ8?ÿÿ‡ÿÀüüþpÿÿÿ€?þÿøüÿÿðüÿðÿÿÀ8?ÿÿ‡ÿÀÿüþð€?xø€€àxðÀÀüx>xÀ€<|ÀÀðø€xàÀ€à€xðÀx|À€<ðàÀðø€xàà€À€xpÀx|À€<ððÀàü€xÀð€ÀÀxpÀ€x þÀ€<àøÀ`¼€xÀð€ÀÀx0À>€x ÞÀ€<àxÀ`¾ÃxÀø€À;àx0À>Àx ßÀá€<à|À`>Ãx€ø€À3àx0À|Àx ŸÀá€<À|À`Áx€|€À1àxÀ|àx Àà€<À>À`ƒÀx€|€Àqðx<À|àx €Áà<À>À`‡Àx€|€À`ðx|À|àx €Ãà<À>À`€ÿÀx€|€ÀàøüÀ|àx Àÿà<À>À` €ÿÀx€|€ÀÀøüÀ|àx Àÿà<À>À` €‡Àx€|€ÀÀxx|À|àx ÀÃà<À>À`ÀÀx€|€ÀÀ|xÀ|àx àÀà<À>À`ÿÀÀx€|€ÀÿüxÀ|àx ÿàÀà<À>À`?ÿàÁ€x€|€ÀÿþxÀ|àx ÿðÀàÀ<À>À`0àÁ€x€ø€À>xÀ<Àx ðÀàÀ<À|À`0ð€€xÀø€Àx8À>Àx øÀÀ<à|À`pð€€xÀð€Àx8À>€x8øÀÀ<àxÀà`ð€€xÀðÀ€x8À€|0xÀÀ<àøàÀàø€€xààÀ€€xxÀ|8p|ÀÀ<ððàÀàø€€xðÀà€xxÀ€>pp|ÀÀ<øàð€ð|À?€øü€øÀ|øÀà|?àø>àÀ|~Àüþÿ¿ÿÿÿ€?þÿüÿàûÿÿøüÿðÿÀÿÿßÿÿÇÿÀÿþþÿ¿ÿÿÿ€ø?ðÿàûÿÿðüÀÿÿÿßÿÿ‡ÿÀüøppÀøøà€ü€üðÀŒ9€Ì0à`À 8`À` 0€ @pÿÿÿ€øÿð?øpÿÿÿ€?þÿð?øð€?xø€Àø€xàÀÀø€xàà€ü€xÀð€¼€xÀð€¾ÃxÀø€>Ãx€ø€Áx€|€ƒÀx€|€‡Àx€|€€ÿÀx€|€ €ÿÀx€|€ €‡Àx€|€ÀÀx€|€ÿÀÀx€|€?ÿàÁ€x€|€0àÁ€x€ø€0ð€€xÀø€pð€€xÀð€`ð€€xÀð€àø€€xàà€àø€€xðÀÀð|À?€øü€ð<þÿ¿ÿÿÿ€?þÿøþÿ¿ÿÿÿ€øà€€ @À0€8À€Àpàà€€<<8Àx€€<xððÀÀ|~|àðx€<8xàÃÀ ppàînîpÀ<àÀðãÀ><øð`ÇÃÇ0€8p8Àà8ÃÀpð00ƒ`À`0€ €  ` ƒÂ€ à~xþøøÀ?€àÿøàðàà~<þøøÿøÿøþ?àÿÀàÿÀüàøáüøÿüÿøð|LJøǃø<xðÿñààƒàà<áüð|Çüǃøà<ÀxÀxxð8Àðààà8à<à<À<Àxð<àxàx|à<Àxàà<àxà<ð<à<àxð<àxàx|à<Àxàà<àxà<ð<à<àxà<àxðx8à<€<àà<àðà<à<à<ðxüðxðxà>€<àà|Áàðà<üð<ðxüÿðxðxÿÿþ€<ààÿÁàðà<üÿð<ðx><ÿðxðxÿþ€<àñàÿÁàðà<><ÿð<ðxp<xðxà€<àà|àðà<p<<ðxð<xðx<à€<àà|àðà<ð<<ðxà<xðxxàÀ|àà<àøà<à<<ðxà< xàxxàÀxàà<àxà<à< <àxà|€`xÀxxð Àpàà>àxà|à|€`<Àxðü‡ÁÀxÇ€|?|? ø8ñà‡à‡äà><ðüðü‡ÁÀ<Ç€|?ÿßÃÿƒÿÿ?ïð?÷ððàÿÀýþþþþüøÿ¿ÀÿßÃÿÿƒÿ?ïðþÿþðÃÀÀà?€ñþøxøüð~?Àþÿ€þð`Çp?€a€àÇ€8ÿ€øÀÀÀàÇ8ÿÀžñà€`„8À‡8˜à‡þààpÄxÀ‡8püàà8åð€ƒ8ðàà<?Àƒ8ð>áàƒàƒ8pð< 0áÀp?à‚8pà| póÀ<àpåðàÿÿx `÷€<ð>pÄxÀÿÿØxàþ<ð>p„88pøx0Àøxð>p 8pÿ€xÿÿpÀpàð>xÿðÀÿþø>xÿðÿ€Àÿþx <<xÿðÿ€8Àpàx | <Žxpÿ€0Àpà˜8ø<ÌxppÀ`À˜8ø>ø<ÿÿppÀáÀ˜80ð>ø<ÿÿp`ÀáÀ8pð0?ø<ÿÿpà>pàÀáÀp`ð €ü8øð>pÀÀáÀàÀxÀÃÿðøø>pÀÀáÀßÀÀ?€ÿ?à8øøpÀÀáÀÿ€€üÀ8XXà<pà€`80àÀÀ00ÿüàa€`àÿüàÀ€à€àÀ€ÿ€€þàÀ08øÀÿÿÀÿ€ÀþÀÀ€8<?ÿÀÿÀƒàðÀ?€ÀÀ<8xÀððð`?€ÀÀ8àÀ<8Àððp{€ÀÀààxàðð0sÀÀÀ€Ààpàðð8ñàÀÀÀÀààyÆÀððààÀÀ ÀàÀÿÇ€ððàðÀÀÀáÁçÇ€àð ÀpÀÀ>þ€áÃǃàðÀxÀÀþÀÿ€A‡‡ƒÀð€8ÀÀøðÃÏ€ƒ€ð€<ÀÀàü‡Ï€ƒð€Àà€€Ï€Ÿ‡ð€ÀøþàÏ€ž ðÀ<Àxøø€žðÀÀðÀü€Þ ðàÀà€|€!Þð`ÀÀàüÀ`Ï>8ð0ÀÀøøÀ`çîpð8ÀÀþàÀàcÏÆ8ðÀÀ€€ƒàÀpŽxðÀÀàüÃàÀ8ð>ð ÀÀøðð€8à>ðÀÀþÀÀüðà>ðÀÀ>ÿþÿÀÀpðÀÀþøÿÀøðÀxÀøð€À`Àøÿ€þÀ€|Ààxÿ€þàþàà0àððààüÀ?€ø€þ|‡ÇÃÀ?ƒ€8óƒ€8ƒƒ€8ƒ€8Ç8ÀÆ8ùÀ|88?ÿùÿÿ€?ÿùÿÿ€>?ÿøÃÿÿ€8ÿþÿãÃÿÿ€8ÿþãÿƒÿÿ€8ÿþ€ÿ€8>€8€8€8€¿ÿø¿ÿø¿ÿøocrad-0.22/testsuite/test.txt0000644000076400001440000000025110214314606014643 0ustar yousers00123456789 ABCDEFGHIJKLMN ÑOPQRSTUVWXYZ abcdefghijklmn ñopqrstuvwxyz ÁÉÍÓÚ ÀÈÌÒÙ ÄËÏÖÜ ÂÊÎÔÛ áéíóú àèìòù äëïöü âêîôû ,.;:_+-*/¡!"#$%&()= ¿?[ \ ]^{|} <>` ' çÇ@ ~¬±ªº÷ ocrad-0.22/testsuite/test_utf8.txt0000644000076400001440000000033410214362660015616 0ustar yousers00123456789 ABCDEFGHIJKLMN ÑOPQRSTUVWXYZ abcdefghijklmn ñopqrstuvwxyz ÃÉÃÓÚ ÀÈÌÒÙ ÄËÃÖÜ ÂÊÎÔÛ áéíóú àèìòù äëïöü âêîôû ,.;:_+-*/¡!"#$%&()= ¿?[ \ ]^{|} <>` ' çÇ@ ~¬±ªº÷ ocrad-0.22/ocrad.png0000644000076400001440000000033310363251477012704 0ustar yousers‰PNG  IHDR0¼ý~Ü¢IDATX…í–Ý€ …¥õþ¯L7±~DE›‹oë";ëˆÇ°”‚àßÀó‘‘@>f­Ós{gÆ™Zëx0%<'XÕnZ¹àºìa £–¡TçK!uØm^ó] ‘À(ÔmzŸSwšPÀ»Ún·É ä“/õùÁsÀßܨDÙÉ[ÓèX¾ 1Ð*µVKª#|R($ 5±ß½8þN“F:†Öë2.¼BgIEND®B`‚ocrad-0.22/arg_parser.h0000644000076400001440000000770412110527212013376 0ustar yousers/* Arg_parser - POSIX/GNU command line argument parser. (C++ version) Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this library. If not, see . As a special exception, you may use this file as part of a free software library without restriction. Specifically, if other files instantiate templates or use macros or inline functions from this file, or you compile this file and link it with other files to produce an executable, this file does not by itself cause the resulting executable to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the executable file might be covered by the GNU General Public License. */ /* Arg_parser reads the arguments in 'argv' and creates a number of option codes, option arguments and non-option arguments. In case of error, 'error' returns a non-empty error message. 'options' is an array of 'struct Option' terminated by an element containing a code which is zero. A null name means a short-only option. A code value outside the unsigned char range means a long-only option. Arg_parser normally makes it appear as if all the option arguments were specified before all the non-option arguments for the purposes of parsing, even if the user of your program intermixed option and non-option arguments. If you want the arguments in the exact order the user typed them, call 'Arg_parser' with 'in_order' = true. The argument '--' terminates all options; any following arguments are treated as non-option arguments, even if they begin with a hyphen. The syntax for optional option arguments is '-' (without whitespace), or '--='. */ class Arg_parser { public: enum Has_arg { no, yes, maybe }; struct Option { int code; // Short option letter or code ( code != 0 ) const char * name; // Long option name (maybe null) Has_arg has_arg; }; private: struct Record { int code; std::string argument; explicit Record( const int c = 0 ) : code( c ) {} }; std::string error_; std::vector< Record > data; bool parse_long_option( const char * const opt, const char * const arg, const Option options[], int & argind ); bool parse_short_option( const char * const opt, const char * const arg, const Option options[], int & argind ); public: Arg_parser( const int argc, const char * const argv[], const Option options[], const bool in_order = false ); // Restricted constructor. Parses a single token and argument (if any) Arg_parser( const char * const opt, const char * const arg, const Option options[] ); const std::string & error() const { return error_; } // The number of arguments parsed (may be different from argc) int arguments() const { return data.size(); } // If code( i ) is 0, argument( i ) is a non-option. // Else argument( i ) is the option's argument (or empty). int code( const int i ) const { if( i >= 0 && i < arguments() ) return data[i].code; else return 0; } const std::string & argument( const int i ) const { if( i >= 0 && i < arguments() ) return data[i].argument; else return error_; } }; ocrad-0.22/bitmap.h0000644000076400001440000000524512123651045012531 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Bitmap : public Rectangle { std::vector< std::vector< uint8_t > > data; // faster than bool public: // Creates a blank Bitmap Bitmap( const int l, const int t, const int r, const int b ); // Creates a Bitmap from part of another Bitmap Bitmap( const Bitmap & source, const Rectangle & re ); using Rectangle::left; using Rectangle::top; using Rectangle::right; using Rectangle::bottom; using Rectangle::height; using Rectangle::width; void left ( const int l ); void top ( const int t ); void right ( const int r ); void bottom( const int b ); void height( const int h ) { bottom( top() + h - 1 ); } void width ( const int w ) { right( left() + w - 1 ); } void add_bitmap( const Bitmap & bm ); void add_point( const int row, const int col ); void add_rectangle( const Rectangle & re ); bool adjust_height(); bool adjust_width(); bool get_bit( const int row, const int col ) const { return data[row-top()][col-left()]; } void set_bit( const int row, const int col, const bool bit ) { data[row-top()][col-left()] = bit; } int area() const; // 'area' means filled area int area_octagon() const; int size_octagon() const; int seek_left ( const int row, const int col, const bool black = true ) const; int seek_top ( const int row, const int col, const bool black = true ) const; int seek_right ( const int row, const int col, const bool black = true ) const; int seek_bottom( const int row, const int col, const bool black = true ) const; bool escape_left ( int row, int col ) const; bool escape_top ( int row, int col ) const; bool escape_right ( int row, int col ) const; bool escape_bottom( int row, int col ) const; int follow_top ( int row, int col ) const; int follow_bottom( int row, int col ) const; bool top_hook ( int *hdiff ) const; bool bottom_hook( int *hdiff ) const; }; ocrad-0.22/blob.h0000644000076400001440000000372412160616254012177 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Blob : public Bitmap { std::vector< Bitmap * > holepv; // vector of holes public: Blob( const int l, const int t, const int r, const int b ) : Bitmap( l, t, r, b ) {} Blob( const Bitmap & source, const Rectangle & re ) : Bitmap( source, re ) {} Blob( const Blob & b ); Blob & operator=( const Blob & b ); ~Blob(); using Bitmap::left; using Bitmap::top; using Bitmap::right; using Bitmap::bottom; using Bitmap::height; using Bitmap::width; void left ( const int l ); void top ( const int t ); void right ( const int r ); void bottom( const int b ); void height( const int h ) { bottom( top() + h - 1 ); } void width ( const int w ) { right( left() + w - 1 ); } const Bitmap & hole( const int i ) const; int holes() const { return holepv.size(); } // id = 1 for blob dots, negative for hole dots, 0 otherwise int id( const int row, const int col ) const; bool is_abnormal() const { return height() < 10 || height() >= 5 * width() || width() >= 3 * height(); } bool test_BD() const; bool test_Q() const; void print( FILE * const outfile ) const; void fill_hole( const int i ); void find_holes(); }; ocrad-0.22/character.h0000644000076400001440000000642412150233277013214 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Character : public Rectangle { public: struct Guess { int code; int value; Guess( const int c, const int v ) : code( c ), value( v ) {} }; private: std::vector< Blob * > blobpv; // the blobs forming this Character std::vector< Guess > gv; // vector of possible char codes // and their associated values. // gv[0].code < 0 means further // processing is needed (merged chars) void recognize11( const Charset & charset, const Rectangle & charbox ); void recognize110( const Charset & charset, const Rectangle & charbox ); void recognize111( const Charset & charset, const Rectangle & charbox ); void recognize112( const Rectangle & charbox ); void recognize12( const Charset & charset, const Rectangle & charbox ); void recognize13( const Charset & charset, const Rectangle & charbox ); public: explicit Character( Blob * const p ) : Rectangle( *p ), blobpv( 1, p ) {} Character( const Rectangle & re, int code, int value ) : Rectangle( re ), gv( 1, Guess( code, value ) ) {} Character( const Character & c ); Character & operator=( const Character & c ); ~Character(); int area() const; const Blob & blob( const int i ) const; Blob & blob( const int i ); int blobs() const { return blobpv.size(); } Blob & main_blob(); void shift_blobp( Blob * const p ); void add_guess( const int code, const int value ) { gv.push_back( Guess( code, value ) ); } void clear_guesses() { gv.clear(); } void insert_guess( const int i, const int code, const int value ); void delete_guess( const int i ); void only_guess( const int code, const int value ) { gv.clear(); gv.push_back( Guess( code, value ) ); } bool set_merged_guess( const int code1, const int right1, const int code2, const int blob_index ); void swap_guesses( const int i, const int j ); const Guess & guess( const int i ) const; int guesses() const { return gv.size(); } bool maybe( const int code ) const; // bool maybe_digit() const; // bool maybe_letter() const; void join( Character & c ); unsigned char byte_result() const; const char * utf8_result() const; void print( const Control & control ) const; void dprint( const Control & control, const Rectangle & charbox, const bool graph, const bool recursive ) const; void xprint( const Control & control ) const; void recognize1( const Charset & charset, const Rectangle & charbox ); void apply_filter( const Filter & filter ); }; ocrad-0.22/common.h0000644000076400001440000000462312150245250012541 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ extern int verbosity; namespace Ocrad { void internal_error( const char * const msg ); bool similar( const int a, const int b, const int percent_dif, const int abs_dif = 1 ); } // end namespace Ocrad class Charset { int charset_; public: enum Value { ascii = 1, iso_8859_9 = 2, iso_8859_15 = 4 }; Charset() : charset_( 0 ) {} bool enable( const char * const name ); bool enabled( const Value cset ) const; bool only( const Value cset ) const; void show_error( const char * const program_name, const char * const arg ) const; }; class Filter { public: enum Type { none, letters, letters_only, numbers, numbers_only }; private: Type type_; public: Filter() : type_( none ) {} bool set( const char * const name ); Type type() const { return type_; } void show_error( const char * const program_name, const char * const arg ) const; }; class Transformation { public: enum Type { none, rotate90, rotate180, rotate270, mirror_lr, mirror_tb, mirror_d1, mirror_d2 }; private: Type type_; public: Transformation() : type_( none ) {} bool set( const char * const name ); Type type() const { return type_; } void show_error( const char * const program_name, const char * const arg ) const; }; struct Control { Charset charset; Filter filter; FILE * outfile, * exportfile; int debug_level; char filetype; bool utf8; Control() : outfile( stdout ), exportfile( 0 ), debug_level( 0 ), filetype( '4' ), utf8( false ) {} bool set_format( const char * const name ); }; ocrad-0.22/feats.h0000644000076400001440000000454212161621522012355 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Features { const Blob & b; // Blob to witch these features belong mutable int hbars_, vbars_; mutable std::vector< Rectangle > hbar_, vbar_; mutable std::vector< std::vector< Csegment > > row_scan, col_scan; Features( const Features & ); // declared as private void operator=( const Features & ); // declared as private public: mutable Profile lp, tp, rp, bp, hp, wp; explicit Features( const Blob & b_ ); // const Blob & blob() const { return b; } const Rectangle & hbar( const int i ) const { return hbar_[i]; } const Rectangle & vbar( const int i ) const { return vbar_[i]; } int hbars() const; int vbars() const; int segments_in_row( const int row ) const; int segments_in_col( const int col ) const; Csegment col_segment( const int row, const int col ) const; int test_235Esz( const Charset & charset ) const; int test_49ARegpq( const Rectangle & charbox ) const; int test_4ADQao( const Charset & charset, const Rectangle & charbox ) const; int test_6abd( const Charset & charset ) const; int test_CEFIJLlT( const Charset & charset ) const; int test_c() const; int test_frst( const Rectangle & charbox ) const; int test_G() const; int test_HKMNUuvwYy( const Rectangle & charbox ) const; int test_hknwx( const Rectangle & charbox ) const; int test_s_cedilla() const; bool test_comma() const; int test_easy( const Rectangle & charbox ) const; int test_line( const Rectangle & charbox ) const; int test_solid( const Rectangle & charbox ) const; int test_misc( const Rectangle & charbox ) const; }; ocrad-0.22/mask.h0000644000076400001440000000351212140443140012175 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Mask : public Rectangle { std::vector< Csegment > data; // csegment in each line public: // Creates a rectangular Mask explicit Mask( const Rectangle & re ) : Rectangle( re ), data( height(), Csegment( re.left(), re.right() ) ) {} Mask( const int l, const int t, const int r, const int b ) : Rectangle( l, t, r, b ), data( height(), Csegment( l, r ) ) {} using Rectangle::left; using Rectangle::top; using Rectangle::right; using Rectangle::bottom; using Rectangle::height; int left ( const int row ) const; int right( const int row ) const; void top ( const int t ); void bottom( const int b ); void height( const int h ) { bottom( top() + h - 1 ); } void add_mask( const Mask & m ); void add_point( const int row, const int col ); void add_rectangle( const Rectangle & re ); bool includes( const Rectangle & re ) const; bool includes( const int row, const int col ) const; int distance( const Rectangle & re ) const; int distance( const int row, const int col ) const; }; ocrad-0.22/ocradlib.h0000644000076400001440000001011312166633570013034 0ustar yousers/* Ocradlib - Optical Character Recognition library Copyright (C) 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . As a special exception, you may use this file as part of a free software library without restriction. Specifically, if other files instantiate templates or use macros or inline functions from this file, or you compile this file and link it with other files to produce an executable, this file does not by itself cause the resulting executable to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the executable file might be covered by the GNU General Public License. */ #ifdef __cplusplus extern "C" { #endif const char * const OCRAD_version_string = "0.22"; /* OCRAD_Pixmap.data is a pointer to image data formed by "height" rows of "width" pixels each. The format for each pixel depends on mode like this: OCRAD_bitmap --> 1 byte per pixel; 0 = white, 1 = black OCRAD_greymap --> 1 byte per pixel; 256 level greymap (0 = black) OCRAD_colormap --> 3 bytes per pixel; 16777216 colors RGB (0,0,0 = black) */ enum OCRAD_Pixmap_Mode { OCRAD_bitmap, OCRAD_greymap, OCRAD_colormap }; struct OCRAD_Pixmap { const uint8_t * data; int height; int width; enum OCRAD_Pixmap_Mode mode; }; enum OCRAD_Errno { OCRAD_ok = 0, OCRAD_bad_argument, OCRAD_mem_error, OCRAD_sequence_error, OCRAD_library_error }; struct OCRAD_Descriptor; const char * OCRAD_version( void ); /*--------------------- Functions ---------------------*/ struct OCRAD_Descriptor * OCRAD_open( void ); int OCRAD_close( struct OCRAD_Descriptor * const ocrdes ); enum OCRAD_Errno OCRAD_get_errno( struct OCRAD_Descriptor * const ocrdes ); int OCRAD_set_image( struct OCRAD_Descriptor * const ocrdes, const struct OCRAD_Pixmap * const image, const bool invert ); int OCRAD_set_image_from_file( struct OCRAD_Descriptor * const ocrdes, const char * const filename, const bool invert ); int OCRAD_set_utf8_format( struct OCRAD_Descriptor * const ocrdes, const bool utf8 ); // 0 = byte, 1 = utf8 int OCRAD_set_threshold( struct OCRAD_Descriptor * const ocrdes, const int threshold ); // 0..255, -1 = auto int OCRAD_scale( struct OCRAD_Descriptor * const ocrdes, const int value ); int OCRAD_recognize( struct OCRAD_Descriptor * const ocrdes, const bool layout ); int OCRAD_result_blocks( struct OCRAD_Descriptor * const ocrdes ); int OCRAD_result_lines( struct OCRAD_Descriptor * const ocrdes, const int blocknum ); // 0..blocks-1 int OCRAD_result_chars_total( struct OCRAD_Descriptor * const ocrdes ); int OCRAD_result_chars_block( struct OCRAD_Descriptor * const ocrdes, const int blocknum ); // 0..blocks-1 int OCRAD_result_chars_line( struct OCRAD_Descriptor * const ocrdes, const int blocknum, // 0..blocks-1 const int linenum ); // 0..lines[block]-1 const char * OCRAD_result_line( struct OCRAD_Descriptor * const ocrdes, const int blocknum, // 0..blocks-1 const int linenum ); // 0..lines[block]-1 int OCRAD_result_first_character( struct OCRAD_Descriptor * const ocrdes ); #ifdef __cplusplus } #endif ocrad-0.22/page_image.h0000644000076400001440000000575312124647151013343 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ struct OCRAD_Pixmap; class Mask; class Rational; class Track; class Page_image : public Rectangle // left,top is always 0,0 { public: struct Error { const char * const msg; explicit Error( const char * const s ) : msg( s ) {} }; using Rectangle::left; using Rectangle::top; using Rectangle::right; using Rectangle::bottom; using Rectangle::height; using Rectangle::width; private: std::vector< std::vector< uint8_t > > data; // 256 level greymap uint8_t maxval_, threshold_; // x > threshold == white void read_p1( FILE * const f, const bool invert ); void read_p4( FILE * const f, const bool invert ); void read_p2( FILE * const f, const bool invert ); void read_p5( FILE * const f, const bool invert ); void read_p3( FILE * const f, const bool invert ); void read_p6( FILE * const f, const bool invert ); void left ( int ); // resize functions declared as private void top ( int ); void right ( int ); void bottom( int ); void height( int ); void width ( int ); public: // Creates a Page_image from a pbm, pgm or ppm file Page_image( FILE * const f, const bool invert ); // Creates a Page_image from a OCRAD_Pixmap Page_image( const OCRAD_Pixmap & image, const bool invert ); // Creates a reduced Page_image Page_image( const Page_image & source, const int scale ); bool get_bit( const int row, const int col ) const { return data[row-top()][col-left()] <= threshold_; } bool get_bit( const int row, const int col, const uint8_t th ) const { return data[row-top()][col-left()] <= th; } void set_bit( const int row, const int col, const bool bit ) { data[row-top()][col-left()] = ( bit ? 0 : maxval_ ); } uint8_t maxval() const { return maxval_; } uint8_t threshold() const { return threshold_; } void threshold( const Rational & th ); // 0 <= th <= 1, else auto void threshold( const int th ); // 0 <= th <= 255, else auto bool cut( const Rational ltwh[4] ); void draw_mask( const Mask & m ); void draw_rectangle( const Rectangle & re ); void draw_track( const Track & tr ); bool save( FILE * const f, const char filetype ) const; bool scale( int n ); void transform( const Transformation & t ); }; ocrad-0.22/profile.h0000644000076400001440000000426412160066444012721 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Profile { public: enum Type { left, top, right, bottom, height, width }; private: const Bitmap & bm; // Bitmap to witch this profile belongs // can be a Blob or a hole Type type; int limit_, max_, min_, mean_; signed char isconcave_, isconvex_, isflat_, isflats_, ispit_, istpit_, isupit_, isvpit_, istip_; std::vector< int > data; void initialize(); int mean(); public: Profile( const Bitmap & bm_, const Type t ); // const Bitmap & bitmap() const { return bm; } int limit() { if( limit_ < 0 ) initialize(); return limit_; } int max(); int max( const int l, int r = -1 ); int min(); int min( const int l, int r = -1 ); int operator[]( int i ); int pos( const int p ) { return ( ( samples() - 1 ) * p ) / 100; } int range() { return max() - min(); } int samples() { if( limit_ < 0 ) initialize(); return data.size(); } int area( const int l = 0, int r = -1 ); bool increasing( int i = 1, const int min_delta = 2 ); bool decreasing( int i = 1 ); bool isconcave(); bool isconvex(); bool isflat(); bool isflats(); bool ispit(); bool iscpit( const int cpos = 50 ); bool islpit(); bool istpit(); bool isupit(); bool isvpit(); bool istip(); bool isctip( const int cpos = 50 ); int imaximum(); int iminimum( const int m = 0, int th = -1 ); int minima( int th = -1 ); bool straight( int * const dyp ); }; ocrad-0.22/rational.h0000644000076400001440000001422712111777364013100 0ustar yousers/* Rational - Rational number class with overflow detection. Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This library is free software: you have unlimited permission to copy, distribute and modify it. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ // Rationals are kept normalized at all times. // Invariant = ( gcd( num, den ) == 1 && den > 0 ). // Range extends from INT_MAX to -INT_MAX. // Maximum resolution is 1 / INT_MAX. // In case of domain error or overflow, den is set to 0 and num is set // to >0, <0 or 0, meaning +INF, -INF and NAN respectively. This error // condition can be tested with the 'error' function, and can only be // cleared assigning a new value to the Rational. // While in error state, arithmetic operators become no ops and // relational operators return false, except !=, which returns true. // class Rational { int num, den; void normalize( long long n, long long d ); void normalize(); public: Rational( const int n, const int d ) : num( n ), den( d ) // n / d { normalize(); } explicit Rational( const int n ) : num( n ), den( 1 ) // n / 1 { if( num < -INT_MAX ) { num = -INT_MAX; den = 0; } } Rational() : num( 0 ), den( 1 ) {} // zero Rational & assign( const int n, const int d ) { num = n; den = d; normalize(); return *this; } Rational & operator=( const int n ) { num = n; den = 1; if( num < -INT_MAX ) { num = -INT_MAX; den = 0; } return *this; } int numerator() const { return num; } int denominator() const { return den; } int sign() const { if( num > 0 ) return 1; if( num < 0 ) return -1; return 0; } bool error() const { return ( den <= 0 ); } // true if in error state const Rational & operator+() const { return *this; } // unary plus const Rational & operator+() { return *this; } // unary plus Rational operator-() const // unary minus { Rational tmp( *this ); tmp.num = -tmp.num; return tmp; } Rational abs() const { if( num >= 0 ) return *this; else return -*this; } Rational inverse() const; Rational & operator+=( const Rational & r ); Rational & operator-=( const Rational & r ) { return operator+=( -r ); } Rational & operator*=( const Rational & r ); Rational & operator/=( const Rational & r ) { return operator*=( r.inverse() ); } Rational & operator+=( const int n ) { return operator+=( Rational( n ) ); } Rational & operator-=( const int n ) { return operator-=( Rational( n ) ); } Rational & operator*=( const int n ) { return operator*=( Rational( n ) ); } Rational & operator/=( const int n ) { return operator/=( Rational( n ) ); } Rational operator+( const Rational & r ) const { Rational tmp( *this ); return tmp += r; } Rational operator-( const Rational & r ) const { Rational tmp( *this ); return tmp -= r; } Rational operator*( const Rational & r ) const { Rational tmp( *this ); return tmp *= r; } Rational operator/( const Rational & r ) const { Rational tmp( *this ); return tmp /= r; } Rational operator+( const int n ) const { Rational tmp( *this ); return tmp += n; } Rational operator-( const int n ) const { Rational tmp( *this ); return tmp -= n; } Rational operator*( const int n ) const { Rational tmp( *this ); return tmp *= n; } Rational operator/( const int n ) const { Rational tmp( *this ); return tmp /= n; } Rational & operator++() { return operator+=( 1 ); } // prefix Rational operator++( int ) // suffix { Rational tmp( *this ); operator+=( 1 ); return tmp; } Rational & operator--() { return operator-=( 1 ); } // prefix Rational operator--( int ) // suffix { Rational tmp( *this ); operator-=( 1 ); return tmp; } bool operator==( const Rational & r ) const { return ( den > 0 && num == r.num && den == r.den ); } bool operator==( const int n ) const { return ( num == n && den == 1 ); } bool operator!=( const Rational & r ) const { return ( den <= 0 || r.den <= 0 || num != r.num || den != r.den ); } bool operator!=( const int n ) const { return ( num != n || den != 1 ); } bool operator< ( const Rational & r ) const { return ( den > 0 && r.den > 0 && (long long)num * r.den < (long long)r.num * den ); } bool operator<=( const Rational & r ) const { return ( *this < r || *this == r ); } bool operator> ( const Rational & r ) const { return ( den > 0 && r.den > 0 && (long long)num * r.den > (long long)r.num * den ); } bool operator>=( const Rational & r ) const { return ( *this > r || *this == r ); } bool operator< ( const int n ) const { return operator< ( Rational( n ) ); } bool operator<=( const int n ) const { return operator<=( Rational( n ) ); } bool operator> ( const int n ) const { return operator> ( Rational( n ) ); } bool operator>=( const int n ) const { return operator>=( Rational( n ) ); } int round() const; // nearest integer; -1.5 ==> -2, 1.5 ==> 2 int trunc() const // integer part; -x.y ==> -x, x.y ==> x { if( den > 0 ) return ( num / den ); else return num; } int parse( const char * const s ); // returns parsed size const std::string to_decimal( const unsigned iwidth = 1, int prec = -2 ) const; const std::string to_fraction( const unsigned width = 1 ) const; }; inline Rational operator+( const int n, const Rational & r ) { return r + n; } inline Rational operator-( const int n, const Rational & r ) { return -r + n; } inline Rational operator*( const int n, const Rational & r ) { return r * n; } inline Rational operator/( const int n, const Rational & r ) { return Rational( n ) / r; } inline bool operator==( const int n, const Rational & r ) { return r == n; } inline bool operator!=( const int n, const Rational & r ) { return r != n; } inline bool operator< ( const int n, const Rational & r ) { return r > n; } inline bool operator<=( const int n, const Rational & r ) { return r >= n; } inline bool operator> ( const int n, const Rational & r ) { return r < n; } inline bool operator>=( const int n, const Rational & r ) { return r <= n; } ocrad-0.22/rectangle.h0000644000076400001440000000653412123636414013226 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Rectangle { int left_, top_, right_, bottom_; public: Rectangle( const int l, const int t, const int r, const int b ); void left ( const int l ); void top ( const int t ); void right ( const int r ); void bottom( const int b ); void height( const int h ); void width ( const int w ); void add_point( const int row, const int col ); void add_rectangle( const Rectangle & re ); void enlarge( const int scale ); void move( const int row, const int col ); int left() const { return left_; } int top() const { return top_; } int right() const { return right_; } int bottom() const { return bottom_; } int height() const { return bottom_ - top_ + 1; } int width() const { return right_ - left_ + 1; } int size() const { return height() * width(); } int hcenter() const { return ( left_ + right_ ) / 2; } int vcenter() const { return ( top_ + bottom_ ) / 2; } int hpos( const int p ) const { return left_ + ( ( ( right_ - left_ ) * p ) / 100 ); } int vpos( const int p ) const { return top_ + ( ( ( bottom_ - top_ ) * p ) / 100 ); } bool operator==( const Rectangle & re ) const { return ( left_ == re.left_ && top_ == re.top_ && right_ == re.right_ && bottom_ == re.bottom_ ); } bool operator!=( const Rectangle & re ) const { return !( *this == re ); } bool includes( const Rectangle & re ) const; bool includes( const int row, const int col ) const; bool strictly_includes( const Rectangle & re ) const; bool strictly_includes( const int row, const int col ) const; bool includes_hcenter( const Rectangle & re ) const; bool includes_vcenter( const Rectangle & re ) const; bool h_includes( const Rectangle & re ) const; bool h_includes( const int col ) const; bool v_includes( const Rectangle & re ) const; bool v_includes( const int row ) const; bool h_overlaps( const Rectangle & re ) const; bool v_overlaps( const Rectangle & re ) const; int v_overlap_percent( const Rectangle & re ) const; bool is_hcentred_in( const Rectangle & re ) const; bool is_vcentred_in( const Rectangle & re ) const; bool precedes( const Rectangle & re ) const; bool h_precedes( const Rectangle & re ) const; bool v_precedes( const Rectangle & re ) const; int distance( const Rectangle & re ) const; int distance( const int row, const int col ) const; int h_distance( const Rectangle & re ) const; int h_distance( const int col ) const; int v_distance( const Rectangle & re ) const; int v_distance( const int row ) const; static int hypoti( const int c1, const int c2 ); }; ocrad-0.22/segment.h0000644000076400001440000000302412147751414012717 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ struct Csegment // cartesian (one-dimensional) segment { int left, right; // l > r means no segment // in vertical segments, left is top explicit Csegment( const int l = 1, const int r = 0 ) : left( l ), right( r ) {} void add_point( const int col ); void add_csegment( const Csegment & seg ); bool valid() const { return ( left <= right ); } int size() const { return ( left <= right ) ? right - left + 1 : 0; } bool includes( const Csegment & seg ) const { return ( seg.valid() && left <= seg.left && seg.right <= right ); } bool includes( const int col ) const { return ( left <= col && col <= right ); } int distance( const Csegment & seg ) const; int distance( const int col ) const; }; ocrad-0.22/textblock.h0000644000076400001440000000313012161621522013242 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Textblock : public Rectangle { mutable std::vector< Textline * > tlpv; Textblock( const Textblock & ); // declared as private void operator=( const Textblock & ); // declared as private public: Textblock( const Rectangle & page, const Rectangle & block, std::vector< Blob * > & blobp_vector ); ~Textblock(); void recognize( const Charset & charset, const Filter & filter ); const Textline & textline( const int i ) const; int textlines() const { return tlpv.size(); } int characters() const; void print( const Control & control ) const; void dprint( const Control & control, bool graph, bool recursive ) const; void xprint( const Control & control ) const; void cmark( Page_image & page_image ) const; void lmark( Page_image & page_image ) const; }; ocrad-0.22/textline.h0000644000076400001440000000443012134344073013106 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Page_image; class Rational; class Textline : public Track { int big_initials_; mutable std::vector< Character * > cpv; void check_lower_ambiguous(); public: Textline() : big_initials_( 0 ) {} Textline( const Textline & tl ); Textline & operator=( const Textline & tl ); ~Textline(); void set_track(); void verify_big_initials(); int big_initials() const { return big_initials_; } Character & character( const int i ) const; Character * character_at( const int col ) const; int characters() const { return cpv.size(); } Rectangle charbox( const Character & c ) const; int width() const { return cpv.size() ? cpv.back()->right() - cpv.front()->left() : 0; } void delete_character( const int i ); int shift_characterp( Character * const p, const bool big = false ); bool insert_space( const int i, const bool tab = false ); void insert_spaces(); void join( Textline & tl ); int mean_height() const; Rational mean_width() const; Rational mean_gap_width( const int first = 0, int last = -1 ) const; int mean_hcenter() const; int mean_vcenter() const; void print( const Control & control ) const; void dprint( const Control & control, const bool graph, const bool recursive ) const; void xprint( const Control & control ) const; void cmark( Page_image & page_image ) const; void recognize1( const Charset & charset ) const; void recognize2( const Charset & charset ); void apply_filter( const Filter & filter ); }; ocrad-0.22/textpage.h0000644000076400001440000000266612161621522013101 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Textblock; class Textpage : public Rectangle { const std::string name; std::vector< Textblock * > tbpv; Textpage( const Textpage & ); // declared as private void operator=( const Textpage & ); // declared as private public: Textpage( const Page_image & page_image, const char * const filename, const Control & control, const bool layout ); ~Textpage(); const Textblock & textblock( const int i ) const; int textblocks() const { return tbpv.size(); } int textlines() const; int characters() const; void print( const Control & control ) const; void xprint( const Control & control ) const; }; ocrad-0.22/track.h0000644000076400001440000000523512123636414012363 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ class Vrhomboid // Rhomboid with two vertical sides. { int left_, lvcenter_, right_, rvcenter_, height_; public: Vrhomboid( const int l, const int lc, const int r, const int rc, const int h ); int left() const { return left_; } int lvcenter() const { return lvcenter_; } int right() const { return right_; } int rvcenter() const { return rvcenter_; } int height() const { return height_; } int width() const { return right_ - left_ + 1; } int size() const { return height_ * width(); } void left( const int l ); void lvcenter( const int lc ) { lvcenter_ = lc; } void right( const int r ); void rvcenter( const int rc ) { rvcenter_ = rc; } void height( const int h ); void extend_left( const int l ); void extend_right( const int r ); int bottom( const int col ) const { return vcenter( col ) + ( height_ / 2 ); } int top( const int col ) const { return bottom( col ) - height_ + 1; } int vcenter( const int col ) const; bool includes( const Rectangle & r ) const; bool includes( const int row, const int col ) const; }; class Track // vector of Vrhomboids tracking a Textline. { std::vector< Vrhomboid > data; public: Track() {} Track( const Track & t ) : data( t.data ) {} Track & operator=( const Track & t ) { if( this != &t ) { data = t.data; } return *this; } void set_track( const std::vector< Rectangle > & rectangle_vector ); int segments() const { return data.size(); } int height() const { return data.size() ? data[0].height() : 0; } int left() const { return data.size() ? data[0].left() : 0; } int right() const { return data.size() ? data.back().right() : 0; } int bottom( const int col ) const; int top( const int col ) const; int vcenter( const int col ) const; bool includes( const Rectangle & r ) const; bool includes( const int row, const int col ) const; }; ocrad-0.22/ucs.h0000644000076400001440000001452212147130655012052 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ namespace UCS { enum { IEXCLAM = 0x00A1, // inverted exclamation mark COPY = 0x00A9, // copyright sign FEMIORD = 0x00AA, // feminine ordinal indicator LDANGLE = 0x00AB, // left-pointing double angle quotation mark NOT = 0x00AC, // not sign REG = 0x00AE, // registered sign DEG = 0x00B0, // degree sign PLUSMIN = 0x00B1, // plus-minus sign POW2 = 0x00B2, // superscript two POW3 = 0x00B3, // superscript three MICRO = 0x00B5, // micro sign PILCROW = 0x00B6, // pilcrow sign MIDDOT = 0x00B7, // middle dot POW1 = 0x00B9, // superscript one MASCORD = 0x00BA, // masculine ordinal indicator RDANGLE = 0x00BB, // right-pointing double angle quotation mark IQUEST = 0x00BF, // inverted question mark CAGRAVE = 0x00C0, // latin capital letter a with grave CAACUTE = 0x00C1, // latin capital letter a with acute CACIRCU = 0x00C2, // latin capital letter a with circumflex CATILDE = 0x00C3, // latin capital letter a with tilde CADIAER = 0x00C4, // latin capital letter a with diaeresis CARING = 0x00C5, // latin capital letter a with ring above CCCEDI = 0x00C7, // latin capital letter c with cedilla CEGRAVE = 0x00C8, // latin capital letter e with grave CEACUTE = 0x00C9, // latin capital letter e with acute CECIRCU = 0x00CA, // latin capital letter e with circumflex CEDIAER = 0x00CB, // latin capital letter e with diaeresis CIGRAVE = 0x00CC, // latin capital letter i with grave CIACUTE = 0x00CD, // latin capital letter i with acute CICIRCU = 0x00CE, // latin capital letter i with circumflex CIDIAER = 0x00CF, // latin capital letter i with diaeresis CNTILDE = 0x00D1, // latin capital letter n with tilde COGRAVE = 0x00D2, // latin capital letter o with grave COACUTE = 0x00D3, // latin capital letter o with acute COCIRCU = 0x00D4, // latin capital letter o with circumflex COTILDE = 0x00D5, // latin capital letter o with tilde CODIAER = 0x00D6, // latin capital letter o with diaeresis CUGRAVE = 0x00D9, // latin capital letter u with grave CUACUTE = 0x00DA, // latin capital letter u with acute CUCIRCU = 0x00DB, // latin capital letter u with circumflex CUDIAER = 0x00DC, // latin capital letter u with diaeresis CYACUTE = 0x00DD, // latin capital letter y with acute SSSHARP = 0x00DF, // latin small letter sharp s (german) SAGRAVE = 0x00E0, // latin small letter a with grave SAACUTE = 0x00E1, // latin small letter a with acute SACIRCU = 0x00E2, // latin small letter a with circumflex SATILDE = 0x00E3, // latin small letter a with tilde SADIAER = 0x00E4, // latin small letter a with diaeresis SARING = 0x00E5, // latin small letter a with ring above SCCEDI = 0x00E7, // latin small letter c with cedilla SEGRAVE = 0x00E8, // latin small letter e with grave SEACUTE = 0x00E9, // latin small letter e with acute SECIRCU = 0x00EA, // latin small letter e with circumflex SEDIAER = 0x00EB, // latin small letter e with diaeresis SIGRAVE = 0x00EC, // latin small letter i with grave SIACUTE = 0x00ED, // latin small letter i with acute SICIRCU = 0x00EE, // latin small letter i with circumflex SIDIAER = 0x00EF, // latin small letter i with diaeresis SNTILDE = 0x00F1, // latin small letter n with tilde SOGRAVE = 0x00F2, // latin small letter o with grave SOACUTE = 0x00F3, // latin small letter o with acute SOCIRCU = 0x00F4, // latin small letter o with circumflex SOTILDE = 0x00F5, // latin small letter o with tilde SODIAER = 0x00F6, // latin small letter o with diaeresis DIV = 0x00F7, // division sign SUGRAVE = 0x00F9, // latin small letter u with grave SUACUTE = 0x00FA, // latin small letter u with acute SUCIRCU = 0x00FB, // latin small letter u with circumflex SUDIAER = 0x00FC, // latin small letter u with diaeresis SYACUTE = 0x00FD, // latin small letter y with acute SYDIAER = 0x00FF, // latin small letter y with diaeresis CGBREVE = 0X011E, // latin capital letter g with breve SGBREVE = 0x011F, // latin small letter g with breve CIDOT = 0x0130, // latin capital letter i with dot above SINODOT = 0x0131, // latin small letter i dotless CSCEDI = 0x015E, // latin capital letter s with cedilla SSCEDI = 0x015F, // latin small letter s with cedilla CSCARON = 0x0160, // latin capital letter s with caron SSCARON = 0x0161, // latin small letter s with caron CZCARON = 0x017D, // latin capital letter z with caron SZCARON = 0x017E, // latin small letter z with caron EURO = 0x20AC // symbole euro }; int base_letter( const int code ); int compose( const int letter, const int accent ); bool isalnum( const int code ); bool isalpha( const int code ); bool isdigit( const int code ); bool ishigh( const int code ); // high chars like "A1bp|" bool islower( const int code ); bool islower_ambiguous( const int code ); bool islower_small( const int code ); bool islower_small_ambiguous( const int code ); bool isspace( const int code ); bool isupper( const int code ); bool isvowel( int code ); unsigned char map_to_byte( const int code ); const char * ucs_to_utf8( const int code ); int to_nearest_digit( const int code ); int to_nearest_letter( const int code ); int toupper( const int code ); } // end namespace UCS ocrad-0.22/arg_parser.cc0000644000076400001440000001441412110527212013530 0ustar yousers/* Arg_parser - POSIX/GNU command line argument parser. (C++ version) Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this library. If not, see . As a special exception, you may use this file as part of a free software library without restriction. Specifically, if other files instantiate templates or use macros or inline functions from this file, or you compile this file and link it with other files to produce an executable, this file does not by itself cause the resulting executable to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the executable file might be covered by the GNU General Public License. */ #include #include #include #include "arg_parser.h" bool Arg_parser::parse_long_option( const char * const opt, const char * const arg, const Option options[], int & argind ) { unsigned len; int index = -1; bool exact = false, ambig = false; for( len = 0; opt[len+2] && opt[len+2] != '='; ++len ) ; // Test all long options for either exact match or abbreviated matches. for( int i = 0; options[i].code != 0; ++i ) if( options[i].name && std::strncmp( options[i].name, &opt[2], len ) == 0 ) { if( std::strlen( options[i].name ) == len ) // Exact match found { index = i; exact = true; break; } else if( index < 0 ) index = i; // First nonexact match found else if( options[index].code != options[i].code || options[index].has_arg != options[i].has_arg ) ambig = true; // Second or later nonexact match found } if( ambig && !exact ) { error_ = "option '"; error_ += opt; error_ += "' is ambiguous"; return false; } if( index < 0 ) // nothing found { error_ = "unrecognized option '"; error_ += opt; error_ += '\''; return false; } ++argind; data.push_back( Record( options[index].code ) ); if( opt[len+2] ) // '--=' syntax { if( options[index].has_arg == no ) { error_ = "option '--"; error_ += options[index].name; error_ += "' doesn't allow an argument"; return false; } if( options[index].has_arg == yes && !opt[len+3] ) { error_ = "option '--"; error_ += options[index].name; error_ += "' requires an argument"; return false; } data.back().argument = &opt[len+3]; return true; } if( options[index].has_arg == yes ) { if( !arg || !arg[0] ) { error_ = "option '--"; error_ += options[index].name; error_ += "' requires an argument"; return false; } ++argind; data.back().argument = arg; return true; } return true; } bool Arg_parser::parse_short_option( const char * const opt, const char * const arg, const Option options[], int & argind ) { int cind = 1; // character index in opt while( cind > 0 ) { int index = -1; const unsigned char c = opt[cind]; if( c != 0 ) for( int i = 0; options[i].code; ++i ) if( c == options[i].code ) { index = i; break; } if( index < 0 ) { error_ = "invalid option -- "; error_ += c; return false; } data.push_back( Record( c ) ); if( opt[++cind] == 0 ) { ++argind; cind = 0; } // opt finished if( options[index].has_arg != no && cind > 0 && opt[cind] ) { data.back().argument = &opt[cind]; ++argind; cind = 0; } else if( options[index].has_arg == yes ) { if( !arg || !arg[0] ) { error_ = "option requires an argument -- "; error_ += c; return false; } data.back().argument = arg; ++argind; cind = 0; } } return true; } Arg_parser::Arg_parser( const int argc, const char * const argv[], const Option options[], const bool in_order ) { if( argc < 2 || !argv || !options ) return; std::vector< std::string > non_options; // skipped non-options int argind = 1; // index in argv while( argind < argc ) { const unsigned char ch1 = argv[argind][0]; const unsigned char ch2 = ( ch1 ? argv[argind][1] : 0 ); if( ch1 == '-' && ch2 ) // we found an option { const char * const opt = argv[argind]; const char * const arg = (argind + 1 < argc) ? argv[argind+1] : 0; if( ch2 == '-' ) { if( !argv[argind][2] ) { ++argind; break; } // we found "--" else if( !parse_long_option( opt, arg, options, argind ) ) break; } else if( !parse_short_option( opt, arg, options, argind ) ) break; } else { if( !in_order ) non_options.push_back( argv[argind++] ); else { data.push_back( Record() ); data.back().argument = argv[argind++]; } } } if( error_.size() ) data.clear(); else { for( unsigned i = 0; i < non_options.size(); ++i ) { data.push_back( Record() ); data.back().argument.swap( non_options[i] ); } while( argind < argc ) { data.push_back( Record() ); data.back().argument = argv[argind++]; } } } Arg_parser::Arg_parser( const char * const opt, const char * const arg, const Option options[] ) { if( !opt || !opt[0] || !options ) return; if( opt[0] == '-' && opt[1] ) // we found an option { int argind = 1; // dummy if( opt[1] == '-' ) { if( opt[2] ) parse_long_option( opt, arg, options, argind ); } else parse_short_option( opt, arg, options, argind ); if( error_.size() ) data.clear(); } else { data.push_back( Record() ); data.back().argument = opt; } } ocrad-0.22/bitmap.cc0000644000076400001440000003164212123651140012663 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include "common.h" #include "rectangle.h" #include "bitmap.h" // Creates a blank Bitmap Bitmap::Bitmap( const int l, const int t, const int r, const int b ) : Rectangle( l, t, r, b ), data( height() ) { for( int row = 0; row < height(); ++row ) data[row].resize( width(), false ); } // Creates a Bitmap from part of another Bitmap Bitmap::Bitmap( const Bitmap & source, const Rectangle & re ) : Rectangle( re ), data( re.height() ) { if( !source.includes( re ) ) Ocrad::internal_error( "bad parameter building a Bitmap from part of another one" ); const int ldiff = left()-source.left(); const int tdiff = top()-source.top(); for( int row = 0; row < height(); ++row ) { data[row].resize( width() ); std::vector< uint8_t > & datarow = data[row]; const std::vector< uint8_t > & datarow2 = source.data[row+tdiff]; for( int col = 0; col < width(); ++col ) datarow[col] = datarow2[col+ldiff]; } } void Bitmap::left( const int l ) { if( l == left() ) return; if( l < left() ) for( int row = height() - 1; row >= 0 ; --row ) data[row].insert( data[row].begin(), left() - l, false ); else for( int row = height() - 1; row >= 0 ; --row ) data[row].erase( data[row].begin(), data[row].begin() + ( l - left() ) ); Rectangle::left( l ); } void Bitmap::top( const int t ) { if( t == top() ) return; if( t < top() ) data.insert( data.begin(), top() - t, std::vector< uint8_t >( width(), false ) ); else data.erase( data.begin(), data.begin() + ( t - top() ) ); Rectangle::top( t ); } void Bitmap::right( const int r ) { if( r == right() ) return; Rectangle::right( r ); for( int row = height() - 1; row >= 0 ; --row ) data[row].resize( width(), false ); } void Bitmap::bottom( const int b ) { if( b == bottom() ) return; int old_height = height(); Rectangle::bottom( b ); data.resize( height() ); for( int row = old_height; row < height(); ++row ) data[row].resize( width(), false ); } void Bitmap::add_bitmap( const Bitmap & bm ) { add_rectangle( bm ); for( int row = bm.top(); row <= bm.bottom(); ++row ) for( int col = bm.left(); col <= bm.right(); ++col ) if( bm.get_bit( row, col ) ) set_bit( row, col, true ); } void Bitmap::add_point( const int row, const int col ) { if( col > right() ) right( col ); else if( col < left() ) left( col ); if( row > bottom() ) bottom( row ); else if( row < top() ) top( row ); set_bit( row, col, true ); } void Bitmap::add_rectangle( const Rectangle & re ) { if( re.left() < left() ) left( re.left() ); if( re.top() < top() ) top( re.top() ); if( re.right() > right() ) right( re.right() ); if( re.bottom() > bottom() ) bottom( re.bottom() ); } // Returns false if bitmap is empty // bool Bitmap::adjust_height() { int row1, row2; for( row1 = top(); row1 <= bottom(); ++row1 ) for( int col = left(); col <= right(); ++col ) if( get_bit( row1, col ) ) goto L1; L1: for( row2 = bottom(); row2 >= row1; --row2 ) for( int col = left(); col <= right(); ++col ) if( get_bit( row2, col ) ) goto L2; L2: if( row1 > row2 ) return false; if( row1 > top() ) top( row1 ); if( row2 < bottom() ) bottom( row2 ); return true; } // Returns false if bitmap is empty // bool Bitmap::adjust_width() { int col1, col2; for( col1 = left(); col1 <= right(); ++col1 ) for( int row = top(); row <= bottom(); ++row ) if( get_bit( row , col1 ) ) goto L1; L1: for( col2 = right(); col2 >= col1; --col2 ) for( int row = top(); row <= bottom(); ++row ) if( get_bit( row , col2) ) goto L2; L2: if( col1 >= col2 ) return false; if( col1 > left() ) left( col1 ); if( col2 < right() ) right( col2 ); return true; } // Return the total filled area of this Bitmap // int Bitmap::area() const { int a = 0; for( int row = top(); row <= bottom(); ++row ) for( int col = left(); col <= right(); ++col ) if( get_bit( row, col ) ) ++a; return a; } // Return the central octagon filled area of this Bitmap // int Bitmap::area_octagon() const { int a = 0; int bevel = ( 29 * std::min( height(), width() ) ) / 100; int l = left() + bevel; int r = right() - bevel; for( int i = 0; i < bevel; ++i ) for( int row = top() + i, col = l - i; col <= r + i; ++col ) if( get_bit( row, col ) ) ++a; for( int row = top() + bevel; row <= bottom() - bevel; ++row ) for( int col = left(); col <= right(); ++col ) if( get_bit( row, col ) ) ++a; for( int i = bevel - 1; i >= 0; --i ) for( int row = bottom() - i, col = l - i; col <= r + i; ++col ) if( get_bit( row, col ) ) ++a; return a; } // Return the size of the central octagon of this blob // int Bitmap::size_octagon() const { int bevel = ( 29 * std::min( height(), width() ) ) / 100; return size() - ( 2 * bevel * ( bevel + 1 ) ); } int Bitmap::seek_left( const int row, const int col, const bool black ) const { int c = col; while( c > left() && get_bit( row, c - 1 ) != black ) --c; return c; } int Bitmap::seek_top( const int row, const int col, const bool black ) const { int r = row; while( r > top() && get_bit( r - 1, col ) != black ) --r; return r; } int Bitmap::seek_right( const int row, const int col, const bool black ) const { int c = col; while( c < right() && get_bit( row, c + 1 ) != black ) ++c; return c; } int Bitmap::seek_bottom( const int row, const int col, const bool black ) const { int r = row; while( r < bottom() && get_bit( r + 1, col ) != black ) ++r; return r; } bool Bitmap::escape_left( int row, int col ) const { if( get_bit( row, col ) ) return false; int u, d; for( u = row; u > top() + 1; --u ) if( get_bit( u - 1, col ) ) break; for( d = row; d < bottom() - 1; ++d ) if( get_bit( d + 1, col ) ) break; while( u <= d && --col >= left() ) { if( u > top() + 1 && !get_bit( u, col ) ) --u; if( d < bottom() - 1 && !get_bit( d, col ) ) ++d; while( u <= d && get_bit( u, col ) ) ++u; while( u <= d && get_bit( d, col ) ) --d; } return ( col < left() ); } bool Bitmap::escape_top( int row, int col ) const { if( get_bit( row, col ) ) return false; int l, r; for( l = col; l > left() + 1; --l ) if( get_bit( row, l - 1 ) ) break; for( r = col; r < right() - 1; ++r ) if( get_bit( row, r + 1 ) ) break; while( l <= r && --row >= top() ) { if( l > left() + 1 && !get_bit( row, l ) ) --l; if( r < right() - 1 && !get_bit( row, r ) ) ++r; while( l <= r && get_bit( row, l ) ) ++l; while( l <= r && get_bit( row, r ) ) --r; } return ( row < top() ); } bool Bitmap::escape_right( int row, int col ) const { if( get_bit( row, col ) ) return false; int u, d; for( u = row; u > top() + 1; --u ) if( get_bit( u - 1, col ) ) break; for( d = row; d < bottom() - 1; ++d ) if( get_bit( d + 1, col ) ) break; while( u <= d && ++col <= right() ) { if( u > top() + 1 && !get_bit( u, col ) ) --u; if( d < bottom() - 1 && !get_bit( d, col ) ) ++d; while( u <= d && get_bit( u, col ) ) ++u; while( u <= d && get_bit( d, col ) ) --d; } return ( col > right() ); } bool Bitmap::escape_bottom( int row, int col ) const { if( get_bit( row, col ) ) return false; int l, r; for( l = col; l > left() + 1; --l ) if( get_bit( row, l - 1 ) ) break; for( r = col; r < right() - 1; ++r ) if( get_bit( row, r + 1 ) ) break; while( l <= r && ++row <= bottom() ) { if( l > left() + 1 && !get_bit( row, l ) ) --l; if( r < right() - 1 && !get_bit( row, r ) ) ++r; while( l <= r && get_bit( row, l ) ) ++l; while( l <= r && get_bit( row, r ) ) --r; } return ( row > bottom() ); } int Bitmap::follow_top( int row, int col ) const { if( !get_bit( row, col ) ) return row; std::vector< uint8_t > array; array.reserve( width() ); int c; for( c = col; c > left() && get_bit( row, c - 1 ); --c ) ; if( c > left() ) array.resize( c - left(), false ); for( c = col; c < right() && get_bit( row, c + 1 ); ++c ) ; array.resize( c - left() + 1, true ); if( c < right() ) array.resize( width(), false ); while( --row >= top() ) { bool alive = false; for( int i = 0; i < width(); ++i ) if( array[i] ) { if( !get_bit( row, left() + i ) ) array[i] = false; else alive = true; } if( !alive ) break; for( int i = 1; i < width(); ++i ) if( array[i-1] && !array[i] && get_bit( row, left() + i ) ) array[i] = true; for( int i = width() - 2; i >= 0; --i ) if( array[i+1] && !array[i] && get_bit( row, left() + i ) ) array[i] = true; } return row + 1; } int Bitmap::follow_bottom( int row, int col ) const { if( !get_bit( row, col ) ) return row; std::vector< uint8_t > array; array.reserve( width() ); int c; for( c = col; c > left() && get_bit( row, c - 1 ); --c ) ; if( c > left() ) array.resize( c - left(), false ); for( c = col; c < right() && get_bit( row, c + 1 ); ++c ) ; array.resize( c - left() + 1, true ); if( c < right() ) array.resize( width(), false ); while( ++row <= bottom() ) { bool alive = false; for( int i = 0; i < width(); ++i ) if( array[i] ) { if( !get_bit( row, left() + i ) ) array[i] = false; else alive = true; } if( !alive ) break; for( int i = 1; i < width(); ++i ) if( array[i-1] && !array[i] && get_bit( row, left() + i ) ) array[i] = true; for( int i = width() - 2; i >= 0; --i ) if( array[i+1] && !array[i] && get_bit( row, left() + i ) ) array[i] = true; } return row - 1; } // Looks for an inverted-U-shaped curve near the top, then tests which of // the vertical bars goes deeper // bool Bitmap::top_hook( int *hdiff ) const { int row, lcol = 0, rcol = 0, black_section = 0, wmax = 0; for( row = top() + 1; row < vcenter(); ++row ) { int l = -1, r = -2; bool prev_black = false; black_section = 0; for( int col = left(); col <= right(); ++col ) { bool black = get_bit( row, col ); if( black ) { if( !prev_black && ++black_section == 2 ) rcol = col; r = col; if( l < 0 ) l = col; } else if( prev_black && black_section == 1 ) lcol = col - 1; prev_black = black; } r = r - l + 1; if( 10 * r <= 9 * wmax ) return false; if( r > wmax ) wmax = r ; if( black_section >= 2 ) break; } if( black_section != 2 ) return false; if( escape_top( row, lcol + 1 ) ) return false; int lrow = follow_bottom( row, lcol ), rrow = follow_bottom( row, rcol ); if( lrow <= row || rrow <= row ) return false; if( hdiff ) *hdiff = lrow - rrow; return true; } // Looks for an U-shaped curve near the bottom, then tests which of // the vertical bars is taller // bool Bitmap::bottom_hook( int *hdiff ) const { int row, lcol = 0, rcol = 0, black_section = 0, wmax = 0; for( row = bottom(); row > vpos( 80 ); --row ) { int l, r; for( l = left(); l <= right(); ++l ) if( get_bit( row, l ) ) break; for( r = right(); r > l; --r ) if( get_bit( row, r ) ) break; const int w = r - l + 1; if( w > wmax ) wmax = w; if( 4 * w >= width() ) { int i; for( i = l + 1; i < r; ++i ) if( !get_bit( row, i ) ) break; if( i >= r ) break; } } if( row > vpos( 80 ) ) while( --row > vcenter() ) { int l = -1, r = -2; bool prev_black = false; black_section = 0; for( int col = left(); col <= right(); ++col ) { bool black = get_bit( row, col ); if( black ) { if( !prev_black && ++black_section == 2 ) rcol = col; r = col; if( l < 0 ) l = col; } else if( prev_black && black_section == 1 ) lcol = col - 1; prev_black = black; } const int w = r - l + 1; if( black_section > 2 || 10 * w <= 8 * wmax ) break; if( w > wmax ) wmax = w; if( black_section == 2 && rcol - lcol >= 2 ) { if( escape_bottom( row, lcol + 1 ) ) break; if( hdiff ) *hdiff = follow_top( row, lcol ) - follow_top( row, rcol ); return true; } } return false; } ocrad-0.22/blob.cc0000644000076400001440000002023512160432342012323 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "bitmap.h" #include "blob.h" namespace { void delete_hole( std::vector< Bitmap * > & holep_vector, std::vector< Bitmap * > & v1, std::vector< Bitmap * > & v2, Bitmap * const p, int i ) { std::replace( v1.begin() + i, v1.end(), p, (Bitmap *) 0 ); std::replace( v2.begin(), v2.begin() + i, p, (Bitmap *) 0 ); i = holep_vector.size(); while( --i >= 0 && holep_vector[i] != p ) ; if( i < 0 ) Ocrad::internal_error( "delete_hole, lost hole." ); holep_vector.erase( holep_vector.begin() + i ); delete p; } inline void join_holes( std::vector< Bitmap * > & holep_vector, std::vector< Bitmap * > & v1, std::vector< Bitmap * > & v2, Bitmap * p1, Bitmap * p2, int i ) { if( p1->top() > p2->top() ) { Bitmap * const temp = p1; p1 = p2; p2 = temp; std::replace( v2.begin(), v2.begin() + ( i + 1 ), p2, p1 ); } else std::replace( v1.begin() + i, v1.end(), p2, p1 ); i = holep_vector.size(); while( --i >= 0 && holep_vector[i] != p2 ) ; if( i < 0 ) Ocrad::internal_error( "join_holes, lost hole" ); holep_vector.erase( holep_vector.begin() + i ); p1->add_bitmap( *p2 ); delete p2; } void delete_outer_holes( const Rectangle & re, std::vector< Bitmap * > & holepv ) { for( int i = holepv.size() - 1; i >= 0; --i ) { Bitmap & h = *holepv[i]; if( !re.strictly_includes( h ) ) { delete &h; holepv.erase( holepv.begin() + i ); } } } } // end namespace Blob::Blob( const Blob & b ) : Bitmap( b ), holepv( b.holepv ) { for( unsigned i = 0; i < holepv.size(); ++i ) holepv[i] = new Bitmap( *b.holepv[i] ); } Blob & Blob::operator=( const Blob & b ) { if( this != &b ) { Bitmap::operator=( b ); for( unsigned i = 0; i < holepv.size(); ++i ) delete holepv[i]; holepv = b.holepv; for( unsigned i = 0; i < holepv.size(); ++i ) holepv[i] = new Bitmap( *b.holepv[i] ); } return *this; } Blob::~Blob() { for( unsigned i = 0; i < holepv.size(); ++i ) delete holepv[i]; } void Blob::left( const int l ) { const int d = l - left(); if( d ) { Bitmap::left( l ); if( d > 0 ) delete_outer_holes( *this, holepv ); } } void Blob::top( const int t ) { const int d = t - top(); if( d ) { Bitmap::top( t ); if( d > 0 ) delete_outer_holes( *this, holepv ); } } void Blob::right( const int r ) { const int d = r - right(); if( d ) { Bitmap::right( r ); if( d < 0 ) delete_outer_holes( *this, holepv ); } } void Blob::bottom( const int b ) { const int d = b - bottom(); if( d ) { Bitmap::bottom( b ); if( d < 0 ) delete_outer_holes( *this, holepv ); } } const Bitmap & Blob::hole( const int i ) const { if( i < 0 || i >= holes() ) Ocrad::internal_error( "hole, index out of bounds" ); return *holepv[i]; } int Blob::id( const int row, const int col ) const { if( this->includes( row, col ) ) { if( get_bit( row, col ) ) return 1; for( int i = 0; i < holes(); ++i ) if( holepv[i]->includes( row, col ) && holepv[i]->get_bit( row, col ) ) return -( i + 1 ); } return 0; } bool Blob::test_BD() const { const int wlimit = std::min( height(), width() ) / 2; int lb = wlimit, rt = wlimit; // index of first dot found for( int i = 0; i < wlimit; ++i ) if( id( bottom() - i, left() + i ) == 1 || id( bottom() - i, left() + i + 1 ) == 1 ) { lb = i; break; } for( int i = 0; i < wlimit; ++i ) if( id( top() + i, right() - i ) == 1 ) { rt = i; break; } return ( rt >= 2 && 3 * lb <= rt ); } bool Blob::test_Q() const { const int wlimit = std::min( height(), width() ) / 2; int ltwmax = 0, rbwmax = 0; int ltimin = wlimit, rbimin = wlimit; // index of first dot found for( int disp = 0; disp < width() / 4; ++disp ) { int ltw = 0, rbw = 0; for( int i = 0; i < wlimit; ++i ) { if( id( top() + i, left() + disp + i ) == 1 ) { ++ltw; if( ltimin > i ) ltimin = i; } if( id( bottom() - i, right() - disp - i ) == 1 ) { ++rbw; if( rbimin > i ) rbimin = i; } } if( ltwmax < ltw ) ltwmax = ltw; if( rbwmax < rbw ) rbwmax = rbw; } return ( ( ltimin > rbimin || rbimin == 0 ) && ( 2 * ltwmax < rbwmax || ( 2 * ltwmax == rbwmax && rbwmax >= 4 ) ) ); } void Blob::print( FILE * const outfile ) const { for( int row = top(); row <= bottom(); ++row ) { for( int col = left(); col <= right(); ++col ) { if( get_bit( row, col ) ) std::fprintf( outfile, " O" ); else std::fprintf( outfile, " ." ); } std::fputs( "\n", outfile ); } std::fputs( "\n", outfile ); } void Blob::fill_hole( const int i ) { if( i < 0 || i >= holes() ) Ocrad::internal_error( "fill_hole, index out of bounds" ); add_bitmap( *holepv[i] ); delete holepv[i]; holepv.erase( holepv.begin() + i ); } void Blob::find_holes() { for( unsigned i = 0; i < holepv.size(); ++i ) delete holepv[i]; holepv.clear(); if( height() < 3 || width() < 3 ) return; std::vector< Bitmap * > old_data( width(), (Bitmap *) 0 ); std::vector< Bitmap * > new_data( width(), (Bitmap *) 0 ); for( int row = top(); row <= bottom(); ++row ) { old_data.swap( new_data ); new_data[0] = get_bit( row, left() ) ? this : 0; for( int col = left() + 1; col < right(); ++col ) { const int dcol = col - left(); if( get_bit( row, col ) ) new_data[dcol] = this; // black pixel else // white pixel { Bitmap *p; Bitmap *lp = new_data[dcol-1]; Bitmap *tp = old_data[dcol]; if( lp == 0 || tp == 0 ) { p = 0; if( lp && lp != this ) delete_hole( holepv, old_data, new_data, lp, dcol ); else if( tp && tp != this ) delete_hole( holepv, old_data, new_data, tp, dcol ); } else if( lp != this ) { p = lp; p->add_point( row, col ); } else if( tp != this ) { p = tp; p->add_point( row, col ); } else { p = new Bitmap( col, row, col, row ); p->set_bit( row, col, true ); holepv.push_back( p ); } new_data[dcol] = p; if( p && lp != tp && lp != this && tp != this ) join_holes( holepv, old_data, new_data, lp, tp, dcol ); } } if( !get_bit( row, right() ) ) { Bitmap *lp = new_data[width()-2]; if( lp && lp != this ) delete_hole( holepv, old_data, new_data, lp, width() - 1 ); } } for( int i = holepv.size() - 1; i >= 0; --i ) // FIXME noise holes removal { Bitmap & h = *holepv[i]; if( this->strictly_includes( h ) && ( h.height() > 4 || h.width() > 4 || ( ( h.height() > 2 || h.width() > 2 ) && h.area() > 3 ) ) ) continue; delete &h; holepv.erase( holepv.begin() + i ); } /* for( int i = holepv.size() - 1; i >= 0; --i ) { Bitmap & h = *holepv[i]; if( !this->strictly_includes( h ) ) { delete &h; holepv.erase( holepv.begin() + i ); } if( 20 * h.height() < height() && 16 * h.width() < width() ) fill_hole( i ); // else if( h.height() < 2 && h.width() < 2 && h.area() < 2 ) // { delete &h; holepv.erase( holepv.begin() + i ); } } */ } ocrad-0.22/character.cc0000644000076400001440000002452712150233277013356 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "character.h" Character::Character( const Character & c ) : Rectangle( c ), blobpv( c.blobpv ), gv( c.gv ) { for( unsigned i = 0; i < blobpv.size(); ++i ) blobpv[i] = new Blob( *c.blobpv[i] ); } Character & Character::operator=( const Character & c ) { if( this != &c ) { Rectangle::operator=( c ); for( unsigned i = 0; i < blobpv.size(); ++i ) delete blobpv[i]; blobpv = c.blobpv; for( unsigned i = 0; i < blobpv.size(); ++i ) blobpv[i] = new Blob( *c.blobpv[i] ); gv = c.gv; } return *this; } Character::~Character() { for( unsigned i = 0; i < blobpv.size(); ++i ) delete blobpv[i]; } // Return the filled area of the main blobs only (no recursive) // int Character::area() const { int a = 0; for( int i = 0; i < blobs(); ++i ) a += blobpv[i]->area(); return a; } const Blob & Character::blob( const int i ) const { if( i < 0 || i >= blobs() ) Ocrad::internal_error( "const blob, index out of bounds" ); return *blobpv[i]; } Blob & Character::blob( const int i ) { if( i < 0 || i >= blobs() ) Ocrad::internal_error( "blob, index out of bounds" ); return *blobpv[i]; } Blob & Character::main_blob() { int imax = 0; for( int i = 1; i < blobs(); ++i ) if( blobpv[i]->size() > blobpv[imax]->size() ) imax = i; return *blobpv[imax]; } void Character::shift_blobp( Blob * const p ) { add_rectangle( *p ); int i = blobs() - 1; for( ; i >= 0; --i ) { Blob & bi = *blobpv[i]; if( p->vcenter() > bi.vcenter() ) break; if( p->vcenter() == bi.vcenter() && p->hcenter() >= bi.hcenter() ) break; } blobpv.insert( blobpv.begin() + ( i + 1 ), p ); } void Character::insert_guess( const int i, const int code, const int value ) { if( i < 0 || i > guesses() ) Ocrad::internal_error( "insert_guess, index out of bounds" ); gv.insert( gv.begin() + i, Guess( code, value ) ); } void Character::delete_guess( const int i ) { if( i < 0 || i >= guesses() ) Ocrad::internal_error( "delete_guess, index out of bounds" ); gv.erase( gv.begin() + i ); } bool Character::set_merged_guess( const int code1, const int right1, const int code2, const int blob_index ) { if( blob_index < 0 || blob_index >= blobs() ) return false; const Blob & b = *blobpv[blob_index]; if( b.left() <= right1 && right1 < b.right() ) { only_guess( -(blob_index + 1), left() ); add_guess( code1, right1 ); add_guess( code2, right() ); return true; } return false; } void Character::swap_guesses( const int i, const int j ) { if( i < 0 || i >= guesses() || j < 0 || j >= guesses() ) Ocrad::internal_error( "swap_guesses, index out of bounds" ); const int code = gv[i].code; gv[i].code = gv[j].code; gv[j].code = code; } const Character::Guess & Character::guess( const int i ) const { if( i < 0 || i >= guesses() ) Ocrad::internal_error( "guess, index out of bounds" ); return gv[i]; } bool Character::maybe( const int code ) const { for( int i = 0; i < guesses(); ++i ) if( code == gv[i].code ) return true; return false; } /* bool Character::maybe_digit() const { for( int i = 0; i < guesses(); ++i ) if( UCS::isdigit( gv[i].code ) ) return true; return false; } bool Character::maybe_letter() const { for( int i = 0; i < guesses(); ++i ) if( UCS::isalpha( gv[i].code ) ) return true; return false; } */ void Character::join( Character & c ) { for( int i = 0; i < c.blobs(); ++i ) shift_blobp( c.blobpv[i] ); c.blobpv.clear(); } unsigned char Character::byte_result() const { if( guesses() ) { const unsigned char ch = UCS::map_to_byte( gv[0].code ); if( ch ) return ch; } return '_'; } const char * Character::utf8_result() const { if( guesses() ) { const char * s = UCS::ucs_to_utf8( gv[0].code ); if( *s ) return s; } return "_"; } void Character::print( const Control & control ) const { if( guesses() ) { if( !control.utf8 ) { unsigned char ch = UCS::map_to_byte( gv[0].code ); if( ch ) std::putc( ch, control.outfile ); } else if( gv[0].code ) std::fputs( UCS::ucs_to_utf8( gv[0].code ), control.outfile ); } else std::putc( '_', control.outfile ); } void Character::dprint( const Control & control, const Rectangle & charbox, const bool graph, const bool recursive ) const { if( graph || recursive ) std::fprintf( control.outfile, "%d guesses ", guesses() ); for( int i = 0; i < guesses(); ++i ) { if( !control.utf8 ) { unsigned char ch = UCS::map_to_byte( gv[i].code ); if( ch ) std::fprintf( control.outfile, "guess '%c', confidence %d ", ch, gv[i].value ); } else std::fprintf( control.outfile, "guess '%s', confidence %d ", UCS::ucs_to_utf8( gv[i].code ), gv[i].value ); if( !graph && !recursive ) break; } std::fputs( "\n", control.outfile ); if( graph ) { std::fprintf( control.outfile, "left = %d, top = %d, right = %d, bottom = %d\n", left(), top(), right(), bottom() ); std::fprintf( control.outfile, "width = %d, height = %d, hcenter = %d, vcenter = %d, black area = %d%%\n\n", width(), height(), hcenter(), vcenter(), ( area() * 100 ) / size() ); const int minrow = std::min( top(), charbox.top() ); const int maxrow = std::max( bottom(), charbox.bottom() ); for( int row = minrow; row <= maxrow; ++row ) { bool istop = ( row == top() ); bool isvc = ( row == vcenter() ); bool isbot = ( row == bottom() ); bool iscbtop = ( row == charbox.top() ); bool iscbvc = ( row == charbox.vcenter() ); bool iscbbot = ( row == charbox.bottom() ); bool ish1top = false, ish1bot = false, ish2top = false, ish2bot = false; if( blobs() == 1 && blobpv[0]->holes() ) { const Blob & b = *blobpv[0]; ish1top = ( row == b.hole(0).top() ); ish1bot = ( row == b.hole(0).bottom() ); if( b.holes() > 1 ) { ish2top = ( row == b.hole(1).top() ); ish2bot = ( row == b.hole(1).bottom() ); } } for( int col = left(); col <= right(); ++col ) { char ch = ( isvc && col == hcenter() ) ? '+' : '.'; for( int i = 0; i < blobs(); ++i ) { int id = blobpv[i]->id( row, col ); if( id != 0 ) { if( id > 0 ) ch = (ch == '+') ? 'C' : 'O'; else ch = (ch == '+') ? '=' : '-'; break; } } std::fprintf( control.outfile, " %c", ch ); } if( istop ) std::fprintf( control.outfile, " top(%d)", row ); if( isvc ) std::fprintf( control.outfile, " vcenter(%d)", row ); if( isbot ) std::fprintf( control.outfile, " bottom(%d)", row ); if( iscbtop ) std::fprintf( control.outfile, " box.top(%d)", row ); if( iscbvc ) std::fprintf( control.outfile, " box.vcenter(%d)", row ); if( iscbbot ) std::fprintf( control.outfile, " box.bottom(%d)", row ); if( ish1top ) std::fprintf( control.outfile, " h1.top(%d)", row ); if( ish1bot ) std::fprintf( control.outfile, " h1.bottom(%d)", row ); if( ish2top ) std::fprintf( control.outfile, " h2.top(%d)", row ); if( ish2bot ) std::fprintf( control.outfile, " h2.bottom(%d)", row ); std::fputs( "\n", control.outfile ); } std::fputs( "\n\n", control.outfile ); } } void Character::xprint( const Control & control ) const { std::fprintf( control.exportfile, "%3d %3d %2d %2d; %d", left(), top(), width(), height(), guesses() ); for( int i = 0; i < guesses(); ++i ) if( !control.utf8 ) { unsigned char ch = UCS::map_to_byte( gv[i].code ); if( !ch ) ch = '_'; std::fprintf( control.exportfile, ", '%c'%d", ch, gv[i].value ); } else std::fprintf( control.exportfile, ", '%s'%d", UCS::ucs_to_utf8( gv[i].code ), gv[i].value ); std::fputs( "\n", control.exportfile ); } void Character::apply_filter( const Filter & filter ) { if( filter.type() == Filter::none ) return; const int code = guesses() ? gv[0].code : 0; bool remove = false; switch( filter.type() ) { case Filter::none: // only for completeness break; case Filter::letters_only: remove = true; case Filter::letters: if( !UCS::isalpha( code ) && !UCS::isspace( code ) ) { for( int i = 1; i < guesses(); ++i ) if( UCS::isalpha( gv[i].code ) ) { swap_guesses( 0, i ); break; } if( guesses() && !UCS::isalpha( gv[0].code ) ) gv[0].code = UCS::to_nearest_letter( gv[0].code ); if( remove && ( !guesses() || !UCS::isalpha( gv[0].code ) ) ) only_guess( 0, 0 ); } break; case Filter::numbers_only: remove = true; case Filter::numbers: if( !UCS::isdigit( code ) && !UCS::isspace( code ) ) { for( int i = 1; i < guesses(); ++i ) if( UCS::isdigit( gv[i].code ) ) { swap_guesses( 0, i ); break; } if( guesses() && !UCS::isdigit( gv[0].code ) ) gv[0].code = UCS::to_nearest_digit( gv[0].code ); if( remove && ( !guesses() || !UCS::isdigit( gv[0].code ) ) ) only_guess( 0, 0 ); } break; } } ocrad-0.22/character_r11.cc0000644000076400001440000003462512160710705014036 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "segment.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "profile.h" #include "feats.h" // First attempt at recognition without relying on context. // void Character::recognize1( const Charset & charset, const Rectangle & charbox ) { if( blobs() == 1 ) recognize11( charset, charbox ); else if( blobs() == 2 ) recognize12( charset, charbox ); else if( blobs() == 3 ) recognize13( charset, charbox ); } // Recognizes 1 blob characters. // 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghklmnopqrstuvwxyz // #$&'()*+,-./<>@[\]^_`{|}~¬ // void Character::recognize11( const Charset & charset, const Rectangle & charbox ) { const Blob & b = blob( 0 ); if( b.holes() == 0 ) recognize110( charset, charbox ); else if( b.holes() == 1 ) recognize111( charset, charbox ); else if( b.holes() == 2 ) recognize112( charbox ); } // Recognizes 1 blob characters without holes. // 12357CEFGHIJKLMNSTUVWXYZcfhklmnrstuvwxyz // '()*+,-./<>@[\]^_`{|}~¬ // void Character::recognize110( const Charset & charset, const Rectangle & charbox ) { const Blob & b = blob( 0 ); Features f( b ); int code = f.test_easy( charbox ); if( code ) { if( code == '.' && b.width() > b.height() && b.v_includes( charbox.vcenter() ) ) { add_guess( code, 1 ); add_guess( '-', 0 ); return; } add_guess( code, 0 ); return; } if( b.height() < 5 || ( b.height() < 8 && b.width() < 6 ) || b.height() > 10 * b.width() || 5 * b.height() < b.width() ) return; code = f.test_CEFIJLlT( charset ); if( code ) { add_guess( code, 0 ); return; } code = f.test_frst( charbox ); if( code ) { add_guess( code, 0 ); return; } code = f.test_G(); if( code ) { add_guess( code, 0 ); return; } code = f.test_c(); if( code ) { add_guess( code, 0 ); return; } if( charset.enabled( Charset::iso_8859_9 ) ) { code = f.test_s_cedilla(); if( code ) { add_guess( code, 0 ); return; } } code = f.test_235Esz( charset ); if( code ) { add_guess( code, 0 ); return; } code = f.test_HKMNUuvwYy( charbox ); if( code == 'u' && f.lp.istpit() ) // Looks for merged 'tr' { int col = b.seek_left( b.vcenter(), b.right() ); if( col < b.hpos( 90 ) && !b.escape_top( b.vcenter(), col ) ) { col = b.seek_left( b.vcenter(), col - 1, false ); while( --col > b.hpos( 40 ) && ( b.seek_top( b.vcenter(), col ) > b.top() || f.hp[col-b.left()] > b.height() / 10 ) ) ; if( col > b.hpos( 40 ) && col < b.right() && set_merged_guess( 't', col, 'r', 0 ) ) return; } } if( code == 'N' && b.width() > b.height() && b.top() >= charbox.top() && 4 * f.tp[f.tp.pos(50)] < b.height() ) { // Looks for merged 'rv' const int col = f.hp.iminimum(); if( col >= f.hp.pos( 40 ) && col < f.hp.pos( 50 ) && set_merged_guess( 'r', b.left() + col, 'v', 0 ) ) return; } if( code ) { add_guess( code, 0 ); return; } const int noise = ( std::min( b.height(), b.width() ) / 30 ) + 1; if( f.bp.minima() <= 2 && ( f.bp.minima( b.height() / 8 + noise ) == 2 || ( b.height() >= 16 && f.bp.minima( b.height() / 8 ) == 2 ) ) ) { code = f.test_hknwx( charbox ); if( code == 'n' ) // Looks for '"' or merged 'rt' or 'fl' { if( b.bottom() <= charbox.vcenter() ) { add_guess( '"', 0 ); return; } if( b.width() > b.height() && 10 * f.lp[f.lp.pos(10)] < b.width() && !f.rp.increasing( f.rp.pos( 75 ) ) ) { const int rgap = f.rp[f.rp.pos(50)]; if( 10 * rgap > b.width() && !b.escape_top( b.vcenter(), b.right() ) ) return; // leave 'rr', 'TT', 'rz', 'FT' etc, for next pass } if( 2 * f.lp[f.lp.pos(10)] > b.width() && !f.rp.increasing( f.rp.pos( 75 ) ) ) { const int col = b.seek_left( b.vcenter(), b.right() ); if( col <= b.hpos( 95 ) && !b.escape_top( b.vcenter(), col ) && set_merged_guess( 'r', b.hcenter(), 't', 0 ) ) return; } if( f.rp.minima() == 1 && !f.rp.increasing( f.rp.pos( 75 ) ) ) { int dmax = 0; bool bar = false; for( int row = b.vpos( 60 ); row > b.vpos( 25 ); --row ) { int d = b.hcenter() - b.seek_left( row, b.hcenter() ); if( d > dmax ) dmax = d; else if( 2 * d < dmax && dmax > 2 ) bar = true; if( bar && Ocrad::similar( d, dmax, 25 ) ) { int col, limit = b.seek_right( b.vcenter(), b.hcenter() ); for( col = b.hcenter(); col <= limit; ++col ) if( b.seek_bottom( b.vcenter(), col ) < b.bottom() ) break; if( col > b.left() && col < b.right() && set_merged_guess( 'f', col - 1, 'l', 0 ) ) return; } } } } else if( code == 'h' ) // Looks for merged 'rf' or 'fi' { if( 2 * f.lp[f.lp.pos(10)] > b.width() ) { if( f.rp[f.rp.pos(70)] >= 2 && b.seek_top( b.vpos( 70 ), b.right() ) > b.top() ) { int col = 0, hmin = f.hp.range() + 1; for( int i = b.hpos( 40 ); i <= b.hpos( 60 ); ++i ) if( f.hp[i-b.left()] < hmin ) { hmin = f.hp[i-b.left()]; col = i; } if( col > b.left() && col < b.right() ) set_merged_guess( 'r', col - 1, 'f', 0 ); } return; } if( f.rp.isctip( 30 ) ) { set_merged_guess( 'f', b.hcenter(), 'i', 0 ); return; } } else if( code == 'k' ) // Looks for merged 'rt' { if( 2 * f.lp[f.lp.pos(10)] > b.width() && !f.rp.increasing( f.rp.pos( 75 ) ) && set_merged_guess( 'r', b.hcenter(), 't', 0 ) ) return; } if( code ) { add_guess( code, 0 ); return; } } if( f.bp.minima() == 3 ) { if( f.bp.minima( b.height() / 2 ) == 1 && f.tp.minima() == 3 && f.lp.minima() == 2 && f.rp.minima() == 2 ) { add_guess( '*', 0 ); return; } if( b.id( b.vcenter(), b.hcenter() ) == 0 && b.id( b.vcenter() - 1, b.hcenter() ) == 0 && b.id( b.vcenter() + 1, b.hcenter() ) == 0 && b.seek_left( b.vcenter(), b.hcenter() ) <= b.hpos( 25 ) ) { // Found merged 'rn' int row = b.vpos( 95 ); int col = b.seek_right( row, b.left() ); col = b.seek_right( row, col + 1, false ); col = b.seek_right( row, col + 1 ); if( col > b.left() && col < b.right() && set_merged_guess( 'r', col, 'n', 0 ) ) return; } if( f.tp.minima( b.height() / 3 ) == 1 ) add_guess( 'm', 0 ); return; } if( f.bp.minima() == 4 && f.tp.minima( b.height() / 3 ) == 1 ) { // Found merged 'rm' int row = b.vpos( 95 ); int col = b.seek_right( row, b.left() ); col = b.seek_right( row, col + 1, false ); col = b.seek_right( row, col + 1 ); if( col > b.left() && col < b.right() && set_merged_guess( 'r', col, 'm', 0 ) ) return; } if( f.tp.minima( b.height() / 4 ) == 3 ) { int hdiff; if( !b.bottom_hook( &hdiff ) && ( f.segments_in_row( b.vcenter() ) < 4 || !b.escape_top( b.vcenter(), b.hcenter() ) ) ) add_guess( 'w', 0 ); return; } code = f.test_line( charbox ); if( code ) { add_guess( code, 0 ); return; } code = f.test_misc( charbox ); if( code ) { add_guess( code, 0 ); return; } } // Recognizes 1 blob characters with 1 hole. // 0469ADOPQRabdegopq# // void Character::recognize111( const Charset & charset, const Rectangle & charbox ) { const Blob & b = blob( 0 ); const Bitmap & h = b.hole( 0 ); if( !h.is_hcentred_in( b ) ) return; Features f( b ); int top_delta = h.top() - b.top(), bottom_delta = b.bottom() - h.bottom(); if( std::abs( top_delta - bottom_delta ) <= std::max( 2, h.height() / 4 ) || Ocrad::similar( top_delta, bottom_delta, 40, 2 ) ) { // hole is vertically centred int code = f.test_4ADQao( charset, charbox ); if( code ) { if( code == 'Q' && Ocrad::similar( top_delta, bottom_delta, 40, 2 ) ) add_guess( 'a', 1 ); add_guess( code, 0 ); } return; } if( top_delta < bottom_delta ) // hole is high { int code = f.test_49ARegpq( charbox ); if( code ) add_guess( code, 0 ); return; } if( top_delta > bottom_delta ) // hole is low { int code = f.test_6abd( charset ); if( code ) { add_guess( code, 0 ); if( code == UCS::SOACUTE ) { int row = h.top() - ( b.bottom() - h.bottom() ) - 1; if( row <= b.top() || row + 1 >= h.top() ) return; Blob & b1 = const_cast< Blob & >( b ); Blob b2( b ); b1.bottom( row ); b2.top( row + 1 ); blobpv.push_back( new Blob( b2 ) ); } } } } // Recognizes 1 blob characters with 2 holes. // 8BQg$& // void Character::recognize112( const Rectangle & charbox ) { const Blob & b = blob( 0 ); const Bitmap & h1 = b.hole( 0 ); // upper hole const Bitmap & h2 = b.hole( 1 ); // lower hole Profile lp( b, Profile::left ); Profile tp( b, Profile::top ); Profile rp( b, Profile::right ); Profile bp( b, Profile::bottom ); // Check for 'm' or 'w' with merged serifs if( 10 * std::abs( h2.vcenter() - h1.vcenter() ) <= b.height() && h1.is_vcentred_in( b ) && h2.is_vcentred_in( b ) ) { if( ( b.bottom() - h1.bottom() <= h1.top() - b.top() ) && ( b.bottom() - h2.bottom() <= h2.top() - b.top() ) && bp.isflats() ) { add_guess( 'm', 0 ); return; } if( 5 * std::abs( h1.bottom() - b.vcenter() ) <= b.height() && 5 * std::abs( h2.bottom() - b.vcenter() ) <= b.height() && tp.isflats() && bp.minima() == 2 ) { add_guess( 'w', 0 ); return; } return; } if( !h1.is_hcentred_in( b ) ) return; if( !h2.is_hcentred_in( b ) ) return; if( h1.left() > b.hcenter() && h2.left() > b.hcenter() ) return; if( h1.right() < b.hpos( 40 ) && h2.right() < b.hpos( 40 ) ) return; if( h1.top() > b.vcenter() || h2.bottom() < b.vcenter() ) return; const int a1 = h1.area(); const int a2 = h2.area(); { const int w = b.right() - std::min( b.hcenter(), std::min( h1.hcenter(), h2.hcenter() ) ); for( int i = h1.bottom() - b.top() + 1; i < h2.top() - b.top(); ++i ) if( rp[i] > w ) { add_guess( 'g', 2 ); return; } } if( Ocrad::similar( a1, a2, 50 ) ) // I don't like this { if( h1.bottom() > b.vcenter() && h2.top() < b.vcenter() && h1.h_overlaps( h2 ) && !h1.h_includes( h2 ) ) { add_guess( '0', 0 ); return; } if( h1.bottom() <= h2.top() ) { int hdiff; if( b.bottom_hook( &hdiff ) && hdiff > b.height() / 2 ) if( b.top_hook( &hdiff ) && hdiff > b.height() / 2 ) { add_guess( 's', 0 ); return; } if( lp.isflats() && ( lp.istip() || ( lp.isflat() && b.test_BD() ) ) ) { add_guess( 'B', 0 ); return; } int col1 = h1.seek_left( h1.bottom(), h1.right() + 1 ) - 1; int col2 = h2.seek_right( h2.top(), h2.left() - 1 ) + 1; if( col1 <= col2 ) { if( lp.isconvex() || lp.ispit() ) add_guess( 'e', 1 ); else if( !rp.isctip() && tp.minima() == 1 ) add_guess( 'a', 1 ); if( bp.istpit() ) { add_guess( '$', 0 ); return; } } if( b.hcenter() > h1.hcenter() && b.hcenter() > h2.hcenter() && ( b.hcenter() >= h1.right() || b.hcenter() >= h2.right() ) ) { add_guess( '&', 0 ); return; } for( int row = h1.bottom() + 1; row < h2.top(); ++row ) if( !b.get_bit( row, hcenter() ) ) { add_guess( 'g', 0 ); return; } if( charbox.bottom() > h2.vcenter() && ( bp.isconvex() || ( bp.ispit() && tp.ispit() ) ) ) { if( b.top() >= charbox.top() && b.height() <= charbox.height() ) { if( ( lp.ispit() || lp.isconvex() ) && ( !rp.ispit() || h2.right() > h1.right() ) ) add_guess( 'e', 1 ); else if( b.right() - rp[rp.pos(50)] > h1.right() && !rp.isctip() ) add_guess( 'a', 1 ); } if( h1.bottom() > b.vcenter() && h1.top() > b.vpos( 30 ) ) add_guess( UCS::SEACUTE, 0 ); else add_guess( '8', 0 ); return; } if( lp.minima() == 2 && rp.minima() == 1 ) { if( charbox.vcenter() < h1.bottom() && charbox.bottom() < h2.bottom() ) add_guess( 'g', 0 ); else add_guess( 'a', 0 ); return; } if( charbox.vcenter() > h1.top() && ( charbox.vcenter() < h1.bottom() || charbox.bottom() < h2.vcenter() ) ) add_guess( 'g', 2 ); add_guess( 'B', 1 ); add_guess( 'a', 0 ); return; } } if( a1 > a2 && h1.h_overlaps( h2 ) ) { if( !h1.v_overlaps( h2 ) ) { if( h2.left() > b.hcenter() && h2.bottom() < b.bottom() - h1.height() ) add_guess( '9', 0 ); else add_guess( 'g', 0 ); return; } if( h1.h_includes( h2 ) ) { add_guess( 'Q', 0 ); return; } return; } if( a1 < a2 && tp.minima() == 1 ) { if( h1.h_overlaps( h2 ) ) { if( rp.minima() == 1 ) { if( 2 * h1.height() > h2.height() && 2 * h1.width() > h2.width() && 3 * h2.width() >= b.width() && !lp.isctip() ) { if( lp.ispit() && lp.isconvex() ) add_guess( '6', 0 ); else add_guess( 'B', 0 ); } else if( h2.right() < b.hcenter() ) add_guess( '&', 0 ); else add_guess( 'a', 0 ); return; } if( !h1.v_overlaps( h2 ) && h1.right() < b.hcenter() && h1.top() > b.top() + h1.height() ) { add_guess( '6', 0 ); return; } } if( h1.bottom() < h2.top() ) { add_guess( '&', 0 ); return; } } } ocrad-0.22/character_r12.cc0000644000076400001440000002270712140452615014036 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "segment.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "profile.h" #include "feats.h" // Recognizes 2 blob characters. // ijÑñ!%:;=?|¡ª±º¿ÁÉÍÓÚÀÈÌÒÙÂÊÎÔÛáéíóúàèìòùâêîôûÅå // void Character::recognize12( const Charset & charset, const Rectangle & charbox ) { const Blob & b1 = blob( 0 ); // upper blob const Blob & b2 = blob( 1 ); // lower blob int a1 = b1.area(); int a2 = b2.area(); Features f1( b1 ); Features f2( b2 ); if( Ocrad::similar( a1, a2, 10 ) ) { if( !b1.holes() && !b2.holes() && 2 * a1 > b1.size() && 2 * a2 > b2.size() ) { if( width() > height() || Ocrad::similar( width(), height(), 40 ) ) { add_guess( '=', 0 ); return; } if( Ocrad::similar( b1.width(), b1.height(), 20, 2 ) && Ocrad::similar( b2.width(), b2.height(), 20, 2 ) ) add_guess( ':', 0 ); return; } return; } if( Ocrad::similar( a1, a2, 60 ) ) { if( f1.test_solid( charbox ) == '.' ) { if( f2.test_solid( charbox ) == '.' ) { add_guess( ':', 0 ); return; } if( b2.height() > b1.height() && b2.top() > charbox.vcenter() ) { add_guess( ';', 0 ); return; } } if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) { int code = f2.test_solid( charbox ); if( code == '-' || code == '_' ) { add_guess( UCS::PLUSMIN, 0 ); return; } } if( b1.includes_hcenter( b2 ) && b2.includes_hcenter( b1 ) ) { if( b1.holes() && b2.holes() ) { add_guess( 'g', 0 ); return; } } if( b1.hcenter() < b2.hcenter() ) // Looks for merged 'fi' { if( b2.height() > b2.width() && b1.hcenter() < b2.left() && b1.includes_hcenter( b2 ) && 4 * b1.height() > 5 * b2.height() && Ocrad::similar( b1.bottom()-b1.top(), b2.bottom()-b1.top(), 10 ) ) { Character c2( new Blob( b2 ) ); c2.recognize1( charset, charbox ); if( ( c2.maybe('l') || c2.maybe('|') ) && set_merged_guess( 'f', b2.left() - 1, 'i', 0 ) ) return; } } } if( a1 > a2 && b1.hcenter() < b2.hcenter() && 2 * b1.height() > 3 * b2.height() && b1.holes() == 1 && b2.holes() == 1 && Ocrad::similar( b2.width(), b2.height(), 50 ) ) { add_guess( '%', 0 ); return; } if( a1 < a2 ) { { int code = f1.test_solid( charbox ); //FIXME all this if( code == '-' && 2 * b1.height() > b1.width() ) code = '.'; else if( code == '\'' || code == '|' ) code = '.'; if( !code && !b1.holes() && 2 * b1.height() < b2.height() && b1.width() <= b2.width() ) { if( 10 * a1 >= 7 * b1.height() * b1.width() ) code = '.'; else code = '\''; } if( !b2.holes() && ( code == '.' || code == '\'' ) ) { // Looks for merged 'ri' or 'rí' if( f2.bp.minima( b2.height() / 4 ) == 2 && b2.top() > b1.bottom() && b2.hcenter() < b1.left() ) { Character c2( new Blob( b2 ) ); c2.recognize1( charset, charbox ); if( c2.maybe('n') ) { if( code == '.' && ( b1.left() < b2.hcenter() || b1.right() > b2.right() ) ) { add_guess( 'n', 0 ); return; } // FIXME remove dot int col, limit = b2.seek_right( b2.vcenter(), b2.hcenter() ); for( col = b2.hcenter(); col <= limit; ++col ) if( b2.seek_bottom( b2.vcenter(), col ) < b2.bottom() ) break; if( b2.left() < col && col < b2.right() ) { if( charset.enabled( Charset::iso_8859_9 ) && f2.rp.istip() ) set_merged_guess( 'T', col - 1, UCS::CIDOT, 1 ); else { const int code2 = ( ( code == '.' ) ? 'i' : (int)UCS::SIACUTE ); set_merged_guess( 'r', col - 1, code2, 1 ); } return; } } } if( code == '.' && f2.bp.minima( b2.height() / 4 ) == 1 && b1.bottom() <= b2.top() && f2.rp.minima( b2.width() / 2 ) <= 2 ) { int hdiff; if( b2.bottom_hook( &hdiff ) && std::abs( hdiff ) >= b2.height() / 2 ) { if( hdiff > 0 && f2.rp.increasing( f2.rp.pos( 80 ) ) ) { add_guess( 'j', 0 ); return; } if( hdiff < 0 ) { if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) if( -4 * hdiff <= 3 * b2.height() && f2.wp.max() > 2 * f1.wp.max() && f2.lp.minima() == 1 && 2 * f2.bp[0] < b2.height() ) { add_guess( UCS::IQUEST, 0 ); return; } add_guess( 'i', 0 ); return; } } if( f2.tp.minima() == 1 ) { const bool maybe_j = ( b2.height() > charbox.height() && b2.vpos( 80 ) > charbox.bottom() ); if( Ocrad::similar( f1.wp.max(), f2.wp.max(), 20 ) ) { if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) if( !f2.lp.isctip() && f2.wp.max() >= f1.wp.max() && ( 3 * f2.wp[f2.wp.pos(10)] < 2 * f1.wp.max() || ( b1.left() <= b2.left() && b2.vpos( 80 ) > charbox.bottom() ) ) ) { add_guess( UCS::IEXCLAM, 0 ); return; } if( maybe_j ) add_guess( 'j', 0 ); else add_guess( 'i', 0 ); return; } if( 3 * f2.wp.max() > 4 * f1.wp.max() && b2.seek_bottom( b2.vcenter(), b2.hpos( 10 ) ) < b2.bottom() && f2.rp.increasing( f2.rp.pos( 75 ) ) && ( b1.left() >= b2.hcenter() || b2.seek_top( b2.vcenter(), b2.hpos( 10 ) ) <= b2.top() ) ) { add_guess( 'j', 0 ); return; } if( charset.enabled( Charset::iso_8859_9 ) && f2.rp.istip() ) { add_guess( UCS::CIDOT, 0 ); return; } if( maybe_j ) add_guess( 'j', 0 ); else add_guess( 'i', 0 ); return; } } } } if( ( !b1.holes() && ( b1.bottom() < b2.vcenter() || 2 * a1 < a2 ) ) || ( b1.holes() == 1 && b1.bottom() < b2.top() && b2.top() - b1.bottom() < b1.height() ) ) { Character c( new Blob( b2 ) ); c.recognize1( charset, charbox ); if( c.guesses() ) { int code = c.guess( 0 ).code; if( b1.holes() == 1 ) { if( code == 'a' ) code = UCS::SARING; else if( code == 'A' ) code = UCS::CARING; else code = 0; } else if( code == 'u' && 5 * b1.width() <= b2.width() && 5 * b1.height() <= b2.width() ) return; else if( b1.bottom() < b2.vcenter() ) { int atype = '\''; if( UCS::isvowel( code ) && 2 * b1.width() > 3 * b1.height() && !f1.tp.iscpit() && f1.hp.iscpit() ) atype = ':'; else if( f1.bp.minima() == 2 || f1.bp.istip() ) atype = '^'; else if( std::min( b1.height(), b1.width() ) >= 5 && ( f1.rp.decreasing() || f1.tp.increasing() ) && ( f1.bp.decreasing() || f1.lp.increasing() ) ) atype = '`'; code = UCS::compose( code, atype ); } if( code != c.guess( 0 ).code && charset.only( Charset::ascii ) ) { if( UCS::base_letter( code ) == 'i' ) code = 'i'; else code = c.guess( 0 ).code; } if( code ) add_guess( code, 0 ); } } return; } if( b1.bottom() <= b2.top() ) { const int code = f2.test_solid( charbox ); if( !b1.holes() && ( code == '.' || ( code && Ocrad::similar( b2.height(), b2.width(), 50 ) ) ) ) { if( Ocrad::similar( b1.width(), b2.width(), 50 ) && !f1.lp.isctip() ) { add_guess( '!', 0 ); return; } if( f1.bp.minima() == 1 ) add_guess( '?', 0 ); return; } if( code == '-' || code == '_' ) if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) { if( b1.holes() == 1 ) { const Bitmap & h = b1.hole( 0 ); if( b2.width() >= h.width() && b2.top() - b1.bottom() < h.height() ) { if( Ocrad::similar( h.left() - b1.left(), b1.right() - h.right(), 40 ) ) { add_guess( UCS::MASCORD, 0 ); return; } add_guess( UCS::FEMIORD, 0 ); return; } } } } } ocrad-0.22/character_r13.cc0000644000076400001440000000457012140452615014035 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "segment.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "profile.h" #include "feats.h" // Recognizes 3 blob characters. // %ÄËÏÖÜäëïöüÿ÷ // void Character::recognize13( const Charset & charset, const Rectangle & charbox ) { const Blob & b1 = blob( 0 ); const Blob & b2 = blob( 1 ); const Blob & b3 = blob( 2 ); // lower blob Character c( new Blob( b3 ) ); int code = 0; c.recognize1( charset, charbox ); if( c.guesses() ) { if( c.maybe('.') || ( c.height() < 2 * c.width() && c.maybe(',') && 2 * b3.area() >= b3.size() ) ) { if( b1.bottom() <= b2.top() && b2.bottom() <= b3.top() ) { if( b2.width() >= 2 * b2.height() ) code = UCS::DIV; } else if( b1.top() < b3.top() && b2.top() < b3.top() ) code = '%'; } else if( std::max( b1.width(), b2.width() ) < b3.width() && Ocrad::similar( b1.height(), b2.height(), 20, 2 ) && 2 * std::max( b1.height(), b2.height() ) < b3.height() ) code = UCS::compose( c.guess( 0 ).code, ':' ); else if( c.maybe('o') ) { if( ( b1.hcenter() < b2.hcenter() && b1.holes() == 1 && !b2.holes() ) || ( b2.hcenter() < b1.hcenter() && b2.holes() == 1 && !b1.holes() ) ) code = '%'; } } if( charset.only( Charset::ascii ) ) { if( code == UCS::DIV ) code = '%'; else code = UCS::base_letter( code ); } if( code ) add_guess( code, 0 ); } ocrad-0.22/common.cc0000644000076400001440000001204212150233277012677 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" namespace { const int charsets = 3; const Charset::Value charset_value[charsets] = { Charset::ascii, Charset::iso_8859_9, Charset::iso_8859_15 }; const char * const charset_name[charsets] = { "ascii", "iso-8859-9", "iso-8859-15" }; struct F_entry { const char * const name; Filter::Type type; }; const F_entry F_table[] = { { "none", Filter::none }, { "letters", Filter::letters }, { "letters_only", Filter::letters_only }, { "numbers", Filter::numbers }, { "numbers_only", Filter::numbers_only }, { 0, Filter::none } }; struct T_entry { const char * const name; Transformation::Type type; }; const T_entry T_table[] = { { "none", Transformation::none }, { "rotate90", Transformation::rotate90 }, { "rotate180", Transformation::rotate180 }, { "rotate270", Transformation::rotate270 }, { "mirror_lr", Transformation::mirror_lr }, { "mirror_tb", Transformation::mirror_tb }, { "mirror_d1", Transformation::mirror_d1 }, { "mirror_d2", Transformation::mirror_d2 }, { 0, Transformation::none } }; } // end namespace int verbosity = 0; void Ocrad::internal_error( const char * const msg ) { std::fprintf( stderr, "ocrad: internal error: %s.\n", msg ); std::exit( 3 ); } bool Ocrad::similar( const int a, const int b, const int percent_dif, const int abs_dif ) { int difference = std::abs( a - b ); if( percent_dif > 0 && difference <= abs_dif ) return true; int max_abs = std::max( std::abs(a), std::abs(b) ); return ( difference * 100 <= max_abs * percent_dif ); } bool Charset::enable( const char * const name ) { for( int i = 0; i < charsets; ++i ) if( std::strcmp( name, charset_name[i] ) == 0 ) { charset_ |= charset_value[i]; return true; } return false; } bool Charset::enabled( const Value cset ) const { if( !charset_ ) return cset == iso_8859_15; // default charset return charset_ & cset; } bool Charset::only( const Value cset ) const { if( !charset_ ) return cset == iso_8859_15; // default charset return charset_ == cset; } void Charset::show_error( const char * const program_name, const char * const arg ) const { if( verbosity >= 0 ) { if( arg && std::strcmp( arg, "help" ) ) std::fprintf( stderr,"%s: bad charset '%s'\n", program_name, arg ); std::fputs( "Valid charset names are:", stderr ); for( int i = 0; i < charsets; ++i ) std::fprintf( stderr, " %s", charset_name[i] ); std::fputs( "\n", stderr ); } } bool Filter::set( const char * const name ) { for( int i = 0; F_table[i].name != 0; ++i ) if( std::strcmp( name, F_table[i].name ) == 0 ) { type_ = F_table[i].type; return true; } return false; } void Filter::show_error( const char * const program_name, const char * const arg ) const { if( verbosity >= 0 ) { if( arg && std::strcmp( arg, "help" ) ) std::fprintf( stderr,"%s: bad filter '%s'\n", program_name, arg ); std::fputs( "Valid filter names are:", stderr ); for( int i = 0; F_table[i].name != 0; ++i ) std::fprintf( stderr, " %s", F_table[i].name ); std::fputs( "\n", stderr ); } } bool Transformation::set( const char * const name ) { for( int i = 0; T_table[i].name != 0; ++i ) if( std::strcmp( name, T_table[i].name ) == 0 ) { type_ = T_table[i].type; return true; } return false; } void Transformation::show_error( const char * const program_name, const char * const arg ) const { if( verbosity >= 0 ) { if( arg && std::strcmp( arg, "help" ) ) std::fprintf( stderr,"%s: bad bitmap trasformation '%s'\n", program_name, arg ); std::fputs( "Valid transformation names are:", stderr ); for( int i = 0; T_table[i].name != 0; ++i ) std::fprintf( stderr, " %s", T_table[i].name ); std::fputs( "\nRotations are made counter-clockwise.\n", stderr ); } } bool Control::set_format( const char * const name ) { if( std::strcmp( name, "byte" ) == 0 ) { utf8 = false; return true; } if( std::strcmp( name, "utf8" ) == 0 ) { utf8 = true; return true; } return false; } ocrad-0.22/feats.cc0000644000076400001440000002247412147754531012532 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "segment.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "profile.h" #include "feats.h" Features::Features( const Blob & b_ ) : b( b_ ), hbars_( -1 ), vbars_( -1 ), lp( b, Profile::left ), tp( b, Profile::top ), rp( b, Profile::right ), bp( b, Profile::bottom ), hp( b, Profile::height ), wp( b, Profile::width ) {} int Features::hbars() const { if( hbars_ < 0 ) { const int limit = wp.max() / 2; int state = 0, begin = 0, l = 0, r = 0; std::vector< int > count( b.height(), 0 ); hbars_ = 0; for( int row = b.top(); row <= b.bottom(); ++row ) { int col, c = 0, lt = 0, rt = 0, x = 0; int & maxcount = count[row-b.top()]; for( col = b.left(); col <= b.right(); ++col ) { if( b.get_bit( row, col ) ) { ++c; x = col; if( col < b.right() ) continue; } if( c > maxcount ) { maxcount = c; rt = x; lt = rt - c + 1; } c = 0; } switch( state ) { case 0: if( maxcount > limit ) { state = 1; begin = row; l = lt; r = rt; } else break; case 1: if( maxcount > limit ) { if( lt < l ) l = lt; if( rt > r ) r = rt; if( row < b.bottom() ) break; } state = 0; int end = ( maxcount <= limit ) ? row - 1 : row; const int width = r - l + 1; while( begin <= end && 3 * count[begin-b.top()] < 2 * width ) ++begin; while( begin <= end && 3 * count[end-b.top()] < 2 * width ) --end; const int height = end - begin + 1; if( height < 1 || 2 * height > 3 * width ) break; hbar_.push_back( Rectangle( l, begin, r, end ) ); ++hbars_; break; } } } return hbars_; } int Features::vbars() const // FIXME small gaps not detected { if( vbars_ < 0 ) { int state = 0, begin = 0, limit = b.height(); limit -= ( b.height() < 40 ) ? 3 : b.height() / 10; vbars_ = 0; for( int col = b.left(); col <= b.right(); ++col ) { int c = 0, c2 = 0, count = 0; for( int row = b.top() + 1; row < b.bottom(); ++row ) { if( b.get_bit( row, col ) ) { ++c; if( row < b.bottom() - 1 ) continue; } else if( ( col > b.left() && b.get_bit( row, col - 1 ) ) || ( col < b.right() && b.get_bit( row, col + 1 ) ) ) { ++c; ++c2; if( row < b.bottom() - 1 ) continue; } if( c > count ) { count = c; } c = 0; } if( ( count - c2 ) * 3 < limit * 2 ) count = 0; switch( state ) { case 0: if( count >= limit ) { state = 3; begin = col; } else if( count * 4 >= limit * 3 ) { state = 2; begin = col; } else if( count * 3 >= limit * 2 ) { state = 1; begin = col; } break; case 1: if( count >= limit ) state = 3; else if( count * 4 >= limit * 3 ) state = 2; else if( count * 3 < limit * 2 ) state = 0; else begin = col; break; case 2: if( count >= limit ) state = 3; else if( count * 3 < limit * 2 ) state = 0; else if( count * 4 < limit * 3 ) state = 1; break; case 3: if( count * 3 < limit * 2 || col == b.right() ) { int end = ( count * 3 < limit * 2 ) ? col - 1 : col; vbar_.push_back( Rectangle( begin, b.top(), end, b.bottom() ) ); ++vbars_; state = 0; } } } } return vbars_; } // return the number of vertical traces crossing every row // int Features::segments_in_row( const int row ) const { if( row_scan.size() == 0 ) { int l = -1; // begin of segment. -1 means no segment row_scan.resize( b.height() ); for( int row = b.top(); row <= b.bottom(); ++row ) for( int col = b.left(); col <= b.right(); ++col ) { bool black = b.get_bit( row, col ); if( l < 0 && black ) l = col; // begin of segment if( l >= 0 && ( !black || col == b.right() ) ) // end of segment { row_scan[row-b.top()].push_back( Csegment( l, col - !black ) ); l = -1; } } } return row_scan[row-b.top()].size(); } // return the number of horizontal traces crossing every column // int Features::segments_in_col( const int col ) const { if( col_scan.size() == 0 ) { int t = -1; // begin of segment. -1 means no segment col_scan.resize( b.width() ); for( int col = b.left(); col <= b.right(); ++col ) for( int row = b.top(); row <= b.bottom(); ++row ) { bool black = b.get_bit( row, col ); if( t < 0 && black ) t = row; // begin of segment if( t >= 0 && ( !black || row == b.bottom() ) ) // end of segment { col_scan[col-b.left()].push_back( Csegment( t, row - !black ) ); t = -1; } } } return col_scan[col-b.left()].size(); } // return the column segment containing the point (row,col) if any // Csegment Features::col_segment( const int row, const int col ) const { const int segments = segments_in_col( col ); for( int i = 0; i < segments; ++i ) if( col_scan[col-b.left()][i].includes( row ) ) return col_scan[col-b.left()][i]; return Csegment(); } int Features::test_misc( const Rectangle & charbox ) const { if( bp.minima() == 1 ) { if( hbars() == 1 && hbar(0).top() <= b.top() + ( b.height() / 10 ) && 4 * hbar(0).height() <= b.height() && 5 * hbar(0).width() >= 4 * b.width() && rp[hbar(0).bottom()-b.top()+2] - rp[hbar(0).bottom()-b.top()] < b.width() / 4 && rp.increasing( hbar(0).vcenter() - b.top() + 1 ) ) return '7'; if( b.height() > b.width() && rp.increasing() && !tp.decreasing() && b.seek_left( b.vcenter(), b.hcenter() ) <= b.left() ) return '7'; } if( tp.minima( b.height() / 4 ) == 1 && bp.minima( b.height() / 4 ) == 1 ) { if( b.height() > 2 * b.width() && rp.increasing() && tp.decreasing() && lp.iscpit( 25 ) ) return '1'; if( hbars() == 1 || ( hbars() == 2 && hbar(1).bottom() >= b.bottom() - 1 && 3 * hbar(0).width() > 4 * hbar(1).width() ) ) if( 3 * hbar(0).height() < b.height() && hbar(0).top() <= b.top() + 1 ) { int i = lp.pos( 40 ); if( 3 * wp[i] < b.width() && 5 * lp[i] > b.width() && 5 * rp[i] > b.width() ) return 'T'; } if( 3 * b.height() > 4 * b.width() && vbars() == 1 && vbar(0).width() >= 2 ) { const int lg = vbar(0).left() - b.left(); const int rg = b.right() - vbar(0).right(); if( 2 * lg < b.width() && 2 * rg < b.width() && Ocrad::similar( lg, rg, 40 ) && 4 * bp[bp.pos(25)] > 3 * b.height() && 4 * tp[tp.pos(75)] > 3 * b.height() ) return 'l'; } if( 5 * b.height() >= 4 * charbox.height() && b.height() > wp.max() && 3 * wp[wp.pos(50)] < b.width() ) { if( hbars() == 1 && hbar(0).bottom() >= b.bottom() - 1 && hbar(0).top() > b.vpos( 75 ) ) return 'l'; if( hbars() == 2 && hbar(0).bottom() < b.vpos( 25 ) && hbar(1).top() > b.vpos( 75 ) && hbar(1).bottom() >= b.bottom() - 1 /*&& 3 * hbar(0).width() < 4 * hbar(1).width()*/ ) { if( hbar(0).right() <= hbar(1).hcenter() ) return 0; if( 3 * hbar(0).width() <= 2 * hbar(1).width() || b.height() >= 3 * wp.max() ) return 'l'; return 'I'; } } if( ( hbars() == 2 || hbars() == 3 ) && hbar(0).top() <= b.top() + 1 && hbar(1).includes_vcenter( b ) && 3 * hbar(0).width() > 4 * hbar(1).width() && ( hbars() == 2 || ( hbar(2).bottom() >= b.bottom() - 1 && 3 * hbar(0).width() > 4 * hbar(2).width() ) ) ) return 'F'; if( b.height() > 3 * wp.max() ) { if( rp.istip() && lp.ispit() ) { if( lp.istpit() ) return '{'; else return '('; } if( lp.istip() && rp.ispit() ) { if( rp.istpit() ) return '}'; else return ')'; } if( b.width() > 2 * wp.max() && rp.isconvex() ) return ')'; } if( b.height() > 2 * b.width() && 5 * b.height() >= 4 * charbox.height() && lp.max() + rp.max() < b.width() ) return '|'; } return 0; } ocrad-0.22/feats_test0.cc0000644000076400001440000007627512160436214013647 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "segment.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "profile.h" #include "feats.h" // Looks for three black sections in column hcenter() ± n, then tests if // upper and lower gaps are open to the right or to the left // int Features::test_235Esz( const Charset & charset ) const { const int csize = 3; const int ucoff[csize] = { 0, -1, +1 }; const int lcoff[3*csize] = { 0, -1, +1, -1, 0, +1, +1, 0, -1 }; if( b.width() < 9 || b.height() > 3 * b.width() || bp.minima( b.height() / 2 ) > 1 ) return 0; const int noise = ( std::min( b.height(), b.width() ) / 15 ) + 1; int lrow1 = 0, urow2 = 0, lrow2 = 0, urow3 = 0; int lcol1 = 0, ucol2 = 0, lcol2 = 0, ucol3 = 0; bool done = false; for( int i = 0; i < csize && !done; ++i ) { const int ucol = b.hcenter() + ( noise * ucoff[i] ); int row = b.top() + tp[ucol-b.left()]; while( ++row < b.bottom() && b.get_bit( row, ucol ) ) ; if( row <= b.vpos( 30 ) ) { lrow1 = row; lcol1 = ucol; } else continue; while( ++row < b.bottom() && !b.get_bit( row, ucol ) ) ; if( row < b.bottom() ) { urow2 = row - 1; ucol2 = ucol; for( int j = 0; j < csize && !done; ++j ) { row = urow2 + 1; const int lcol = b.hcenter() + ( noise * lcoff[(csize*i)+j] ); if( ucol != lcol ) { const int d = ( ucol > lcol ) ? +1 : -1; int c = lcol; while( c != ucol && b.get_bit( row, c ) ) c += d; if( c != ucol ) continue; } while( ++row < b.bottom() && b.get_bit( row, lcol ) ) ; if( row < b.bottom() ) { lrow2 = row; lcol2 = lcol; } else continue; while( ++row <= b.bottom() && !b.get_bit( row, lcol ) ) ; if( row <= b.bottom() && row > b.vpos( 70 ) ) { urow3 = row - 1; ucol3 = lcol; done = true; } } } } if( !done ) return 0; const bool bopen = b.escape_bottom( urow3, ucol3 ); const bool topen = b.escape_top( lrow1, lcol1 ); const bool tbopen = bopen && topen; const int ascode = ( b.get_bit( b.vcenter(), b.hcenter() ) ) ? '*' : 0; if( b.escape_left( lrow2, lcol2 ) ) { if( b.escape_left( urow2, ucol2 ) ) { if( tbopen ) return ascode; if( !bopen && !topen && b.height() <= 3 * b.width() ) { const int lm = lp.minima(), rm = rp.minima(); if( ( lm == 3 || lm == 2 ) && ( rm == 2 || ( rm == 1 && rp.iminimum() < rp.pos( 80 ) ) ) ) return '3'; } } else if( b.escape_right( urow2, ucol2 ) ) { if( tbopen ) return ascode; if( rp[lrow1 + 1 - b.top()] >= lcol1 - b.left() && ( lp[lrow2 + 1 - b.top()] < lcol2 - b.left() || lp[urow3 - 1 - b.top()] < ucol3 - b.left() ) ) { int c = 0, hdiff; if( !b.top_hook( &hdiff ) || 5 * hdiff >= 4 * b.height() ) ++c; if( 2 * lp[lrow2 - b.top()] < lcol2 - b.left() ) ++c; if( !tp.isconvex() || ( !tp.ispit() && bp.ispit() ) ) ++c; if( c >= 2 ) return '5'; } if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) if( urow2 > b.vpos( 55 ) && b.seek_right( urow2 - 1, ucol2 ) < b.right() ) { if( urow2 > b.vpos( 63 ) ) return UCS::CCCEDI; else return UCS::SCCEDI; } return 's'; } } else if( b.escape_right( lrow2, lcol2 ) ) { if( b.escape_right( urow2, ucol2 ) ) { if( tbopen ) return ascode; if( bp.minima( b.height() / 5 ) == 1 ) { if( 8 * lp[((lrow2+urow3)/2)-b.top()] >= b.width() && b.escape_top( ( lrow1 + urow2 ) / 2, b.left() ) && !b.escape_top( ( lrow2 + urow3 ) / 2, b.left() ) ) return 'f'; if( rp.minima( b.width() / 8 ) < 3 && b.escape_bottom( urow3, ucol3 ) ) { if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) if( 2 * lp[lp.pos(95)] > rp[rp.pos(95)] ) { if( urow2 > b.vpos( 63 ) ) return UCS::CCCEDI; else return UCS::SCCEDI; } return 'F'; } else if( lrow1 < urow2 && lrow2 < urow3 ) return 'E'; } } else if( b.escape_left( urow2, ucol2 ) ) { if( !tbopen && ( 2 * lp[lp.pos(50)] ) + 2 >= b.width() && ( tp.isconvex() || ( tp.ispit() && !bp.ispit() ) ) ) return '2'; if( b.height() <= 2 * wp.max() && bp[bp.pos(75)] <= b.height() / 10 ) return 'z'; } } return 0; } int Features::test_CEFIJLlT( const Charset & charset ) const { if( tp.minima( b.height() / 4 ) != 1 || bp.minima( b.height() / 4 ) != 1 ) return 0; const int noise = ( std::min( b.height(), b.width() ) / 30 ) + 1; { int col; if( 2 * ( lp[lp.pos(50)] + noise ) >= b.width() ) col = b.hpos( 25 ); else col = b.hpos( 75 ); int row = b.seek_top( b.vcenter(), col ); if( row <= b.top() || ( row < b.vpos( 25 ) && b.escape_top( row, col ) ) ) { int hdiff; if( b.bottom_hook( &hdiff ) ) { if( hdiff > b.height() / 2 && rp.increasing( rp.pos( 80 ), 1 ) && !rp.decreasing() ) return 'J'; if( -hdiff > b.height() / 2 ) { if( 5 * lp[lp.pos(80)] < 2 * b.width() ) return 'L'; else return 'v'; } } } } const int vnoise = ( b.height() / 30 ) + 1; const int topmax = b.top() + vnoise; const int botmin = b.bottom() - vnoise; if( vbars() == 1 && vbar(0).width() >= 2 && 2 * vbar(0).width() < b.width() ) { if( std::abs( vbar(0).hcenter() - b.hcenter() ) <= noise && std::abs( (vbar(0).left() - b.left()) - (b.right() - vbar(0).right()) ) <= 2 * noise ) { if( hbars() == 1 && 4 * hbar(0).height() <= b.height() ) { if( hbar(0).top() <= topmax || hbar(0).bottom() < b.vpos( 15 ) ) return 'T'; if( std::abs( hbar(0).vcenter() - b.vcenter() ) <= 1 && Ocrad::similar( b.height(), b.width(), 50 ) ) return '+'; } if( hbars() == 2 && hbar(0).top() <= topmax && 4 * hbar(0).height() <= b.height() && hbar(1).bottom() >= botmin && 4 * hbar(1).height() <= b.height() && 3 * hbar(0).width() > 4 * hbar(1).width() ) return 'T'; } } if( vbars() == 1 && vbar(0).width() >= 2 && 2 * vbar(0).width() <= b.width() ) { if( vbar(0).right() <= b.hcenter() ) { if( ( hbars() == 2 || hbars() == 3 ) && hbar(0).top() <= topmax && hbar(0).width() + 1 >= hbar(1).width() && 2 * hbar(1).width() >= 3 * vbar(0).width() && vbar(0).h_overlaps( hbar(1) ) ) { if( hbars() == 3 && Ocrad::similar( hbar(0).width(), hbar(2).width(), 10, 2 ) && 10 * hbar(2).width() >= 9 * hbar(1).width() && hbar(0).left() <= hbar(1).left() + 1 ) return 'E'; if( ( hbars() == 2 || hbar(0).width() > hbar(2).width() ) && ( hbar(1).includes_vcenter( b ) || ( 3 * hbar(1).width() > 2 * hbar(0).width() && 10 * lp[vnoise] < b.width() && hbar(1).top() > b.vpos( 30 ) && hbar(1).bottom() < b.vpos( 60 ) ) ) ) return 'F'; } if( hbars() == 2 && hbar(1).bottom() >= botmin && b.height() > b.width() && hbar(1).width() > hbar(0).width() && std::abs( vbar(0).hcenter() - hbar(0).hcenter() ) <= 1 && rp.iminimum() > rp.pos( 70 ) ) return 'L'; if( hbars() == 1 && Ocrad::similar( hbar(0).width(), b.width(), 10 ) && vbar(0).left() <= b.hpos( 30 ) ) { if( hbar(0).bottom() >= botmin && b.escape_top( b.vcenter(), b.hpos( 75 ) ) ) return 'L'; if( hbar(0).top() <= topmax && 2 * wp[wp.pos(50)] >= b.width() && 4 * wp[wp.pos(75)] < b.width() && b.escape_right( b.vpos( 25 ), b.hcenter() ) ) return 'F'; } } if( vbar(0).left() > b.hcenter() && hbars() == 1 && hbar(0).top() <= topmax && hbar(0).width() + 1 >= b.width() ) { if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) if( b.width() > b.height() ) return UCS::NOT; return 0; } } if( vbars() == 1 && vbar(0).width() >= 2 && tp.minima() == 1 && bp.minima() == 1 ) { if( 3 * b.height() > 4 * b.width() && Ocrad::similar( vbar(0).left() - b.left(), b.right() - vbar(0).right(), 30, 2 * noise ) ) { if( b.height() <= 3 * wp.max() && rp.istip() && lp.istip() ) { if( b.height() <= 3 * b.width() && lp[lp.pos(40)] > lp[lp.pos(60)] + noise && rp[rp.pos(60)] > rp[rp.pos(40)] + noise ) return 'z'; return 'I'; } if( rp.isflats() && ( lp.istip() || lp.isflats() || ( lp.isctip() && lp.minima() == 2 && lp.iminimum() < lp.pos( 30 ) && lp.iminimum(1) > lp.pos( 80 ) ) ) ) return 'l'; if( b.height() > 3 * wp.max() ) { if( rp.istip() && lp.ispit() && Ocrad::similar( lp.iminimum(), lp.pos( 50 ), 10 ) ) { if( lp.istpit() ) return '{'; else return '('; } if( lp.istip() && rp.ispit() && Ocrad::similar( rp.iminimum(), rp.pos( 50 ), 10 ) ) { if( rp.istpit() ) return '}'; else return ')'; } if( rp.isflats() && 2 * vbar(0).size() >= b.area() ) return 'l'; } if( 2 * b.height() > 3 * b.width() && lp.minima() <= 2 ) if( rp.isflats() || rp.minima() == 1 ) if( vbar(0).right() >= b.hpos( 70 ) || b.escape_top( b.vpos( 75 ), std::min( b.right(), vbar(0).right() + 1 ) ) ) for( int i = vbar(0).left() - 1; i > b.left(); --i ) if( b.seek_bottom( b.vpos( 75 ), i ) < b.bottom() && bp[i-b.left()] <= noise ) return 'l'; } if( vbar(0).left() <= b.left() + 1 && b.height() > 2 * b.width() && rp.istip() ) { if( 2 * rp[rp.pos(50)] > b.width() ) { int row = b.seek_top( b.vcenter(), b.hcenter() ); int col = b.seek_right( row, b.hcenter() ); if( col < b.right() ) { row = b.seek_bottom( b.vcenter(), b.hcenter() ); col = b.seek_right( row, b.hcenter() ); if( col < b.right() ) return 'C'; } } return '['; } if( vbar(0).right() >= b.right() - 1 ) { if( lp.istip() && b.height() > 2 * b.width() ) { if( 2 * vbar(0).width() <= wp.max() && lp[lp.pos(50)] >= b.width() / 2 ) return ']'; if( b.height() >= 3 * b.width() ) return 'l'; } if( 2 * b.height() >= 3 * b.width() && vbar(0).height() >= 3 * vbar(0).width() && lp.istpit() && lp.minima() == 1 ) { const int i = lp.iminimum(); if( i > lp.pos( 10 ) && i < lp.pos( 40 ) ) return '1'; } } } if( hbars() == 1 && std::abs( hbar(0).vcenter() - b.vcenter() ) <= 1 && Ocrad::similar( b.height(), b.width(), 50 ) && tp.isupit() && bp.isupit() ) return '+'; return 0; } int Features::test_c() const { if( lp.isconvex() || lp.ispit() ) { int urow = b.seek_top( b.vcenter(), b.hcenter() ); int lrow = b.seek_bottom( b.vcenter(), b.hcenter() ); if( b.height() > 2 * b.width() && ( 3 * wp.max() <= 2 * b.width() || ( 2 * rp[urow-b.top()] >= b.width() && 2 * rp[lrow-b.top()] >= b.width() ) ) ) { if( lp.isconvex() ) return '('; else return 0; } if( urow > b.top() && lrow < b.bottom() && rp.isctip() && ( bp.ispit() || tp.ispit() || ( bp.islpit() && tp.islpit() ) ) && b.escape_right( b.vcenter(), b.hcenter() ) ) return 'c'; } if( b.height() > 2 * b.width() && rp.isconvex() ) { int urow = b.seek_top( b.vcenter(), b.hcenter() ); int lrow = b.seek_bottom( b.vcenter(), b.hcenter() ); if( 3 * wp.max() <= 2 * b.width() || ( 2 * lp[urow-b.top()] >= b.width() && 2 * lp[lrow-b.top()] >= b.width() ) ) return ')'; } return 0; } int Features::test_frst( const Rectangle & charbox ) const { if( bp.minima( b.height() / 4 ) != 1 || tp.minima( b.height() / 2 ) != 1 || bp.minima( b.height() / 2 ) != 1 ) return 0; const int noise = ( std::min( b.height(), b.width() ) / 30 ) + 1; const bool maybe_slanted_r = ( tp.minima( b.height() / 4 ) != 1 ); bool maybe_t = true; if( !maybe_slanted_r ) { int b_hdiff = 0, t_hdiff = 0; if( b.bottom_hook( &b_hdiff ) ) { if( -2 * b_hdiff > b.height() ) { if( b.height() >= 3 * wp.max() && ( hbars() == 0 || hbar(0).bottom() < b.vpos( 20 ) ) ) return 'l'; if( 2 * wp[wp.pos(6)] < b.width() && hbars() >= 1 && hbars() <= 2 && hbar(0).top() >= b.vpos( 15 ) && hbar(0).bottom() < b.vcenter() && Ocrad::similar( hbar(0).width(), wp.max(), 10 ) ) return 't'; } } if( b.top_hook( &t_hdiff ) ) { if( 3 * t_hdiff > 2 * b.height() && b.height() > 2 * wp.max() && tp.iminimum() > tp.pos( 50 ) && bp.iminimum() <= bp.pos( 50 ) && ( !b_hdiff || rp.increasing( rp.pos( 50 ) ) ) ) return 'f'; if( 2 * b_hdiff > b.height() && 2 * t_hdiff > b.height() ) return 0; // recognized 's' or SCCEDI maybe_t = false; } } if( 2 * rp[rp.pos(50)] > b.width() && 2 * bp[bp.pos(50)] > b.height() && tp.isctip() ) return 'r'; if( maybe_slanted_r || vbars() != 1 || vbar(0).width() < 2 ) return 0; if( vbar(0).hcenter() <= b.hcenter() ) { const int col = b.right() - rp[rp.pos(50)] + 2; if( col < b.right() ) { const int row = b.seek_bottom( b.vcenter(), col ); if( row >= b.bottom() || b.escape_bottom( row - 1, col ) ) { if( rp.minima() == 3 ) { if( rp.minima( b.width() / 8 ) < 3 ) return 'f'; else return 0; } if( Ocrad::similar( b.height(), b.width(), 40 ) ) { if( tp.minima( b.height() / 8 ) == 2 && bp.minima( b.height() / 8 ) == 2 ) return 'x'; int row2 = b.vpos( 75 ); int col2 = b.seek_right( row2, b.hcenter(), false ) + 1; if( b.seek_right( row2, col2 ) >= b.right() ) { if( lp.isconvex() && ( col > b.hpos( 60 ) || row < b.bottom() ) ) return 0; if( ( hbars() == 1 || ( hbars() == 2 && hbar(1).bottom() >= b.bottom() - 1 && 2 * hbar(0).width() > 3 * hbar(1).width() ) ) && hbar(0).top() <= b.top() + 1 && 4 * hbar(0).height() <= b.height() && 4 * lp[lp.pos(50)] >= b.width() ) return 'T'; return 'r'; } } } if( Ocrad::similar( b.height(), b.width(), 40 ) && segments_in_row( b.vpos( 15 ) ) == 3 && segments_in_row( b.vpos( 85 ) ) == 3 && b.seek_right( row - 1, col ) < b.right() && lp.isctip() ) return 'x'; } if( 3 * b.height() > 4 * b.width() && vbar(0).left() > b.left() && rp.minima() <= 2 ) { const int col = b.right() - std::max( 0, rp[rp.pos(50)] - 1 ); if( !b.escape_bottom( b.vcenter(), col ) ) { if( 3 * wp[wp.pos(6)] < 2 * b.width() && tp.ispit() && lp.iminimum() < lp.pos( 40 ) ) return 't'; else return 0; } else if( 2 * wp.max() > b.width() ) { if( rp.iminimum() < rp.pos( 20 ) ) { if( rp.increasing( rp.pos( 20 ) ) || bp.increasing() || tp.minima( noise ) == 2 || ( rp.minima() == 1 && ( b.height() < charbox.height() || tp.iminimum() > tp.pos( 50 ) ) ) ) { if( b.height() <= 3 * wp.max() ) return 'r'; else return 0; } else if( 3 * b.height() >= 5 * b.width() ) return 'f'; } else { if( maybe_t && !rp.isconvex() && bp.minima( b.height() / 3 ) == 1 ) return 't'; else return 0; } } } if( b.seek_bottom( b.vcenter(), b.hpos( 60 ) + 1 ) >= b.bottom() ) { if( rp.minima() == 2 ) return 'f'; else return 'r'; } if( vbar(0).right() <= b.hcenter() && hbars() == 1 && hbar(0).bottom() >= b.bottom() - 1 && lp.istip() && rp.istip() && !b.escape_top( b.vcenter(), b.hpos( 75 ) ) ) return 'r'; } return 0; } int Features::test_G() const { if( lp.isconvex() || lp.ispit() ) { int col = 0, row = 0; for( int i = rp.pos( 30 ); i <= rp.pos( 60 ); ++i ) if( rp[i] > col ) { col = rp[i]; row = i; } if( col == 0 ) return 0; row += b.top(); col = b.right() - col + 1; if( col <= b.left() || col >= b.hcenter() ) return 0; col = ( col + b.hcenter() ) / 2; row = b.seek_bottom( row, col ); if( row < b.bottom() && b.escape_right( row, col ) && !b.escape_bottom( row, b.hcenter() ) ) { const int noise = std::max( 2, b.height() / 20 ); int lrow, urow; for( lrow = row - 1 ; lrow > b.top(); --lrow ) if( b.seek_right( lrow, b.hcenter() ) >= b.right() ) break; for( urow = lrow - 1 ; urow > b.top(); --urow ) if( b.seek_right( urow, b.hcenter() ) < b.right() ) break; lrow += noise; urow -= noise; if( lrow < row && urow > b.top() ) { int uwidth = b.seek_left( urow, b.right() ) - b.seek_right( urow, b.hcenter() ); int lwidth = b.seek_left( lrow, b.right() ) - b.seek_right( lrow, b.hcenter() ); if( lrow - noise <= b.vcenter() || lwidth > uwidth + noise ) return 'G'; } } } return 0; } // Common feature: U-shaped top of character // int Features::test_HKMNUuvwYy( const Rectangle & charbox ) const { if( tp.minima( b.height() / 5 ) == 2 && tp.minima( b.height() / 4 ) == 2 && tp.minima( b.height() / 2 ) <= 3 && tp.isctip() ) { const int noise = ( std::min( b.height(), b.width() ) / 30 ) + 1; const int m5 = bp.minima( b.height() / 5 ); if( 2 * b.height() >= b.width() && b.height() >= 10 && ( m5 == 1 || ( m5 == 2 && Ocrad::similar( bp.iminimum(), bp.pos( 50 ), 10 ) ) ) ) { const int lg = lp.min( lp.pos( 90 ) ); if( lg > 1 && bp.isvpit() && tp.minima( b.height() / 2 ) == 2 && lp[lp.pos(75)] <= lg ) return 'v'; int hdiff; if( b.bottom_hook( &hdiff ) ) { if( std::abs( hdiff ) <= b.height() / 8 ) { if( segments_in_row( b.vpos( 30 ) ) >= 3 ) return 'v'; if( bp.isconvex() ) { if( 9 * wp[wp.pos(30)] > 10 * wp[wp.pos(50)] && 9 * wp[wp.pos(50)] > 10 * wp[wp.pos(70)] ) return 'v'; else return 'u'; } } if( hdiff > b.height() / 2 ) { if( bp.minima( b.height() / 2 ) == 1 ) return 'y'; else return 0; } } const int rg = rp.min( rp.pos( 90 ) ); const int lg2 = lp.max( lp.pos( 70 ), lp.pos( 90 ) ); const int rg2 = rp.max( rp.pos( 70 ), rp.pos( 90 ) ); const int lc = ( lg + ( 2 * ( lp.limit() - rg ) ) ) / 3; const int lc2 = ( lg2 + lp.limit() - rg2 ) / 2; if( bp.ispit() && 7 * tp.range() < 4 * b.height() ) { int row2 = b.top(); while( row2 < b.bottom() && segments_in_row( row2 ) != 2 ) ++row2; int row1 = row2 + 1; while( row1 < b.bottom() && segments_in_row( row1 ) != 1 ) ++row1; if( row1 < b.bottom() ) row1 += wp[row1-b.top()] / 4; if( row1 < b.bottom() && wp[row1-b.top()] < b.width() ) { const int w1 = wp[row1-b.top()]; int row0 = w1 * ( row1 - row2 ) / ( b.width() - w1 ) + row1; if( row0 < b.bottom() && 2 * wp[wp.pos(70)] < b.width() && ( Ocrad::similar( lg, rg, 20 ) || ( lg > 1 && lg < rg && lc >= lc2 && !rp.increasing() ) ) ) return 'Y'; } } if( b.escape_top( b.vpos( 60 ), b.hcenter() ) && !lp.istip() ) return 'u'; if( lg < rg + 1 && !lp.increasing( lp.pos( 50 ) ) && ( 2 * lg < rg || b.vpos( 90 ) >= charbox.bottom() ) && ( tp.minima( b.height()/2 ) == 1 || lp.imaximum() > b.height()/2 ) ) return 'y'; if( lg > 1 && bp.ispit() && tp.minima( b.height() / 3 ) == 2 ) return 'v'; if( lg <= 1 && 2 * ( b.width() - rg - lg ) < b.width() && rp.increasing() && tp.minima( b.height() / 2 ) == 2 ) return 'v'; return 0; } if( 2 * b.height() >= b.width() && b.height() >= 9 && bp.minima() == 2 && bp.isctip() ) { const int th = std::max( b.height() / 4, bp[bp.pos(50)] + noise ); if( bp.minima( th ) == 3 ) return 'M'; const int lg = lp[lp.pos(50)]; const int rg = rp[rp.pos(50)]; if( Ocrad::similar( lg, rg, 80, 2 ) && 4 * lg < b.width() && 4 * rg < b.width() ) { if( lg > 1 && rg > 1 && lp.increasing() && rp.increasing() && 5 * tp[tp.pos(50)] > b.height() ) return 'w'; if( hbars() == 1 && 5 * ( hbar(0).height() - 1 ) < b.height() && hbar(0).top() >= b.vpos( 30 ) && hbar(0).bottom() <= b.vpos( 60 ) && 10 * hbar(0).width() > 9 * wp[hbar(0).vcenter()-b.top()] && Ocrad::similar( col_segment( hbar(0).vcenter(), hbar(0).hcenter() ).size(), hbar(0).height(), 30, 2 ) ) { if( 9 * hbar(0).width() < 10 * wp[wp.pos(50)] ) return 'H'; return 0; } if( segments_in_row( b.vpos( 60 ) ) == 4 || segments_in_row( b.vpos( 70 ) ) == 4 ) { if( 2 * tp[tp.pos(50)] > b.height() ) return 'M'; return 'w'; } if( ( vbars() <= 2 || ( vbars() == 3 && b.height() >= b.width() ) ) && tp.minima( b.height() / 2 ) <= 2 && tp.minima( ( 2 * b.height() ) / 5 ) <= 2 && !lp.istpit() && 4 * std::abs( rp[rp.pos(20)] - rp[rp.pos(80)] ) <= b.width() ) { const int row = b.top() + tp[tp.pos(50)]; if( row > b.vcenter() ) { Rectangle r( b.left(), b.top(), b.hcenter(), b.bottom() ); Bitmap bm( b, r ); int hdiff; if( bm.bottom_hook( &hdiff ) && -2 * hdiff > bm.height() ) return 'u'; } if( row > b.vpos( 10 ) || vbars() >= 2 ) return 'N'; } return 0; } if( 3 * lg < 2 * rg && lg < b.width() / 4 && rg > b.width() / 4 && rp.isctip() && tp.minima( b.height() / 8 ) == 2 ) return 'K'; return 0; } if( bp.minima() <= 2 && 2 * b.width() > 5 * b.height() ) return '~'; if( bp.minima() == 3 && ( hbars() == 0 || ( hbars() == 1 && hbar(0).top() >= b.vpos( 20 ) ) ) ) return 'M'; } return 0; } // Looks for the nearest frontier in column hcenter(), then tests if // gap is open downwards (except for 'x') // int Features::test_hknwx( const Rectangle & charbox ) const { const int m8 = tp.minima( b.height() / 8 ); if( m8 == 2 && bp.minima( b.height() / 2 ) == 1 && ( ( lp.istip() && rp.istip() ) || ( lp.isconcave() && rp.isconcave() ) ) ) return 'x'; if( b.width() >= b.height() && tp.ispit() && ( b.bottom() < charbox.vcenter() || ( lp.decreasing() && rp.decreasing() ) ) ) return '^'; int col = 0, row = 0; for( int i = bp.pos( 40 ); i <= bp.pos( 60 ); ++i ) if( bp[i] > row ) { row = bp[i]; col = i; } row = b.bottom() - row + 1; col += b.left(); if( row > b.vpos( 90 ) || row <= b.top() ) return 0; // FIXME follow gap up { int c = col; col = b.seek_right( row, col ); if( col > c ) --col; row = b.seek_top( row, col ); } const int urow = b.seek_top( row - 1, col, false ); if( urow > b.vpos( 20 ) || 3 * tp[tp.pos(60)] > b.height() ) { const int m5 = tp.minima( b.height() / 5 ); if( ( m5 == 2 || m5 == 3 ) && tp.minima() >= 2 && rp[rp.pos(25)] <= b.width() / 4 && ( !lp.istpit() || rp.minima() == 1 ) ) return 'w'; if( m5 == 1 && m8 == 1 && 4 * tp.max( tp.pos(40), tp.pos(60) ) < 3 * b.height() ) { if( rp.isctip( 66 ) ) return 'k'; else return 'h'; } return 0; } if( Ocrad::similar( b.height(), b.width(), 40 ) && row > b.vcenter() && urow < b.vcenter() && tp.minima( b.height() / 5 ) == 2 && bp.minima( urow + 1 ) == 3 ) return 'w'; if( urow <= b.vpos( 20 ) && tp.minima( b.height() / 4 ) == 1 && Ocrad::similar( b.height(), b.width(), 40 ) && ( 8 * ( rp[rp.pos(50)] - 1 ) <= b.width() || tp[tp.pos(100)] > b.height() / 2 ) ) return 'n'; return 0; } // Looks for four black sections in column hcenter() ± 1, then tests if // upper gap is open to the right and lower gaps are open to the left // int Features::test_s_cedilla() const { int urow2 = 0, urow3 = 0, urow4 = 0, col, black_section = 0; for( col = b.hcenter() - 1; col <= b.hcenter() + 1; ++col ) { bool prev_black = false; for( int row = b.top(); row <= b.bottom(); ++row ) { bool black = b.get_bit( row, col ); if( black && !prev_black ) { if( ++black_section == 2 ) urow2 = row - 1; else if( black_section == 3 ) urow3 = row - 1; else if( black_section == 4 ) urow4 = row - 1; } prev_black = black; } if( black_section == 4 && urow2 < b.vpos( 50 ) && urow4 >= b.vpos( 70 ) ) break; black_section = 0; } if( black_section == 4 && b.escape_right( urow2, col ) && b.escape_left( urow3, col ) && b.escape_left( urow4, col ) ) return UCS::SSCEDI; return 0; } bool Features::test_comma() const { if( b.holes() || b.height() <= b.width() || b.height() > 3 * b.width() ) return false; if( b.width() >= 3 && b.height() >= 3 ) { int upper_area = 0; for( int row = b.top(); row < b.top() + b.width(); ++row ) for( int col = b.left(); col <= b.right(); ++col ) if( b.get_bit( row, col ) ) ++upper_area; if( upper_area < (b.width() - 2) * (b.width() - 2) ) return false; int count1 = 0, count2 = 0; for( int col = b.left(); col <= b.right(); ++col ) { if( b.get_bit( b.top() + 1, col ) ) ++count1; if( b.get_bit( b.bottom() - 1, col ) ) ++count2; } if( count1 <= count2 ) return false; } return true; } int Features::test_easy( const Rectangle & charbox ) const { int code = test_solid( charbox ); if( code ) return code; if( b.top() >= charbox.vcenter() && test_comma() ) return ','; if( b.bottom() <= charbox.vcenter() && b.height() > b.width() && bp.minima() == 1 ) { if( tp.iminimum() < tp.pos( 50 ) && bp.iminimum() > bp.pos( 50 ) ) return '`'; else return '\''; } if( 2 * b.height() > 3 * wp.max() && b.top() >= charbox.vcenter() && bp.minima() == 1 ) return ','; return 0; } // Recognizes single line, non-rectangular characters without holes. // '/<>\^` // int Features::test_line( const Rectangle & charbox ) const { int slope1, slope2; if( tp.minima() != 1 ) return 0; if( lp.minima() == 1 && rp.minima() == 1 && 2 * b.height() >= b.width() && lp.straight( &slope1 ) && rp.straight( &slope2 ) ) { if( slope1 < 0 && slope2 < 0 && bp.minima() == 2 ) return '^'; if( bp.minima() != 1 ) return 0; if( slope1 < 0 && slope2 > 0 ) { if( b.v_includes( charbox.vcenter() ) ) { if( 10 * b.area() < 3 * b.size() ) return '/'; if( b.height() > 2 * b.width() ) return 'l'; return 0; } if( b.top() >= charbox.vcenter() ) return ','; return '\''; } if( slope1 > 0 && slope2 < 0 ) { if( b.bottom() > charbox.vcenter() ) { if( ( 3 * b.width() > b.height() && b.height() > charbox.height() ) || 2 * b.width() >= b.height() ) return '\\'; else return 0; } return '`'; } return 0; } if( bp.minima() == 1 && 2 * b.width() >= b.height() && tp.straight( &slope1 ) && bp.straight( &slope2 ) ) { if( lp.minima() == 1 && rp.minima() == 1 ) { if( slope1 < 0 && slope2 > 0 ) { if( b.v_includes( charbox.vcenter() ) ) return '/'; if( b.top() >= charbox.vcenter() ) return ','; return '\''; } if( slope1 > 0 && slope2 < 0 ) { if( b.bottom() > charbox.vcenter() ) return '\\'; return '`'; } } else if( 2 * b.width() >= b.height() ) { if( slope1 < 0 && slope2 < 0 && lp.minima() == 1 && rp.minima() == 2 ) return '<'; if( slope1 > 0 && slope2 > 0 && lp.minima() == 2 && rp.minima() == 1 ) return '>'; } } return 0; } int Features::test_solid( const Rectangle & charbox ) const { if( b.holes() ) return 0; if( b.height() >= 5 && b.width() >= 5 ) { if( 2 * b.height() > b.width() && ( tp.minima() != 1 || bp.minima() != 1 ) ) return 0; if( b.height() < 2 * b.width() && ( lp.minima() != 1 || rp.minima() != 1 ) ) return 0; } int inner_area, inner_size, porosity = 0; if( b.width() >= 3 && b.height() >= 3 ) { inner_size = ( b.width() - 2 ) * ( b.height() - 2 ); inner_area = 0; for( int row = b.top() + 1; row < b.bottom(); ++row ) { int holes = 0; // FIXME for( int col = b.left() + 1; col < b.right(); ++col ) { if( b.get_bit( row, col ) ) ++inner_area; else ++holes; } if( 5 * holes >= b.width() ) porosity += ( 5 * holes ) / b.width(); } if( inner_area * 100 < inner_size * 70 ) return 0; } else { inner_size = 0; inner_area = b.area(); } if( Ocrad::similar( b.height(), wp.max(), 20, 2 ) ) { const int n = std::min( b.height(), b.width() ); if( n >= 6 ) { int d = 0; for( int i = 0; i < n; ++i ) { if( b.get_bit( b.top() + i, b.left() + i ) ) ++d; if( b.get_bit( b.top() + i, b.right() - i ) ) --d; } if( 2 * std::abs( d ) >= n - 1 ) return 0; } if( ( !porosity && inner_area * 100 >= inner_size * 75 ) || ( b.width() >= 7 && b.height() >= 7 && ( 100 * b.area_octagon() >= 95 * b.size_octagon() || 100 * b.area_octagon() >= 95 * b.area() ) ) ) return '.'; return 0; } if( porosity > 1 || inner_area * 100 < inner_size * 85 || ( porosity && inner_area * 100 < inner_size * 95 ) ) return 0; if( b.width() > b.height() ) { if( b.top() > charbox.vpos( 90 ) || ( charbox.bottom() - b.bottom() < b.top() - charbox.vcenter() && b.width() >= 5 * b.height() ) ) return '_'; return '-'; } if( b.height() > b.width() ) { if( b.top() > charbox.vcenter() ) return ','; if( b.bottom() <= charbox.vcenter() ) return '\''; return '|'; } return 0; } ocrad-0.22/feats_test1.cc0000644000076400001440000002056212160432342013632 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "segment.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "profile.h" #include "feats.h" // Tests if the lower half of character is open to the left, to the right, // and/or to the bottom // int Features::test_49ARegpq( const Rectangle & charbox ) const { const Bitmap & h = b.hole( 0 ); if( bp.minima( b.height() / 10 + 1 ) == 2 && bp.isctip() && tp.minima() == 1 ) { if( tp.isvpit() || rp.decreasing() ) return 'A'; else return 'R'; } int col = h.hcenter(); int row = b.seek_bottom( h.bottom(), col, false ) + 1; if( row >= b.vpos( 90 ) ) { col = h.left(); row = b.seek_bottom( h.bottom(), col, false ) + 1; } if( row >= b.bottom() ) return 0; if( b.escape_right( row, col ) ) { if( ( lp.ispit() && b.seek_bottom( row, h.right() ) < b.bottom() ) || ( lp.isconvex() && b.seek_bottom( row, h.hcenter() ) < b.bottom() ) ) return 'e'; if( bp.ispit() ) { int row2 = b.seek_bottom( row, h.right() ); if( row2 < b.vpos( 75 ) ) return 'g'; if( row2 < b.bottom() ) return 'e'; } return 'p'; } else if( b.escape_left( row, col ) ) { Profile hlp( h, Profile::left ); Profile htp( h, Profile::top ); Profile hwp( h, Profile::width ); if( vbars() == 1 && vbar(0).hcenter() > b.hcenter() && hlp.decreasing() && htp.decreasing() && hwp[hwp.pos(30)] < hwp[hwp.pos(70)] ) return '4'; if( rp.isconvex() && rp.ispit() && rp.minima() == 1 && tp.ispit() && charbox.bottom() > b.vpos( 80 ) ) return '9'; int hdiff; if( b.bottom_hook( &hdiff ) && hdiff > 0 ) { if( h.bottom() < b.vcenter() && h.right() + 2 <= b.right() && ( !b.get_bit( h.bottom() + 1, h.right() + 1 ) || !b.get_bit( h.bottom() + 1, h.right() + 2 ) || rp.isctip() ) ) return 's'; else return 'g'; } if( row > b.vpos( 85 ) && tp.ispit() ) return 'Q'; int row2 = b.seek_bottom( row, col ); if( row2 < b.bottom() && rp.increasing( ( ( row + row2 ) / 2 ) - b.top() ) ) return 'g'; if( bp.minima() == 1 ) { if( h.height() >= charbox.height() ) return 'Q'; if( h.right() < b.hcenter() && h.bottom() < b.vcenter() ) return '2'; return 'q'; } } return 0; } int Features::test_4ADQao( const Charset & charset, const Rectangle & charbox ) const { const Bitmap & h = b.hole( 0 ); int left_delta = h.left() - b.left(), right_delta = b.right() - h.right(); if( !lp.ispit() && lp.isflats() && rp.ispit() ) return 'D'; if( !rp.isconvex() ) { if( Ocrad::similar( left_delta, right_delta, 40 ) && tp.minima() == 2 && bp.minima() == 2 ) return '#'; if( tp.minima() == 1 && bp.minima() == 1 ) { int row = b.seek_bottom( h.bottom(), h.hcenter(), false ); if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) if( !lp.isconvex() && bp.isconvex() && b.seek_bottom( row, h.hcenter() ) < b.bottom() ) return UCS::SEACUTE; row = ( row + b.seek_bottom( row, h.hcenter() ) ) / 2; if( row < b.bottom() - 1 && !lp.isflats() && b.seek_left( row, h.hcenter() ) <= b.left() ) { if( wp[h.top()-b.top()] < wp[h.bottom()-b.top()] ) return '4'; return 'Q'; } } if( 2 * b.width() > 5 * h.width() ) { const int c = segments_in_row( h.vcenter() ); const int m = bp.minima(); if( c == 3 && h.top() < b.vcenter() && h.bottom() > b.vcenter() && 3 * h.height() >= b.height() && ( m == 3 || m == 2 ) && !lp.ispit() ) return 'm'; if( c == 3 && left_delta > right_delta && lp.ispit() && segments_in_col( h.hcenter() ) == 4 ) return '@'; if( c == 4 && Ocrad::similar( left_delta, right_delta, 40 ) && lp.ispit() ) return '@'; } if( tp.minima() == 1 && bp.istip() && !lp.isconvex() && !rp.isctip( 66 ) ) return 'A'; } if( Ocrad::similar( left_delta, right_delta, 50 ) ) { if( bp.minima() == 1 && rp.isconvex() && b.test_BD() ) return 'D'; if( bp.minima() > 1 || rp.minima() > 1 || b.test_Q() ) { if( 4 * h.size() >= b.size() || tp.ispit() || lp.ispit() ) return 'Q'; else return 0; } if( 3 * bp[bp.pos(100)] < b.height() && 5 * rp[rp.pos(55)] >= b.width() ) return 'a'; if( lp.istip() ) return 'n'; if( b.vpos( 80 ) < charbox.vcenter() ) return UCS::DEG; return 'o'; } if( left_delta > right_delta && rp.ispit() && tp.minima() == 1 && bp.minima() == 1 ) return 'D'; if( Ocrad::similar( left_delta, right_delta, 50 ) && ( bp.minima() > 1 || rp.minima() > 1 ) ) return 'a'; return 0; } // Tests if the upper half of character is open to the left, to the right, // and/or to the bottom // int Features::test_6abd( const Charset & charset ) const { const Bitmap & h = b.hole( 0 ); if( 3 * h.width() < b.width() && ( bp.minima( b.height() / 4 ) != 1 || tp.minima( h.vcenter() - b.top() ) != 1 ) ) return 0; int col = h.hcenter(); int row = b.seek_top( h.top(), col, false ) - 1; if( row <= b.top() ) { col = h.right(); if( b.right() - h.right() > h.width() ) ++col; row = b.seek_top( h.top(), col, false ) - 1; } if( row <= b.top() ) return 0; const int rcol = ( b.right() + h.right() ) / 2; const int urow = h.top() - ( b.bottom() - h.bottom() ); const bool oacute1 = ( ( b.seek_right( urow - 1, h.right() ) >= b.right() ) || ( b.seek_right( row, col ) >= b.right() ) ); if( b.escape_right( row, col ) ) { const int noise = ( b.width() / 30 ) + 1; const int c = lp[urow-b.top()]; const bool oacute2 = ( c > lp[h.top()-b.top()] + noise && urow <= b.top() + tp[std::min( c - 1, b.width() / 4 )] ); if( ( oacute1 && oacute2 ) && ( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) ) { const bool oacute3 = ( b.right() - rp[rp.pos(5)] >= h.right() || b.left() + lp[h.top()-b.top()] <= b.hpos( 5 ) ); if( oacute3 ) return UCS::SOACUTE; } if( !oacute2 && lp.ispit() && bp.ispit() ) { int row2 = b.seek_top( h.top(), h.right() + 1, false ) - 1; row2 = b.seek_top( row2, h.right() + 1 ); if( row2 > b.top() ) return '6'; } int row2 = b.seek_top( h.top(), rcol, false ) - 1; row2 = b.seek_top( row2, rcol ); if( row2 <= b.top() ) return 'b'; const int m = tp.minima( b.height() / 2 ); if( m == 1 ) return 's'; else if( m == 2 ) return 'k'; else return 0; } if( b.escape_left( row, col ) ) { const int col2 = std::max( h.left(), h.hpos( 10 ) ); int row2 = b.seek_top( h.top(), col2, false ) - 1; row2 = b.seek_top( row2, col2 ); if( row2 > b.top() ) { if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) { int row3 = b.seek_top( row, col ); if( row > b.vcenter() && row3 > b.vpos( 20 ) ) return UCS::SAACUTE; if( oacute1 ) return UCS::SOGRAVE; } return 'a'; } if( charset.enabled( Charset::iso_8859_15 ) || charset.enabled( Charset::iso_8859_9 ) ) if( oacute1 ) return UCS::SOACUTE; return 'd'; } if( b.width() > 3 * h.width() && h.top() < b.vcenter() && segments_in_row( b.vcenter() ) == 3 && !lp.isconvex() ) return 'm'; int hdiff; if( b.top_hook( &hdiff ) && hdiff > 0 ) return 's'; return 0; } ocrad-0.22/main.cc0000644000076400001440000003551012150123352012330 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /* Exit status: 0 for a normal exit, 1 for environmental problems (file not found, invalid flags, I/O errors, etc), 2 to indicate a corrupt or invalid input file, 3 for an internal consistency error (eg, bug) which caused ocrad to panic. */ #include #include #include #include #include #include #include #include #if defined(__MSVCRT__) || defined(__OS2__) || defined(_MSC_VER) #include #include #include #endif #include "arg_parser.h" #include "common.h" #include "rational.h" #include "rectangle.h" #include "page_image.h" #include "textpage.h" namespace { const char * const Program_name = "GNU Ocrad"; const char * const program_name = "ocrad"; const char * const program_year = "2013"; const char * invocation_name = 0; struct Input_control { Transformation transformation; int scale; Rational threshold, ltwh[4]; bool copy, cut, invert, layout; Input_control() : scale( 0 ), threshold( -1 ), copy( false ), cut( false ), invert( false ), layout( false ) {} bool parse_cut_rectangle( const char * const s ); bool parse_threshold( const char * const s ); }; void show_error( const char * const msg, const int errcode = 0, const bool help = false ) { if( verbosity >= 0 ) { if( msg && msg[0] ) { std::fprintf( stderr, "%s: %s", program_name, msg ); if( errcode > 0 ) std::fprintf( stderr, ": %s", std::strerror( errcode ) ); std::fprintf( stderr, "\n" ); } if( help ) std::fprintf( stderr, "Try '%s --help' for more information.\n", invocation_name ); } } bool Input_control::parse_cut_rectangle( const char * const s ) { int c = ltwh[0].parse( s ); // left if( c && s[c] == ',' && ltwh[0] >= -1 ) { int i = c + 1; c = ltwh[1].parse( &s[i] ); // top if( c && s[i+c] == ',' && ltwh[1] >= -1 ) { i += c + 1; c = ltwh[2].parse( &s[i] ); // width if( c && s[i+c] == ',' && ltwh[2] > 0 ) { i += c + 1; c = ltwh[3].parse( &s[i] ); // height if( c && ltwh[3] > 0 ) { cut = true; return true; } } } } show_error( "invalid cut rectangle.", 0, true ); return false; } bool Input_control::parse_threshold( const char * const s ) { Rational tmp; if( tmp.parse( s ) && tmp >= 0 && tmp <= 1 ) { threshold = tmp; return true; } show_error( "threshold out of limits (0.0 - 1.0).", 0, true ); return false; } void show_help() { std::printf( "GNU Ocrad is an OCR (Optical Character Recognition) program based on a\n" "feature extraction method. It reads images in pbm (bitmap), pgm\n" "(greyscale) or ppm (color) formats and produces text in byte (8-bit) or\n" "UTF-8 formats. The pbm, pgm and ppm formats are collectively known as pnm.\n" "\nOcrad includes a layout analyser able to separate the columns or blocks\n" "of text normally found on printed pages.\n" "\nUsage: %s [options] [files]\n", invocation_name ); std::printf( "\nOptions:\n" " -h, --help display this help and exit\n" " -V, --version output version information and exit\n" " -a, --append append text to output file\n" " -c, --charset= try '--charset=help' for a list of names\n" " -e, --filter= try '--filter=help' for a list of names\n" " -f, --force force overwrite of output file\n" " -F, --format= output format (byte, utf8)\n" " -i, --invert invert image levels (white on black)\n" " -l, --layout perform layout analysis\n" " -o, --output= place the output into \n" " -q, --quiet suppress all messages\n" " -s, --scale=[-] scale input image by [1/]\n" " -t, --transform= try '--transform=help' for a list of names\n" " -T, --threshold= threshold for binarization (0-100%%)\n" " -u, --cut= cut input image by given rectangle\n" " -v, --verbose be verbose\n" " -x, --export= export results in ORF format to \n" ); if( verbosity > 0 ) { std::printf( " -1..6 pnm output file type (debug)\n" " -C, --copy 'copy' input to output (debug)\n" " -D, --debug= (0-100) output intermediate data (debug)\n" ); } std::printf( "If no files are specified, ocrad reads the image from standard input.\n" "If the -o option is not specified, ocrad sends text to standard output.\n" "\nExit status: 0 for a normal exit, 1 for environmental problems (file\n" "not found, invalid flags, I/O errors, etc), 2 to indicate a corrupt or\n" "invalid input file, 3 for an internal consistency error (eg, bug) which\n" "caused ocrad to panic.\n" "\nReport bugs to bug-ocrad@gnu.org\n" "Ocrad home page: http://www.gnu.org/software/ocrad/ocrad.html\n" "General help using GNU software: http://www.gnu.org/gethelp\n" ); } void show_version() { std::printf( "%s %s\n", Program_name, PROGVERSION ); std::printf( "Copyright (C) %s Antonio Diaz Diaz.\n", program_year ); std::printf( "License GPLv3+: GNU GPL version 3 or later \n" "This is free software: you are free to change and redistribute it.\n" "There is NO WARRANTY, to the extent permitted by law.\n" ); } const char * my_basename( const char * filename ) { const char * c = filename; while( *c ) { if( *c == '/' ) { filename = c + 1; } ++c; } return filename; } int process_file( FILE * const infile, const char * const infile_name, const Input_control & input_control, const Control & control ) { if( verbosity > 0 ) std::fprintf( stderr, "processing file '%s'\n", infile_name ); try { Page_image page_image( infile, input_control.invert ); if( input_control.cut ) { if( page_image.cut( input_control.ltwh ) ) { if( verbosity > 0 ) std::fprintf( stderr, "file cut to %dw x %dh\n", page_image.width(), page_image.height() ); } else { if( verbosity > 0 ) std::fprintf( stderr, "file '%s' totally cut away\n", infile_name ); return 1; } } page_image.transform( input_control.transformation ); page_image.scale( input_control.scale ); page_image.threshold( input_control.threshold ); if( verbosity > 0 ) { const Rational th( page_image.threshold(), page_image.maxval() ); std::fprintf( stderr, "maxval = %d, threshold = %d (%s)\n", page_image.maxval(), page_image.threshold(), th.to_decimal( 1, -3 ).c_str() ); } if( input_control.copy ) { if( control.outfile ) page_image.save( control.outfile, control.filetype ); return 0; } Textpage textpage( page_image, my_basename( infile_name ), control, input_control.layout ); if( control.debug_level == 0 ) { if( control.outfile ) textpage.print( control ); if( control.exportfile ) textpage.xprint( control ); } } catch( Page_image::Error e ) { show_error( e.msg ); return 2; } if( verbosity > 0 ) std::fprintf( stderr, "\n" ); return 0; } } // end namespace // 'infile' contains the scanned image (in pnm format) to be converted // to text. // 'outfile' is the destination for the text version of the scanned // image. (or for a pnm file if debugging). // 'exportfile' is the Ocr Results File. // int main( const int argc, const char * const argv[] ) { Input_control input_control; Control control; const char * outfile_name = 0, * exportfile_name = 0; bool append = false, force = false; invocation_name = argv[0]; const Arg_parser::Option options[] = { { '1', 0, Arg_parser::no }, { '2', 0, Arg_parser::no }, { '3', 0, Arg_parser::no }, { '4', 0, Arg_parser::no }, { '5', 0, Arg_parser::no }, { '6', 0, Arg_parser::no }, { 'a', "append", Arg_parser::no }, { 'c', "charset", Arg_parser::yes }, { 'C', "copy", Arg_parser::no }, { 'D', "debug", Arg_parser::yes }, { 'e', "filter", Arg_parser::yes }, { 'f', "force", Arg_parser::no }, { 'F', "format", Arg_parser::yes }, { 'h', "help", Arg_parser::no }, { 'i', "invert", Arg_parser::no }, { 'l', "layout", Arg_parser::no }, { 'o', "output", Arg_parser::yes }, { 'q', "quiet", Arg_parser::no }, { 's', "scale", Arg_parser::yes }, { 't', "transform", Arg_parser::yes }, { 'T', "threshold", Arg_parser::yes }, { 'u', "cut", Arg_parser::yes }, { 'v', "verbose", Arg_parser::no }, { 'V', "version", Arg_parser::no }, { 'x', "export", Arg_parser::yes }, { 0 , 0, Arg_parser::no } }; const Arg_parser parser( argc, argv, options ); if( parser.error().size() ) // bad option { show_error( parser.error().c_str(), 0, true ); return 1; } int argind = 0; for( ; argind < parser.arguments(); ++argind ) { const int code = parser.code( argind ); if( !code ) break; // no more options const char * const arg = parser.argument( argind ).c_str(); switch( code ) { case '1': case '2': case '3': case '4': case '5': case '6': control.filetype = code; break; case 'a': append = true; break; case 'c': if( !control.charset.enable( arg ) ) { control.charset.show_error( program_name, arg ); return 1; } break; case 'C': input_control.copy = true; break; case 'D': control.debug_level = std::strtol( arg, 0, 0 ); break; case 'e': if( !control.filter.set( arg ) ) { control.filter.show_error( program_name, arg ); return 1; } break; case 'f': force = true; break; case 'F': if( !control.set_format( arg ) ) { show_error( "bad output format.", 0, true ); return 1; } break; case 'h': show_help(); return 0; case 'i': input_control.invert = true; break; case 'l': input_control.layout = true; break; case 'o': outfile_name = arg; break; case 'q': verbosity = -1; break; case 's': input_control.scale = std::strtol( arg, 0, 0 ); break; case 't': if( !input_control.transformation.set( arg ) ) { input_control.transformation.show_error( program_name, arg ); return 1; } break; case 'T': if( !input_control.parse_threshold( arg ) ) return 1; break; case 'u': if( !input_control.parse_cut_rectangle( arg ) ) return 1; break; case 'v': if( verbosity < 4 ) ++verbosity; break; case 'V': show_version(); return 0; case 'x': exportfile_name = arg; break; default : Ocrad::internal_error( "uncaught option" ); } } // end process options #if defined(__MSVCRT__) || defined(__OS2__) || defined(_MSC_VER) setmode( STDIN_FILENO, O_BINARY ); setmode( STDOUT_FILENO, O_BINARY ); #endif if( outfile_name && std::strcmp( outfile_name, "-" ) != 0 ) { if( append ) control.outfile = std::fopen( outfile_name, "a" ); else if( force ) control.outfile = std::fopen( outfile_name, "w" ); else if( ( control.outfile = std::fopen( outfile_name, "wx" ) ) == 0 ) { if( verbosity >= 0 ) std::fprintf( stderr, "Output file %s already exists.\n", outfile_name ); return 1; } if( !control.outfile ) { if( verbosity >= 0 ) std::fprintf( stderr, "Cannot open %s\n", outfile_name ); return 1; } } if( exportfile_name && control.debug_level == 0 && !input_control.copy ) { if( std::strcmp( exportfile_name, "-" ) == 0 ) { control.exportfile = stdout; if( !outfile_name ) control.outfile = 0; } else { control.exportfile = std::fopen( exportfile_name, "w" ); if( !control.exportfile ) { if( verbosity >= 0 ) std::fprintf( stderr, "Cannot open %s\n", exportfile_name ); return 1; } } std::fprintf( control.exportfile, "# Ocr Results File. Created by %s version %s\n", Program_name, PROGVERSION ); } // process any remaining command line arguments (input files) FILE * infile = (argind < parser.arguments()) ? 0 : stdin; const char *infile_name = "-"; int retval = 0; while( true ) { while( infile != stdin ) { if( infile ) std::fclose( infile ); if( argind >= parser.arguments() ) { infile = 0; break; } infile_name = parser.argument( argind++ ).c_str(); if( std::strcmp( infile_name, "-" ) == 0 ) infile = stdin; else infile = std::fopen( infile_name, "rb" ); if( infile ) break; if( verbosity >= 0 ) std::fprintf( stderr, "Cannot open %s\n", infile_name ); if( retval == 0 ) retval = 1; } if( !infile ) break; int tmp = process_file( infile, infile_name, input_control, control ); if( infile == stdin ) { if( tmp <= 1 ) { int ch; do ch = std::fgetc( infile ); while( std::isspace( ch ) ); std::ungetc( ch, infile ); } if( tmp > 1 || std::feof( infile ) || std::ferror( infile ) ) infile = 0; } if( tmp > retval ) retval = tmp; if( control.outfile ) std::fflush( control.outfile ); if( control.exportfile ) std::fflush( control.exportfile ); } if( control.outfile ) std::fclose( control.outfile ); if( control.exportfile ) std::fclose( control.exportfile ); return retval; } ocrad-0.22/mask.cc0000644000076400001440000000764112140443140012342 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include "rectangle.h" #include "segment.h" #include "mask.h" int Mask::left( const int row ) const { if( top() <= row && row <= bottom() && data[row-top()].valid() ) return data[row-top()].left; return -1; } int Mask::right( const int row ) const { if( top() <= row && row <= bottom() && data[row-top()].valid() ) return data[row-top()].right; return -1; } void Mask::top( const int t ) { if( t == top() ) return; if( t < top() ) data.insert( data.begin(), top() - t, Csegment() ); else data.erase( data.begin(), data.begin() + ( t - top() ) ); Rectangle::top( t ); } void Mask::bottom( const int b ) { if( b != bottom() ) { Rectangle::bottom( b ); data.resize( height() ); } } void Mask::add_mask( const Mask & m ) { if( m.top() < top() ) top( m.top() ); if( m.bottom() > bottom() ) bottom( m.bottom() ); for( int i = m.top(); i <= m.bottom(); ++i ) { Csegment & seg = data[i-top()]; seg.add_csegment( m.data[i-m.top()] ); if( seg.left < left() ) left( seg.left ); if( seg.right > right() ) right( seg.right ); } } void Mask::add_point( const int row, const int col ) { if( row < top() ) top( row ); else if( row > bottom() ) bottom( row ); data[row-top()].add_point( col ); if( col < left() ) left( col ); else if( col > right() ) right( col ); } void Mask::add_rectangle( const Rectangle & re ) { if( re.top() < top() ) top( re.top() ); if( re.bottom() > bottom() ) bottom( re.bottom() ); const Csegment rseg( re.left(), re.right() ); for( int i = re.top(); i <= re.bottom(); ++i ) { Csegment & seg = data[i-top()]; seg.add_csegment( rseg ); if( seg.left < left() ) left( seg.left ); if( seg.right > right() ) right( seg.right ); } } bool Mask::includes( const Rectangle & re ) const { if( re.top() < top() || re.bottom() > bottom() ) return false; const Csegment seg( re.left(), re.right() ); for( int i = re.top(); i <= re.bottom(); ++i ) if( !data[i-top()].includes( seg ) ) return false; return true; } bool Mask::includes( const int row, const int col ) const { return ( row >= top() && row <= bottom() && data[row-top()].includes( col ) ); } int Mask::distance( const Rectangle & re ) const { const Csegment seg( re.left(), re.right() ); int mindist = INT_MAX; for( int i = bottom(); i >= top(); --i ) { const int vd = re.v_distance( i ); if( vd >= mindist ) { if( i < re.top() ) break; else continue; } const int hd = data[i-top()].distance( seg ); if( hd >= mindist ) continue; const int d = Rectangle::hypoti( hd, vd ); if( d < mindist ) mindist = d; } return mindist; } int Mask::distance( const int row, const int col ) const { int mindist = INT_MAX; for( int i = bottom(); i >= top(); --i ) { const int vd = std::abs( i - row ); if( vd >= mindist ) { if( i < row ) break; else continue; } const int hd = data[i-top()].distance( col ); if( hd >= mindist ) continue; const int d = Rectangle::hypoti( hd, vd ); if( d < mindist ) mindist = d; } return mindist; } ocrad-0.22/ocradlib.cc0000644000076400001440000002164512150245250013171 0ustar yousers/* Ocradlib - Optical Character Recognition library Copyright (C) 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . As a special exception, you may use this file as part of a free software library without restriction. Specifically, if other files instantiate templates or use macros or inline functions from this file, or you compile this file and link it with other files to produce an executable, this file does not by itself cause the resulting executable to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the executable file might be covered by the GNU General Public License. */ #include #include #include #include #include #include #include "ocradlib.h" #include "common.h" #include "rectangle.h" #include "ucs.h" #include "track.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "page_image.h" #include "textline.h" #include "textblock.h" #include "textpage.h" struct OCRAD_Descriptor { Page_image * page_image; Textpage * textpage; OCRAD_Errno ocr_errno; Control control; std::string text; OCRAD_Descriptor() : page_image( 0 ), textpage( 0 ), ocr_errno( OCRAD_ok ) { control.outfile = 0; } }; bool verify_descriptor( OCRAD_Descriptor * const ocrdes, const bool result = false ) { if( !ocrdes ) return false; if( !ocrdes->page_image || ( result && !ocrdes->textpage ) ) { ocrdes->ocr_errno = OCRAD_sequence_error; return false; } return true; } const char * OCRAD_version() { return OCRAD_version_string; } OCRAD_Descriptor * OCRAD_open() { verbosity = -1; // keep library silent OCRAD_Descriptor * const ocrdes = new( std::nothrow ) OCRAD_Descriptor; if( !ocrdes ) return 0; return ocrdes; } int OCRAD_close( OCRAD_Descriptor * const ocrdes ) { if( !ocrdes ) return -1; if( ocrdes->textpage ) delete ocrdes->textpage; if( ocrdes->page_image ) delete ocrdes->page_image; delete ocrdes; return 0; } OCRAD_Errno OCRAD_get_errno( OCRAD_Descriptor * const ocrdes ) { if( !ocrdes ) return OCRAD_bad_argument; return ocrdes->ocr_errno; } int OCRAD_set_image( OCRAD_Descriptor * const ocrdes, const OCRAD_Pixmap * const image, const bool invert ) { if( !ocrdes ) return -1; if( !image || image->height < 3 || image->width < 3 || INT_MAX / image->width < image->height || ( image->mode != OCRAD_bitmap && image->mode != OCRAD_greymap && image->mode != OCRAD_colormap ) ) { ocrdes->ocr_errno = OCRAD_bad_argument; return -1; } try { Page_image * const page_image = new Page_image( *image, invert ); if( ocrdes->textpage ) { delete ocrdes->textpage; ocrdes->textpage = 0; } if( ocrdes->page_image ) delete ocrdes->page_image; ocrdes->page_image = page_image; } catch( std::bad_alloc ) { ocrdes->ocr_errno = OCRAD_mem_error; return -1; } return 0; } int OCRAD_set_image_from_file( OCRAD_Descriptor * const ocrdes, const char * const filename, const bool invert ) { if( !ocrdes ) return -1; FILE * infile = 0; if( filename && filename[0] ) { if( std::strcmp( filename, "-" ) == 0 ) infile = stdin; else infile = std::fopen( filename, "rb" ); } if( !infile ) { ocrdes->ocr_errno = OCRAD_bad_argument; return -1; } int retval = 0; try { Page_image * const page_image = new Page_image( infile, invert ); if( ocrdes->textpage ) { delete ocrdes->textpage; ocrdes->textpage = 0; } if( ocrdes->page_image ) delete ocrdes->page_image; ocrdes->page_image = page_image; } catch( std::bad_alloc ) { ocrdes->ocr_errno = OCRAD_mem_error; retval = -1; } catch( ... ) { ocrdes->ocr_errno = OCRAD_bad_argument; retval = -1; } std::fclose( infile ); return retval; } int OCRAD_set_utf8_format( OCRAD_Descriptor * const ocrdes, const bool utf8 ) { if( !verify_descriptor( ocrdes ) ) return -1; ocrdes->control.utf8 = utf8; return 0; } int OCRAD_set_threshold( OCRAD_Descriptor * const ocrdes, const int threshold ) { if( !verify_descriptor( ocrdes ) ) return -1; if( threshold < -1 || threshold > 255 ) { ocrdes->ocr_errno = OCRAD_bad_argument; return -1; } ocrdes->page_image->threshold( threshold ); return 0; } int OCRAD_scale( OCRAD_Descriptor * const ocrdes, const int value ) { if( !verify_descriptor( ocrdes ) ) return -1; int retval = 0; try { if( !ocrdes->page_image->scale( value ) ) retval = -1; } catch( ... ) { retval = -1; } if( retval < 0 ) ocrdes->ocr_errno = OCRAD_bad_argument; return retval; } int OCRAD_recognize( OCRAD_Descriptor * const ocrdes, const bool layout ) { if( !verify_descriptor( ocrdes ) ) return -1; Textpage * const textpage = new( std::nothrow ) Textpage( *ocrdes->page_image, "", ocrdes->control, layout ); if( !textpage ) { ocrdes->ocr_errno = OCRAD_mem_error; return -1; } if( ocrdes->textpage ) delete ocrdes->textpage; ocrdes->textpage = textpage; return 0; } int OCRAD_result_blocks( OCRAD_Descriptor * const ocrdes ) { if( !verify_descriptor( ocrdes, true ) ) return -1; return ocrdes->textpage->textblocks(); } int OCRAD_result_lines( OCRAD_Descriptor * const ocrdes, const int blocknum ) { if( !verify_descriptor( ocrdes, true ) ) return -1; if( blocknum < 0 || blocknum >= ocrdes->textpage->textblocks() ) { ocrdes->ocr_errno = OCRAD_bad_argument; return -1; } return ocrdes->textpage->textblock( blocknum ).textlines(); } int OCRAD_result_chars_total( OCRAD_Descriptor * const ocrdes ) { if( !verify_descriptor( ocrdes, true ) ) return -1; int c = 0; for( int b = 0; b < ocrdes->textpage->textblocks(); ++b ) for( int i = 0; i < ocrdes->textpage->textblock( b ).textlines(); ++i ) c += ocrdes->textpage->textblock( b ).textline( i ).characters(); return c; } int OCRAD_result_chars_block( OCRAD_Descriptor * const ocrdes, const int blocknum ) { if( !verify_descriptor( ocrdes, true ) ) return -1; if( blocknum < 0 || blocknum >= ocrdes->textpage->textblocks() ) { ocrdes->ocr_errno = OCRAD_bad_argument; return -1; } int c = 0; for( int i = 0; i < ocrdes->textpage->textblock( blocknum ).textlines(); ++i ) c += ocrdes->textpage->textblock( blocknum ).textline( i ).characters(); return c; } int OCRAD_result_chars_line( OCRAD_Descriptor * const ocrdes, const int blocknum, const int linenum ) { if( !verify_descriptor( ocrdes, true ) ) return -1; if( blocknum < 0 || blocknum >= ocrdes->textpage->textblocks() || linenum < 0 || linenum >= ocrdes->textpage->textblock( blocknum ).textlines() ) { ocrdes->ocr_errno = OCRAD_bad_argument; return -1; } return ocrdes->textpage->textblock( blocknum ).textline( linenum ).characters(); } const char * OCRAD_result_line( OCRAD_Descriptor * const ocrdes, const int blocknum, const int linenum ) { if( !verify_descriptor( ocrdes, true ) ) return 0; if( blocknum < 0 || blocknum >= ocrdes->textpage->textblocks() || linenum < 0 || linenum >= ocrdes->textpage->textblock( blocknum ).textlines() ) { ocrdes->ocr_errno = OCRAD_bad_argument; return 0; } const Textline & textline = ocrdes->textpage->textblock( blocknum ).textline( linenum ); ocrdes->text.clear(); if( !ocrdes->control.utf8 ) for( int i = 0; i < textline.characters(); ++i ) ocrdes->text += textline.character( i ).byte_result(); else for( int i = 0; i < textline.characters(); ++i ) ocrdes->text += textline.character( i ).utf8_result(); ocrdes->text += '\n'; return ocrdes->text.c_str(); } int OCRAD_result_first_character( OCRAD_Descriptor * const ocrdes ) { if( !verify_descriptor( ocrdes, true ) ) return -1; int ch = 0; if( ocrdes->textpage->textblocks() > 0 && ocrdes->textpage->textblock( 0 ).textlines() > 0 ) { const Character & character = ocrdes->textpage->textblock( 0 ).textline( 0 ).character( 0 ); if( character.guesses() ) { if( !ocrdes->control.utf8 ) ch = UCS::map_to_byte( character.guess( 0 ).code ); else ch = character.guess( 0 ).code; } } return ch; } ocrad-0.22/ocrcheck.cc0000644000076400001440000000664712150241427013202 0ustar yousers/* Ocrcheck - A test program for the ocradlib library Copyright (C) 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you have unlimited permission to copy, distribute and modify it. Usage is: ocrcheck filename.pnm or ocrcheck filename.pnm --utf8 This program reads the specified image file, feeds it to the OCR engine and sends the resulting text to stdout. */ #include #include #include #include #include #include "ocradlib.h" int main( const int argc, const char * const argv[] ) { const bool utf8 = ( argc > 2 ); if( argc < 2 ) { std::fprintf( stderr, "Usage: ocrcheck filename.pnm\n" ); return 1; } if( OCRAD_version()[0] != OCRAD_version_string[0] ) { std::fprintf( stderr, "bad library version" ); return 3; } if( std::strcmp( PROGVERSION, OCRAD_version_string ) ) { std::fprintf( stderr, "bad library version_string" ); return 3; } OCRAD_Descriptor * const ocrdes = OCRAD_open(); if( !ocrdes || OCRAD_get_errno( ocrdes ) != OCRAD_ok ) { OCRAD_close( ocrdes ); std::fprintf( stderr, "not enough memory.\n" ); return 1; } if( OCRAD_set_image_from_file( ocrdes, argv[1], false ) < 0 ) { const OCRAD_Errno ocr_errno = OCRAD_get_errno( ocrdes ); OCRAD_close( ocrdes ); if( ocr_errno == OCRAD_mem_error ) std::fprintf( stderr, "not enough memory.\n" ); else std::fprintf( stderr, "Can't open file '%s' for reading\n", argv[1] ); return 1; } // std::fprintf( stderr, "ocrcheck: testing file '%s'\n", argv[1] ); if( ( utf8 && OCRAD_set_utf8_format( ocrdes, true ) < 0 ) || OCRAD_set_threshold( ocrdes, -1 ) < 0 || // auto threshold OCRAD_recognize( ocrdes, false ) < 0 ) // no layout { const OCRAD_Errno ocr_errno = OCRAD_get_errno( ocrdes ); OCRAD_close( ocrdes ); if( ocr_errno == OCRAD_mem_error ) { std::fprintf( stderr, "not enough memory.\n" ); return 1; } std::fprintf( stderr, "internal error: invalid argument.\n" ); return 3; } const int blocks = OCRAD_result_blocks( ocrdes ); int chars_total_by_block = 0; int chars_total_by_line = 0; int chars_total_by_count = 0; for( int b = 0; b < blocks; ++b ) { const int lines = OCRAD_result_lines( ocrdes, b ); chars_total_by_block += OCRAD_result_chars_block( ocrdes, b ); for( int l = 0; l < lines; ++l ) { const char * const s = OCRAD_result_line( ocrdes, b, l ); chars_total_by_line += OCRAD_result_chars_line( ocrdes, b, l ); if( s && s[0] ) { std::printf( "%s", s ); const int len = std::strlen( s ) - 1; if( !utf8 ) chars_total_by_count += len; else for( int i = 0; i < len; ++i ) if( (uint8_t)s[i] < 128 || (uint8_t)s[i] >= 0xC0 ) ++chars_total_by_count; } } std::printf( "\n" ); } const int chars_total = OCRAD_result_chars_total( ocrdes ); if( chars_total_by_block != chars_total || chars_total_by_line != chars_total || chars_total_by_count != chars_total ) { std::fprintf( stderr, "library_error: character counts differ.\n" "%d %d %d %d\n", chars_total, chars_total_by_block, chars_total_by_line, chars_total_by_count ); return 1; } OCRAD_close( ocrdes ); return 0; } ocrad-0.22/page_image.cc0000644000076400001440000004742012147703113013472 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include #include #include "ocradlib.h" #include "common.h" #include "rational.h" #include "rectangle.h" #include "segment.h" #include "mask.h" #include "track.h" #include "page_image.h" namespace { // binarization by Otsu's method based on maximization of inter-class variance // int otsu_th( const std::vector< std::vector< uint8_t > > & data, const Rectangle & re, const int maxval ) { if( maxval == 1 ) return 0; std::vector< int > hist( maxval + 1, 0 ); // histogram of image data for( int row = re.top(); row <= re.bottom(); ++row ) for( int col = re.left(); col <= re.right(); ++col ) ++hist[data[row][col]]; std::vector< int > chist; // cumulative histogram chist.reserve( maxval + 1 ); chist.push_back( hist[0] ); std::vector< long long > cmom; // cumulative moment cmom.reserve( maxval + 1 ); cmom.push_back( 0 ); // 0 times hist[0] equals zero for( int i = 1; i <= maxval; ++i ) { chist.push_back( chist[i-1] + hist[i] ); cmom.push_back( cmom[i-1] + ( i * hist[i] ) ); } const double cmom_max = cmom[maxval]; double bvar_max = 0; int threshold = 0; // threshold for binarization for( int i = 0; i < maxval; ++i ) if( chist[i] > 0 && chist[i] < re.size() ) { double bvar = (double)cmom[i] / chist[i]; bvar -= ( cmom_max - cmom[i] ) / ( re.size() - chist[i] ); bvar *= bvar; bvar *= chist[i]; bvar *= ( re.size() - chist[i] ); if( bvar > bvar_max ) { bvar_max = bvar; threshold = i; } } return threshold; } int absolute_pos( Rational pos, const int left, const int right ) { int a; if( pos >= 0 ) { if( pos <= 1 ) a = left + ( pos * ( right - left ) ).trunc(); else a = left + pos.round(); } else { pos = -pos; if( pos <= 1 ) a = right - ( pos * ( right - left ) ).trunc(); else a = right - pos.round(); } return a; } void convol_23( std::vector< std::vector< uint8_t > > & data, const int scale ) { const int height = data.size(); const int width = data[0].size(); if( height < 3 || width < 3 ) return; std::vector< std::vector< uint8_t > > new_data( height ); new_data[0] = data[0]; // copy first row for( int row = 1; row < height - 1; ++row ) new_data[row].reserve( width ); new_data[height-1] = data[height-1]; // copy last row for( int row = 1; row < height - 1; ++row ) { const std::vector< uint8_t > & datarow1 = data[row-1]; const std::vector< uint8_t > & datarow2 = data[row]; const std::vector< uint8_t > & datarow3 = data[row+1]; std::vector< uint8_t > & new_datarow = new_data[row]; new_datarow.push_back( datarow2[0] ); // copy first col if( scale < 3 ) for( int col = 1; col < width - 1; ++col ) { int sum = datarow1[col-1] + datarow1[col] + datarow1[col+1] + datarow2[col-1] + 2 * datarow2[col] + datarow2[col+1] + datarow3[col-1] + datarow3[col] + datarow3[col+1]; new_datarow.push_back( ( sum + 5 ) / 10 ); } else for( int col = 1; col < width - 1; ++col ) { int sum = datarow1[col-1] + datarow1[col] + datarow1[col+1] + datarow2[col-1] + datarow2[col] + datarow2[col+1] + datarow3[col-1] + datarow3[col] + datarow3[col+1]; new_datarow.push_back( ( 2 * sum + 9 ) / 18 ); } new_datarow.push_back( datarow2[width-1] ); // copy last col } data.swap( new_data ); } void convol_n( std::vector< std::vector< uint8_t > > & data, const int scale ) { const int radius = scale / 2; // this is really radius - 0.5 const int min_size = 2 * radius + 1; const int area = min_size * min_size; const int height = data.size(); const int width = data[0].size(); if( radius < 1 || height < min_size || width < min_size ) return; std::vector< std::vector< uint8_t > > new_data( height ); for( int row = 0; row < radius; ++row ) new_data[row] = data[row]; // copy first rows for( int row = radius; row < height - radius; ++row ) new_data[row].reserve( width ); for( int row = height - radius; row < height; ++row ) new_data[row] = data[row]; // copy last rows for( int row = radius; row < height - radius; ++row ) { const std::vector< uint8_t > & datarow = data[row]; std::vector< uint8_t > & new_datarow = new_data[row]; for( int col = 0; col < radius; ++col ) new_datarow.push_back( datarow[col] ); // copy first cols for( int col = radius; col < width - radius; ++col ) { int sum = 0; for( int r = -radius; r < radius; ++r ) for( int c = -radius; c < radius; ++c ) sum += data[row+r][col+c]; new_datarow.push_back( ( 2 * sum + area ) / ( 2 * area ) ); } for( int col = width - radius; col < width; ++col ) new_datarow.push_back( datarow[col] ); // copy last cols } data.swap( new_data ); } void enlarge_2b( std::vector< std::vector< uint8_t > > & data ) { const int height = data.size(); const int width = data[0].size(); std::vector< std::vector< uint8_t > > new_data( 2 * height ); for( unsigned row = 0; row < new_data.size(); ++row ) new_data[row].resize( 2 * width, 1 ); for( int row = 0; row < height; ++row ) { const std::vector< uint8_t > & datarow = data[row]; std::vector< uint8_t > & new_datarow0 = new_data[2*row]; std::vector< uint8_t > & new_datarow1 = new_data[2*row+1]; for( int col = 0; col < width; ++col ) { if( datarow[col] == 0 ) { const bool l = col > 0 && datarow[col-1] == 0; const bool t = row > 0 && data[row-1][col] == 0; const bool r = col < width - 1 && datarow[col+1] == 0; const bool b = row < height - 1 && data[row+1][col] == 0; const bool lt = row > 0 && col > 0 && data[row-1][col-1] == 0; const bool rt = row > 0 && col < width - 1 && data[row-1][col+1] == 0; const bool lb = row < height - 1 && col > 0 && data[row+1][col-1] == 0; const bool rb = row < height - 1 && col < width - 1 && data[row+1][col+1] == 0; if( l || t || lt || ( !rt && !lb ) ) new_datarow0[2*col] = 0; if( r || t || rt || ( !lt && !rb ) ) new_datarow0[2*col+1] = 0; if( l || b || lb || ( !lt && !rb ) ) new_datarow1[2*col] = 0; if( r || b || rb || ( !rt && !lb ) ) new_datarow1[2*col+1] = 0; } } } data.swap( new_data ); } void enlarge_3b( std::vector< std::vector< uint8_t > > & data ) { const int height = data.size(); const int width = data[0].size(); std::vector< std::vector< uint8_t > > new_data( 3 * height ); for( unsigned row = 0; row < new_data.size(); ++row ) new_data[row].resize( 3 * width, 1 ); for( int row = 0; row < height; ++row ) { const int row3 = 3 * row; const std::vector< uint8_t > & datarow = data[row]; std::vector< uint8_t > & new_datarow0 = new_data[row3]; std::vector< uint8_t > & new_datarow1 = new_data[row3+1]; std::vector< uint8_t > & new_datarow2 = new_data[row3+2]; for( int col = 0; col < width; ++col ) { const int col3 = 3 * col; const bool l = col > 0 && datarow[col-1] == 0; const bool t = row > 0 && data[row-1][col] == 0; const bool r = col < width - 1 && datarow[col+1] == 0; const bool b = row < height - 1 && data[row+1][col] == 0; const bool lt = row > 0 && col > 0 && data[row-1][col-1] == 0; const bool rt = row > 0 && col < width - 1 && data[row-1][col+1] == 0; const bool lb = row < height - 1 && col > 0 && data[row+1][col-1] == 0; const bool rb = row < height - 1 && col < width - 1 && data[row+1][col+1] == 0; if( datarow[col] == 0 ) { if( l || t || lt || ( !rt && !lb ) ) new_datarow0[col3] = 0; new_datarow0[col3+1] = 0; if( r || t || rt || ( !lt && !rb ) ) new_datarow0[col3+2] = 0; new_datarow1[col3] = new_datarow1[col3+1] = new_datarow1[col3+2] = 0; if( l || b || lb || ( !lt && !rb ) ) new_datarow2[col3] = 0; new_datarow2[col3+1] = 0; if( r || b || rb || ( !rt && !lb ) ) new_datarow2[col3+2] = 0; } else { if( l && t && lt && ( !rt || !lb ) ) new_datarow0[col3] = 0; if( r && t && rt && ( !lt || !rb ) ) new_datarow0[col3+2] = 0; if( l && b && lb && ( !lt || !rb ) ) new_datarow2[col3] = 0; if( r && b && rb && ( !rt || !lb ) ) new_datarow2[col3+2] = 0; } } } data.swap( new_data ); } void enlarge_n( std::vector< std::vector< uint8_t > > & data, const int n ) { if( n < 2 ) return; const int height = data.size(); const int width = data[0].size(); std::vector< std::vector< uint8_t > > new_data; new_data.reserve( n * height ); for( int row = 0; row < height; ++row ) { const std::vector< uint8_t > & datarow = data[row]; new_data.push_back( std::vector< uint8_t >() ); for( int col = 0; col < width; ++col ) { const uint8_t d = datarow[col]; for( int i = 0; i < n; ++i ) new_data.back().push_back( d ); } for( int i = 1; i < n; ++i ) new_data.push_back( new_data.back() ); } data.swap( new_data ); } void mirror_left_right( std::vector< std::vector< uint8_t > > & data ) { const int height = data.size(); for( int row = 0; row < height; ++row ) std::reverse( data[row].begin(), data[row].end() ); } void mirror_top_bottom( std::vector< std::vector< uint8_t > > & data ) { for( int u = 0, d = data.size() - 1; u < d; ++u, --d ) data[u].swap( data[d] ); } void mirror_diagonal( std::vector< std::vector< uint8_t > > & data, Rectangle & re ) { const int size = std::max( re.height(), re.width() ); if( re.height() < size ) { data.resize( size ); for( int row = re.height(); row < size; ++row ) data[row].resize( size ); } else if( re.width() < size ) for( int row = 0; row < re.height(); ++row ) data[row].resize( size ); for( int row = 0; row < size; ++row ) { std::vector< uint8_t > & datarow = data[row]; for( int col = 0; col < row; ++col ) { uint8_t tmp = datarow[col]; datarow[col] = data[col][row]; data[col][row] = tmp; } } const int h = re.height(), w = re.width(); re.height( w ); re.width( h ); if( re.height() < size ) data.resize( re.height() ); else if( re.width() < size ) for( int row = 0; row < re.height(); ++row ) data[row].resize( re.width() ); } } // end namespace // Creates a Page_image from a OCRAD_Pixmap // Page_image::Page_image( const OCRAD_Pixmap & image, const bool invert ) : Rectangle( 0, 0, image.width - 1, image.height - 1 ) { data.resize( height() ); for( unsigned row = 0; row < data.size(); ++row ) data[row].reserve( width() ); const int rows = height(), cols = width(); switch( image.mode ) { case OCRAD_bitmap: { maxval_ = 1; threshold_ = 0; if( !invert ) for( int i = 0, row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col, ++i ) data[row].push_back( image.data[i] ? 0 : 1 ); else for( int i = 0, row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col, ++i ) data[row].push_back( image.data[i] ? 1 : 0 ); } break; case OCRAD_greymap: { maxval_ = 255; threshold_ = 127; if( !invert ) for( int i = 0, row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col, ++i ) data[row].push_back( image.data[i] ); else for( int i = 0, row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col, ++i ) data[row].push_back( maxval_ - image.data[i] ); } break; case OCRAD_colormap: { maxval_ = 255; threshold_ = 127; for( int i = 0, row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col, i += 3 ) { const uint8_t r = image.data[i]; // Red value const uint8_t g = image.data[i+1]; // Green value const uint8_t b = image.data[i+2]; // Blue value uint8_t val; if( !invert ) val = std::min( r, std::min( g, b ) ); else val = maxval_ - std::max( r, std::max( g, b ) ); data[row].push_back( val ); } } break; } } // Creates a reduced Page_image // Page_image::Page_image( const Page_image & source, const int scale ) : Rectangle( source ), maxval_( source.maxval_ ), threshold_( source.threshold_ ) { if( scale < 2 || scale > source.width() || scale > source.height() ) Ocrad::internal_error( "bad parameter building a reduced Page_image" ); const int scale2 = scale * scale; Rectangle::height( source.height() / scale ); Rectangle::width( source.width() / scale ); data.resize( height() ); for( int row = 0; row < height(); ++row ) { const int srow = ( row * scale ) + scale; data[row].reserve( width() ); std::vector< uint8_t > & datarow = data[row]; for( int col = 0; col < width(); ++col ) { const int scol = ( col * scale ) + scale; int sum = 0; for( int i = srow - scale; i < srow; ++i ) { const std::vector< uint8_t > & sdatarow = source.data[i]; for( int j = scol - scale; j < scol; ++j ) sum += sdatarow[j]; } datarow.push_back( sum / scale2 ); } } } void Page_image::threshold( const Rational & th ) { if( th >= 0 && th <= 1 ) threshold_ = ( th * maxval_ ).trunc(); else threshold_ = otsu_th( data, *this, maxval_ ); } void Page_image::threshold( const int th ) { if( th >= 0 && th <= 255 ) threshold_ = ( th * maxval_ ) / 255; else threshold_ = otsu_th( data, *this, maxval_ ); } bool Page_image::cut( const Rational ltwh[4] ) { Rectangle re = *this; const int l = absolute_pos( ltwh[0], left(), right() ); if( l > re.left() ) { if( l < re.right() ) re.left( l ); else return false; } const int t = absolute_pos( ltwh[1], top(), bottom() ); if( t > re.top() ) { if( t < re.bottom() ) re.top( t ); else return false; } const int r = l + absolute_pos( ltwh[2], left(), right() ) - 1; if( r < re.right() ) { if( r > re.left() ) re.right( r ); else return false; } const int b = t + absolute_pos( ltwh[3], top(), bottom() ) - 1; if( b < re.bottom() ) { if( b > re.top() ) re.bottom( b ); else return false; } if( re.width() < 3 || re.height() < 3 ) return false; // cutting is performed here if( re.bottom() < bottom() ) data.resize( re.bottom() - top() + 1 ); if( re.right() < right() ) { const int w = re.right() - left() + 1; for( int row = data.size() - 1; row >= 0 ; --row ) data[row].resize( w ); } if( re.top() > top() ) data.erase( data.begin(), data.begin() + ( re.top() - top() ) ); if( re.left() > left() ) { const int d = re.left() - left(); for( int row = data.size() - 1; row >= 0 ; --row ) data[row].erase( data[row].begin(), data[row].begin() + d ); } Rectangle::left( 0 ); Rectangle::top( 0 ); Rectangle::right( data[0].size() - 1 ); Rectangle::bottom( data.size() - 1 ); return true; } void Page_image::draw_mask( const Mask & m ) { const int t = std::max( top(), m.top() ); const int b = std::min( bottom(), m.bottom() ); if( t == m.top() && m.left( t ) >= 0 && m.right( t ) >= 0 ) for( int col = m.left( t ); col <= m.right( t ); ++col ) set_bit( t, col, true ); if( b == m.bottom() && m.left( b ) >= 0 && m.right( b ) >= 0 ) for( int col = m.left( b ); col <= m.right( b ); ++col ) set_bit( b, col, true ); int lprev = m.left( t ); int rprev = m.right( t ); for( int row = t + 1; row <= b; ++row ) { int lnew = m.left( row ), rnew = m.right( row ); if( lnew < 0 ) lnew = lprev; if( rnew < 0 ) rnew = rprev; if( lprev >= 0 && lnew >= 0 ) { int c1 = std::max( left(), std::min( lprev, lnew ) ); int c2 = std::min( right(), std::max( lprev, lnew ) ); for( int col = c1; col <= c2; ++col ) set_bit( row, col, true ); } if( rprev >= 0 && rnew >= 0 ) { int c1 = std::max( left(), std::min( rprev, rnew ) ); int c2 = std::min( right(), std::max( rprev, rnew ) ); for( int col = c1; col <= c2; ++col ) set_bit( row, col, true ); } lprev = lnew; rprev = rnew; } } void Page_image::draw_rectangle( const Rectangle & re ) { const int l = std::max( left(), re.left() ); const int t = std::max( top(), re.top() ); const int r = std::min( right(), re.right() ); const int b = std::min( bottom(), re.bottom() ); if( l == re.left() ) for( int row = t; row <= b; ++row ) set_bit( row, l, true ); if( t == re.top() ) for( int col = l; col <= r; ++col ) set_bit( t, col, true ); if( r == re.right() ) for( int row = t; row <= b; ++row ) set_bit( row, r, true ); if( b == re.bottom() ) for( int col = l; col <= r; ++col ) set_bit( b, col, true ); } void Page_image::draw_track( const Track & tr ) { int l = std::max( left(), tr.left() ); int r = std::min( right(), tr.right() ); if( l == tr.left() ) for( int row = tr.top( l ); row <= tr.bottom( l ); ++row ) if( row >= top() && row <= bottom() ) set_bit( row, l, true ); if( r == tr.right() ) for( int row = tr.top( r ); row <= tr.bottom( r ); ++row ) if( row >= top() && row <= bottom() ) set_bit( row, r, true ); for( int col = l; col <= r; ++col ) { int row = tr.top( col ); if( row >= top() && row <= bottom() ) set_bit( row, col, true ); row = tr.bottom( col ); if( row >= top() && row <= bottom() ) set_bit( row, col, true ); } } bool Page_image::scale( int n ) { if( n <= -2 ) { Page_image reduced( *this, -n ); *this = reduced; return true; } if( n >= 2 ) { if( INT_MAX / n < width() * height() ) throw Error( "scale factor too big. 'int' will overflow." ); if( maxval_ == 1 ) { if( n && ( n % 2 ) == 0 ) { enlarge_2b( data ); n /= 2; } else if( n && ( n % 3 ) == 0 ) { enlarge_3b( data ); n /= 3; } } if( n >= 2 ) { enlarge_n( data, n ); if( maxval_ > 1 ) { if( n <= 3 ) convol_23( data, n ); else convol_n( data, n ); } } Rectangle::height( data.size() ); Rectangle::width( data[0].size() ); return true; } return false; } void Page_image::transform( const Transformation & t ) { switch( t.type() ) { case Transformation::none: break; case Transformation::rotate90: mirror_diagonal( data, *this ); mirror_top_bottom( data ); break; case Transformation::rotate180: mirror_left_right( data ); mirror_top_bottom( data ); break; case Transformation::rotate270: mirror_diagonal( data, *this ); mirror_left_right( data ); break; case Transformation::mirror_lr: mirror_left_right( data ); break; case Transformation::mirror_tb: mirror_top_bottom( data ); break; case Transformation::mirror_d1: mirror_diagonal( data, *this ); break; case Transformation::mirror_d2: mirror_diagonal( data, *this ); mirror_left_right( data ); mirror_top_bottom( data ); break; } } ocrad-0.22/page_image_io.cc0000644000076400001440000002355412123647723014173 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include #include #include "common.h" #include "rational.h" #include "rectangle.h" #include "page_image.h" namespace { uint8_t pnm_getrawbyte( FILE * const f ) { int ch = std::fgetc( f ); if( ch == EOF ) throw Page_image::Error( "end-of-file reading pnm file." ); return ch; } uint8_t pnm_getc( FILE * const f ) { uint8_t ch; bool comment = false; do { ch = pnm_getrawbyte( f ); if( ch == '#' ) comment = true; else if( ch == '\n' ) comment = false; } while( comment ); return ch; } int pnm_getint( FILE * const f ) { uint8_t ch; int i = 0; do ch = pnm_getc( f ); while( std::isspace( ch ) ); if( !std::isdigit( ch ) ) throw Page_image::Error( "junk in pnm file where an integer should be." ); do { if( ( INT_MAX - (ch - '0') ) / 10 < i ) throw Page_image::Error( "number too big in pnm file." ); i = (i * 10) + (ch - '0'); ch = pnm_getc( f ); } while( std::isdigit( ch ) ); return i; } uint8_t pbm_getbit( FILE * const f ) { uint8_t ch; do ch = pnm_getc( f ); while( std::isspace( ch ) ); if( ch == '0' ) return 0; if( ch == '1' ) return 1; throw Page_image::Error( "junk in pbm file where bits should be." ); } } // end namespace void Page_image::read_p1( FILE * const f, const bool invert ) { maxval_ = 1; threshold_ = 0; const int rows = height(), cols = width(); if( !invert ) for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col ) data[row].push_back( 1 - pbm_getbit( f ) ); else for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col ) data[row].push_back( pbm_getbit( f ) ); } void Page_image::read_p4( FILE * const f, const bool invert ) { maxval_ = 1; threshold_ = 0; const int rows = height(), cols = width(); if( !invert ) for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ) { uint8_t byte = pnm_getrawbyte( f ); for( uint8_t mask = 0x80; mask > 0 && col < cols; mask >>= 1, ++col ) data[row].push_back( ( byte & mask ) ? 0 : 1 ); } else for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ) { uint8_t byte = pnm_getrawbyte( f ); for( uint8_t mask = 0x80; mask > 0 && col < cols; mask >>= 1, ++col ) data[row].push_back( ( byte & mask ) ? 1 : 0 ); } } void Page_image::read_p2( FILE * const f, const bool invert ) { const int maxval = pnm_getint( f ); if( maxval == 0 ) throw Page_image::Error( "zero maxval in pgm file." ); maxval_ = std::min( maxval, 255 ); threshold_ = maxval_ / 2; const int rows = height(), cols = width(); for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col ) { int val = pnm_getint( f ); if( val > maxval ) throw Page_image::Error( "value > maxval in pgm file." ); if( invert ) val = maxval - val; if( maxval > 255 ) { val *= 255; val /= maxval; } data[row].push_back( val ); } } void Page_image::read_p5( FILE * const f, const bool invert ) { const int maxval = pnm_getint( f ); if( maxval == 0 ) throw Page_image::Error( "zero maxval in pgm file." ); if( maxval > 255 ) throw Page_image::Error( "maxval > 255 in pgm \"P5\" file." ); maxval_ = maxval; threshold_ = maxval_ / 2; const int rows = height(), cols = width(); for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col ) { uint8_t val = pnm_getrawbyte( f ); if( val > maxval_ ) throw Page_image::Error( "value > maxval in pgm file." ); if( invert ) val = maxval_ - val; data[row].push_back( val ); } } void Page_image::read_p3( FILE * const f, const bool invert ) { const int maxval = pnm_getint( f ); if( maxval == 0 ) throw Page_image::Error( "zero maxval in ppm file." ); maxval_ = std::min( maxval, 255 ); threshold_ = maxval_ / 2; const int rows = height(), cols = width(); for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col ) { const int r = pnm_getint( f ); // Red value const int g = pnm_getint( f ); // Green value const int b = pnm_getint( f ); // Blue value if( r > maxval || g > maxval || b > maxval ) throw Page_image::Error( "value > maxval in ppm file." ); int val; if( !invert ) val = std::min( r, std::min( g, b ) ); else val = maxval - std::max( r, std::max( g, b ) ); if( maxval > 255 ) { val *= 255; val /= maxval; } data[row].push_back( val ); } } void Page_image::read_p6( FILE * const f, const bool invert ) { const int maxval = pnm_getint( f ); if( maxval == 0 ) throw Page_image::Error( "zero maxval in ppm file." ); if( maxval > 255 ) throw Page_image::Error( "maxval > 255 in ppm \"P6\" file." ); maxval_ = maxval; threshold_ = maxval_ / 2; const int rows = height(), cols = width(); for( int row = 0; row < rows; ++row ) for( int col = 0; col < cols; ++col ) { const uint8_t r = pnm_getrawbyte( f ); // Red value const uint8_t g = pnm_getrawbyte( f ); // Green value const uint8_t b = pnm_getrawbyte( f ); // Blue value if( r > maxval_ || g > maxval_ || b > maxval_ ) throw Page_image::Error( "value > maxval in ppm file." ); uint8_t val; if( !invert ) val = std::min( r, std::min( g, b ) ); else val = maxval_ - std::max( r, std::max( g, b ) ); data[row].push_back( val ); } } // Creates a Page_image from a pbm, pgm or ppm file // "P1" (pbm), "P4" (pbm RAWBITS), "P2" (pgm), "P5" (pgm RAWBITS), // "P3" (ppm), "P6" (ppm RAWBITS) file formats are recognized. // Page_image::Page_image( FILE * const f, const bool invert ) : Rectangle( 0, 0, 0, 0 ) { unsigned char filetype = 0; if( pnm_getrawbyte( f ) == 'P' ) { unsigned char ch = pnm_getrawbyte( f ); if( ch >= '1' && ch <= '6' ) filetype = ch; } if( filetype == 0 ) throw Error( "bad magic number - not a pbm, pgm or ppm file." ); { int tmp = pnm_getint( f ); if( tmp == 0 ) throw Error( "zero width in pnm file." ); Rectangle::width( tmp ); tmp = pnm_getint( f ); if( tmp == 0 ) throw Error( "zero height in pnm file." ); Rectangle::height( tmp ); if( width() < 3 || height() < 3 ) throw Error( "image too small. Minimum size is 3x3." ); if( INT_MAX / width() < height() ) throw Error( "image too big. 'int' will overflow." ); } data.resize( height() ); for( unsigned row = 0; row < data.size(); ++row ) data[row].reserve( width() ); switch( filetype ) { case '1': read_p1( f, invert ); break; case '4': read_p4( f, invert ); break; case '2': read_p2( f, invert ); break; case '5': read_p5( f, invert ); break; case '3': read_p3( f, invert ); break; case '6': read_p6( f, invert ); break; } if( verbosity > 0 ) { std::fprintf( stderr, "file type is P%c\n", filetype ); std::fprintf( stderr, "file size is %dw x %dh\n", width(), height() ); } } bool Page_image::save( FILE * const f, const char filetype ) const { if( filetype < '1' || filetype > '6' ) return false; std::fprintf( f, "P%c\n%d %d\n", filetype, width(), height() ); if( filetype != '1' && filetype != '4' ) std::fprintf( f, "%d\n", maxval_ ); if( filetype == '1' ) // pbm for( int row = top(); row <= bottom(); ++row ) { for( int col = left(); col <= right(); ++col ) std::putc( get_bit( row, col ) ? '1' : '0', f ); std::putc( '\n', f ); } else if( filetype == '4' ) // pbm RAWBITS for( int row = top(); row <= bottom(); ++row ) { uint8_t byte = 0, mask = 0x80; for( int col = left(); col <= right(); ++col ) { if( get_bit( row, col ) ) byte |= mask; mask >>= 1; if( mask == 0 ) { std::putc( byte, f ); byte = 0; mask = 0x80; } } if( mask != 0x80 ) std::putc( byte, f ); // incomplete byte at end of row } else if( filetype == '2' ) // pgm for( int row = top(); row <= bottom(); ++row ) { for( int col = left(); col < right(); ++col ) std::fprintf( f, "%d ", data[row][col] ); std::fprintf( f, "%d\n", data[row][right()] ); } else if( filetype == '5' ) // pgm RAWBITS for( int row = top(); row <= bottom(); ++row ) for( int col = left(); col <= right(); ++col ) std::fprintf( f, "%c", data[row][col] ); else if( filetype == '3' ) // ppm for( int row = top(); row <= bottom(); ++row ) { for( int col = left(); col < right(); ++col ) { const uint8_t d = data[row][col]; std::fprintf( f, "%d %d %d ", d, d, d ); } const uint8_t d = data[row][right()]; std::fprintf( f, "%d %d %d\n", d, d, d ); } else if( filetype == '6' ) // ppm RAWBITS for( int row = top(); row <= bottom(); ++row ) for( int col = left(); col <= right(); ++col ) { const uint8_t d = data[row][col]; std::fprintf( f, "%c %c %c ", d, d, d ); } return true; } ocrad-0.22/profile.cc0000644000076400001440000004343712160555751013070 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" #include "bitmap.h" #include "blob.h" #include "profile.h" Profile::Profile( const Bitmap & bm_, const Type t ) : bm( bm_ ), type( t ), limit_( -1 ), max_( -1 ), min_( -1 ), mean_( -1 ), isconcave_( -1 ), isconvex_( -1 ), isflat_( -1 ), isflats_( -1 ), ispit_( -1 ), istpit_( -1 ), isupit_( -1 ), isvpit_( -1 ), istip_( -1 ) {} void Profile::initialize() { switch( type ) { case left : data.resize( bm.height() ); limit_ = bm.width(); for( int row = bm.top(); row <= bm.bottom(); ++row ) { int j = bm.left(); while( j <= bm.right() && !bm.get_bit( row, j ) ) ++j; data[row-bm.top()] = j - bm.left(); } break; case top : data.resize( bm.width() ); limit_ = bm.height(); for( int col = bm.left(); col <= bm.right(); ++col ) { int j = bm.top(); while( j <= bm.bottom() && !bm.get_bit( j, col ) ) ++j; data[col-bm.left()] = j - bm.top(); } break; case right : data.resize( bm.height() ); limit_ = bm.width(); for( int row = bm.top(); row <= bm.bottom(); ++row ) { int j = bm.right(); while( j >= bm.left() && !bm.get_bit( row, j ) ) --j; data[row-bm.top()] = bm.right() - j; } break; case bottom : data.resize( bm.width() ); limit_ = bm.height(); for( int col = bm.left(); col <= bm.right(); ++col ) { int j = bm.bottom(); while( j >= bm.top() && !bm.get_bit( j, col ) ) --j; data[col-bm.left()] = bm.bottom() - j; } break; case height : data.resize( bm.width() ); limit_ = bm.height(); for( int col = bm.left(); col <= bm.right(); ++col ) { int u = bm.top(), d = bm.bottom(); while( u <= d && !bm.get_bit( u, col ) ) ++u; while( u <= d && !bm.get_bit( d, col ) ) --d; data[col-bm.left()] = d - u + 1; } break; case width : data.resize( bm.height() ); limit_ = bm.width(); for( int row = bm.top(); row <= bm.bottom(); ++row ) { int l = bm.left(), r = bm.right(); while( l <= r && !bm.get_bit( row, l ) ) ++l; while( l <= r && !bm.get_bit( row, r ) ) --r; data[row-bm.top()] = r - l + 1; } break; } } int Profile::mean() { if( mean_ < 0 ) { if( limit_ < 0 ) initialize(); mean_ = 0; for( int i = 0; i < samples(); ++i ) mean_ += data[i]; if( samples() > 1 ) mean_ /= samples(); } return mean_; } int Profile::max() { if( max_ < 0 ) { if( limit_ < 0 ) initialize(); max_ = data[0]; for( int i = 1; i < samples(); ++i ) if( data[i] > max_ ) max_ = data[i]; } return max_; } int Profile::max( const int l, int r ) { if( limit_ < 0 ) initialize(); if( r < 0 ) r = samples() - 1; int m = 0; for( int i = l; i <= r; ++i ) if( data[i] > m ) m = data[i]; return m; } int Profile::min() { if( min_ < 0 ) { if( limit_ < 0 ) initialize(); min_ = data[0]; for( int i = 1; i < samples(); ++i ) if( data[i] < min_ ) min_ = data[i]; } return min_; } int Profile::min( const int l, int r ) { if( limit_ < 0 ) initialize(); if( r < 0 ) r = samples() - 1; int m = limit_; for( int i = l; i <= r; ++i ) if( data[i] < m ) m = data[i]; return m; } int Profile::operator[]( int i ) { if( limit_ < 0 ) initialize(); if( i < 0 ) i = 0; else if( i >= samples() ) i = samples() - 1; return data[i]; } int Profile::area( const int l, int r ) { if( limit_ < 0 ) initialize(); if( r < 0 ) r = samples() - 1; int a = 0; for( int i = l; i <= r; ++i ) a += data[i]; return a; } bool Profile::increasing( int i, const int min_delta ) { if( limit_ < 0 ) initialize(); if( i < 0 || i > samples() - 2 || data[samples()-1] - data[i] < min_delta ) return false; while( ++i < samples() ) if( data[i] < data[i-1] ) return false; return true; } bool Profile::decreasing( int i ) { if( limit_ < 0 ) initialize(); const int noise = ( std::min( samples(), limit_ ) / 20 ) + 1; if( i < 0 || samples() - i <= 2 * noise || data[i] - data[samples()-noise] < noise + 1 ) return false; while( ++i < samples() - noise ) if( data[i] > data[i-1] ) return false; return true; } bool Profile::isconcave() { if( isconcave_ < 0 ) { isconcave_ = false; if( limit_ < 0 ) initialize(); if( samples() < 5 ) return isconcave_; int dmax = -1, l = 0, r = 0; for( int i = pos( 10 ); i <= pos( 90 ); ++i ) { if( data[i] > dmax ) { dmax = data[i]; l = r = i; } else if( data[i] == dmax ) { r = i; } } if( l > r || l < pos( 25 ) || r > pos( 75 ) ) return isconcave_; if( data[pos(10)] >= dmax || data[pos(90)] >= dmax ) return isconcave_; int imax = ( l + r ) / 2; for( int i = pos( 10 ); i < imax; ++i ) if( data[i] > data[i+1] ) return isconcave_; for( int i = pos( 90 ); i > imax; --i ) if( data[i] > data[i-1] ) return isconcave_; isconcave_ = true; } return isconcave_; } bool Profile::isconvex() { if( isconvex_ < 0 ) { isconvex_ = false; if( limit_ < 0 ) initialize(); if( samples() < 9 || limit_ < 5 ) return isconvex_; int min = limit_, min_begin = 0, min_end = 0; int lmin = limit_, rmax = -limit_, l = 0, r = 0; for( int i = 1; i < samples(); ++i ) { int d = data[i] - data[i-1]; if( d < lmin ) { lmin = d; l = i - 1; } if( d >= rmax ) { rmax = d; r = i; } if( data[i] <= min ) { min_end = i; if( data[i] < min ) { min = data[i]; min_begin = i; } } } if( l >= r || l >= pos( 25 ) || r <= pos( 75 ) ) return isconvex_; if( lmin >= 0 || rmax <= 0 || data[l] < 2 || data[r] < 2 || 3 * ( data[l] + data[r] ) <= std::min( limit_, samples() ) ) return isconvex_; if( 3 * ( min_end - min_begin + 1 ) > 2 * samples() ) return isconvex_; if( 2 * l >= min_begin || 2 * r <= min_end + samples() - 1 ) return isconvex_; if( min_begin < pos( 10 ) || min_end > pos( 90 ) ) return isconvex_; const int noise = ( std::min( samples(), limit_ ) / 30 ) + 1; int dmax = -limit_; for( int i = l + 1; i <= r; ++i ) { if( i >= min_begin && i <= min_end ) { if( data[i] <= noise ) continue; else return isconvex_; } int d = data[i] - data[i-1]; if( d == 0 ) continue; if( d > dmax ) { if( std::abs( d ) <= noise ) ++dmax; else dmax = d; } else if( d < dmax - noise ) return isconvex_; } if( 2 * ( min_end - min_begin + 1 ) < samples() ) { int varea = ( min_begin - l + 1 ) * data[l] / 2; varea += ( r - min_end + 1 ) * data[r] / 2; if( this->area( l, min_begin - 1 ) + this->area( min_end + 1, r ) >= varea ) return isconvex_; } isconvex_ = true; } return isconvex_; } bool Profile::isflat() { if( isflat_ < 0 ) { isflat_ = false; if( limit_ < 0 ) initialize(); if( samples() < 10 ) return isflat_; int mn = data[samples()/2], mx = mn; for( int i = 1; i < samples() - 1; ++i ) { int d = data[i]; if( d < mn ) mn = d; else if( d > mx ) mx = d; } isflat_ = (bool)( mx - mn <= 1 + ( samples() / 30 ) ); } return isflat_; } bool Profile::isflats() { if( isflats_ < 0 ) { isflats_ = false; if( limit_ < 0 ) initialize(); if( samples() < 12 ) return isflats_; const int s1 = std::max( pos( 15 ), 3 ); const int s2 = std::min( pos( 85 ), samples() - 4 ); int mn = -1, mx = 0; for( int i = s1 + 2; i < s2; ++i ) if( data[i-1] == data[i] ) { mn = mx = data[i]; break; } if( mn < 0 ) return isflats_; for( int i = 1; i <= s1; ++i ) if( data[i] > mx ) mx = data[i]; for( int i = s1 + 1; i < s2; ++i ) { int d = data[i]; if( d < mn ) mn = d; else if( d > mx ) mx = d; } for( int i = s2; i < samples() - 1; ++i ) if( data[i] > mx ) mx = data[i]; isflats_ = (bool)( mx - mn <= 1 + ( samples() / 30 ) ); } return isflats_; } bool Profile::ispit() { if( ispit_ < 0 ) { ispit_ = false; if( limit_ < 0 ) initialize(); if( samples() < 5 ) return ispit_; const int noise = ( std::min( samples(), limit_ ) / 25 ) + 1; for( int i = 0; i < noise; ++i ) if( data[i] <= noise - i || data[samples()-i-1] <= noise - i ) return ispit_; const int dmin = min(), dmax = limit_ / 2; int begin = 0, end = 0, i, ref; for( i = 0, ref = dmax; i < samples(); ++i ) { int d = data[i]; if( d == dmin ) { begin = i; break; } if( d < ref ) ref = d; else if( d > ref + noise && ref < dmax ) return ispit_; } if( begin < 2 || begin > samples() - 3 ) return ispit_; for( i = samples() - 1, ref = dmax; i >= begin; --i ) { int d = data[i]; if( d == dmin ) { end = i; break; } if( d < ref ) ref = d; else if( d > ref + noise && ref < dmax ) return ispit_; } if( end < begin || end > samples() - 3 ) return ispit_; for( i = begin + 1; i < end; ++i ) if( data[i] > dmin + noise ) return ispit_; ispit_ = true; } return ispit_; } bool Profile::iscpit( const int cpos ) { if( limit_ < 0 ) initialize(); if( samples() < 5 || cpos < 25 || cpos > 75 ) return false; const int mid = ( ( samples() - 1 ) * cpos ) / 100; const int iend = std::min( samples() / 4, std::min( mid, samples() - mid ) ); const int th = ( ( mean() < 2 ) ? 2 : mean() ); int imin = -1; for( int i = 0; i < iend; ++i ) { if( data[mid+i] < th ) { imin = mid + i; break; } if( data[mid-i-1] < th ) { imin = mid - i - 1; break; } } if( imin < 0 ) return false; for( int i = imin + 1; i < samples(); ++i ) if( data[i] > th ) { for( int j = imin - 1; j >= 0; --j ) if( data[j] > th ) return true; break; } return false; } bool Profile::islpit() { if( limit_ < 0 ) initialize(); if( samples() < 5 ) return false; const int noise = samples() / 30; if( data[0] < noise + 2 ) return false; const int dmin = min(); int begin = 0, ref = limit_; for( int i = 0; i < samples(); ++i ) { int d = data[i]; if( d == dmin ) { begin = i; break; } if( d < ref ) ref = d; else if( d > ref + 1 ) return false; } if( begin < 2 || 2 * begin >= samples() ) return false; return true; } bool Profile::istpit() { if( istpit_ < 0 ) { if( limit_ < 0 ) initialize(); if( limit_ < 5 || samples() < 5 || !ispit() ) { istpit_ = false; return istpit_; } const int noise = ( std::min( limit_, samples() ) / 30 ) + 1; int l = -1, r = 0; for( int i = 0; i < samples(); ++i ) if( data[i] <= noise ) { r = i; if( l < 0 ) l = i; } istpit_ = (bool)( l > 0 && 4 * ( r - l + 1 ) < samples() ); } return istpit_; } bool Profile::isupit() { if( isupit_ < 0 ) { isupit_ = false; if( limit_ < 0 ) initialize(); if( samples() < 5 ) return isupit_; int th = ( mean() < 2 && range() > 2 ) ? 2 : mean(); int status = 0, ucount = 0, lcount = 0, umean =0, lmean = 0; for( int i = 0; i < samples(); ++i ) { int d = data[i]; switch( status ) { case 0: if( d < th ) { if( i < pos( 25 ) || i > pos( 70 ) ) return isupit_; status = 1; break; } if( d > th ) { ++ucount; umean += d; } break; case 1: if( d > th ) { if( i < pos( 30 ) || i > pos( 75 ) ) return isupit_; status = 2; break; } if( d < th ) { ++lcount; lmean += d; } break; case 2: if( d < th ) return isupit_; if( d > th ) { ++ucount; umean += d; } break; } } if( ucount > 1 ) umean /= ucount; if( lcount > 1 ) lmean /= lcount; isupit_ = (bool)( status == 2 && umean - lmean > range() / 2 ); } return isupit_; } bool Profile::isvpit() { if( isvpit_ < 0 ) { if( limit_ < 0 ) initialize(); if( limit_ < 5 || samples() < 5 || !ispit() ) { isvpit_ = false; return isvpit_; } const int noise = limit_ / 20; const int level = ( limit_ / 10 ) + 2; int ll = -1, ln = -1, rl = -1, rn = -1; for( int i = 0; i < samples(); ++i ) if( data[i] <= level ) { rl = i; if( ll < 0 ) ll = i; if( data[i] <= noise ) { rn = i; if( ln < 0 ) ln = i; } } const int wl = rl - ll + 1, wn = rn - ln + 1; isvpit_ = (bool)( ln > 0 && 2 * wl <= samples() + 1 && wl - wn <= 2 * ( level - noise ) ); } return isvpit_; } bool Profile::istip() { if( istip_ < 0 ) { istip_ = false; if( limit_ < 0 ) initialize(); if( samples() < 5 ) return istip_; int th = ( mean() < 2 && range() > 2 ) ? 2 : mean(); if( th < 2 ) ++th; int lth = data[0], rth = data[samples()-1]; int begin = 0, end = samples() - 1; for( int i = 1, j = std::max( 2, samples() / 10 ); i < j; ++i ) { if( data[i] < lth ) { lth = data[i]; begin = i; } if( data[samples()-1-i] < rth ) { rth = data[samples()-1-i]; end = samples() - 1 - i; } } if( lth >= th || rth >= th ) return istip_; if( 3 * lth >= 2 * range() || 3 * rth >= 2 * range() ) return istip_; th = std::max( lth, rth ); int status = 0; for( int i = begin + 1; i < end; ++i ) switch( status ) { case 0: if( data[i] > th + 1 ) status = 1; break; case 1: if( data[i] > th + 1 ) status = 2; else status = 0; break; case 2: if( data[i] <= th ) status = 3; break; case 3: if( data[i] > th + 1 ) return istip_; } istip_ = (bool)( status >= 2 ); } return istip_; } bool Profile::isctip( const int cpos ) { if( limit_ < 0 ) initialize(); if( samples() < 5 || cpos < 25 || cpos > 75 ) return false; const int mid = ( ( samples() - 1 ) * cpos ) / 100; const int iend = std::min( samples() / 4, std::min( mid, samples() - mid ) ); int th = std::max( 2, std::min( mean(), limit_ / 3 ) ); int imax = -1; for( int i = 0; i < iend; ++i ) { if( data[mid+i] > th ) { imax = mid + i; break; } if( data[mid-i-1] > th ) { imax = mid - i - 1; break; } } if( imax < 0 && mean() == 0 ) { --th; for( int i = 0; i < iend; ++i ) { if( data[mid+i] > th ) { imax = mid + i; break; } if( data[mid-i-1] > th ) { imax = mid - i - 1; break; } } } if( imax < 0 ) return false; th = std::max( th, data[imax] / 2 ); for( int i = imax + 1; i < samples(); ++i ) if( data[i] < th ) { for( int j = imax - 1; j >= 0; --j ) if( data[j] < th ) return true; break; } return false; } int Profile::imaximum() { if( limit_ < 0 ) initialize(); const int margin = ( samples() / 30 ) + 1; int mbegin = 0, mend, mvalue = 0; for( int i = margin; i < samples() - margin; ++i ) if( data[i] > mvalue ) { mvalue = data[i]; mbegin = i; } for( mend = mbegin + 1; mend < samples(); ++mend ) if( data[mend] < mvalue ) break; return ( mbegin + mend - 1 ) / 2; } int Profile::iminimum( const int m, int th ) { if( limit_ < 0 ) initialize(); const int margin = ( samples() / 30 ) + 1; if( samples() < 2 * margin ) return 0; if( th < 2 ) th = ( mean() < 2 ) ? 2 : mean(); int minima = 0, status = 0; int begin = 0, end, value = limit_ + 1; for( end = margin; end < samples() - margin; ++end ) { if( status == 0 ) { if( data[end] < th ) { status = 1; ++minima; begin = end; } } else if( data[end] > th ) { if( minima == m + 1 ) { --end; break; } else status = 0; } } if( end >= samples() ) --end; if( minima != m + 1 ) return 0; for( int i = begin; i <= end; ++i ) if( data[i] < value ) { value = data[i]; begin = i; } for( ; end >= begin; --end ) if( data[end] == value ) break; return ( begin + end ) / 2; } int Profile::minima( int th ) { if( limit_ < 0 ) initialize(); if( !samples() ) return 0; if( th < 1 ) th = ( mean() < 2 ) ? 2 : mean(); const int noise = limit_ / 40; const int dth = th - ( ( noise + 1 ) / 2 ), uth = th + ( noise / 2 ); if( dth < 1 ) return 1; int minima = ( data[0] < dth ) ? 1 : 0; int status = ( minima ) ? 1 : 0; for( int i = 1; i < samples(); ++i ) switch( status ) { case 0: if( data[i] < dth ) { status = 1; ++minima; } break; case 1: if( data[i] > uth ) status = 0; break; } return minima; } bool Profile::straight( int * const dyp ) { if( limit_ < 0 ) initialize(); if( samples() < 5 ) return false; const int xl = ( samples() / 30 ) + 1, yl = ( data[xl] + data[xl+1] ) / 2 ; const int xr = samples() - xl - 1, yr = ( data[xr-1] + data[xr] ) / 2 ; const int dx = xr - xl, dy = yr - yl; if( dx <= 0 ) return false; const int dmax = dx * ( ( samples() / 20 ) + 2 ); int faults = samples() / 10; for( int i = 0; i < samples(); ++i ) { int y = ( dx * yl ) + ( ( i - xl ) * dy ); int d = std::abs( ( dx * data[i] ) - y ); if( d >= dmax && ( ( dx * data[i] ) < y || ( i >= xl && i <= xr ) ) ) if( d > dmax || ( d == dmax && --faults < 0 ) ) return false; } if( dyp ) *dyp = dy; return true; } ocrad-0.22/rational.cc0000644000076400001440000001550712111777364013240 0ustar yousers/* Rational - Rational number class with overflow detection. Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This library is free software: you have unlimited permission to copy, distribute and modify it. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include #include #include "rational.h" #ifndef LLONG_MAX #define LLONG_MAX 0x7FFFFFFFFFFFFFFFLL #endif #ifndef LLONG_MIN #define LLONG_MIN (-LLONG_MAX - 1LL) #endif #ifndef ULLONG_MAX #define ULLONG_MAX 0xFFFFFFFFFFFFFFFFULL #endif namespace { int gcd( int n, int m ) // Greatest Common Divisor { if( n < 0 ) n = -n; if( m < 0 ) m = -m; while( true ) { if( m ) n %= m; else return n; if( n ) m %= n; else return m; } } long long llgcd( long long n, long long m ) // Greatest Common Divisor { if( n < 0 ) n = -n; if( m < 0 ) m = -m; while( true ) { if( m ) n %= m; else return n; if( n ) m %= n; else return m; } } const std::string overflow_string( const int n ) { if( n > 0 ) return "+INF"; if( n < 0 ) return "-INF"; return "NAN"; } int overflow_value( const int n ) { if( n > 0 ) return INT_MAX; if( n < 0 ) return -INT_MAX; return 0; } int lloverflow_value( const long long n ) { if( n > 0 ) return INT_MAX; if( n < 0 ) return -INT_MAX; return 0; } } // end namespace void Rational::normalize( long long n, long long d ) { if( d == 0 ) { num = lloverflow_value( n ); den = 0; return; } // set error if( n == 0 ) { num = 0; den = 1; return; } if( d != 1 ) { const long long tmp = llgcd( n, d ); n /= tmp; d /= tmp; } if( n <= INT_MAX && n >= -INT_MAX && d <= INT_MAX && d >= -INT_MAX ) { if( d >= 0 ) { num = n; den = d; } else { num = -n; den = -d; } } else { num = lloverflow_value( (d >= 0) ? n : -n ); den = 0; } } void Rational::normalize() { if( den == 0 ) return; // no op on error if( num == 0 ) { den = 1; return; } if( num < -INT_MAX ) { if( den < -INT_MAX ) den = -INT_MAX; num = overflow_value( -den ); den = 0; return; } if( den < 0 ) { if( den < -INT_MAX ) { num = overflow_value( -num ); den = 0; return; } num = -num; den = -den; } if( den != 1 ) { const int tmp = gcd( num, den ); num /= tmp; den /= tmp; } } Rational Rational::inverse() const { if( den <= 0 ) return *this; // no op on error Rational tmp; if( num > 0 ) { tmp.num = den; tmp.den = num; } else if( num < 0 ) { tmp.num = -den; tmp.den = -num; } else { tmp.num = overflow_value( den ); tmp.den = 0; } // set error return tmp; } Rational & Rational::operator+=( const Rational & r ) { if( den <= 0 ) return *this; // no op on error if( r.den <= 0 ) { num = r.num; den = 0; return *this; } // set error const long long new_den = (long long)den * r.den; const long long new_num = ( (long long)num * r.den ) + ( (long long)r.num * den ); normalize( new_num, new_den ); return *this; } Rational & Rational::operator*=( const Rational & r ) { if( den <= 0 ) return *this; // no op on error if( r.den <= 0 ) { num = r.num; den = 0; return *this; } // set error const long long new_num = (long long)num * r.num; const long long new_den = (long long)den * r.den; normalize( new_num, new_den ); return *this; } int Rational::round() const { if( den <= 0 ) return num; int result = num / den; const int rest = std::abs( num ) % den; if( rest > 0 && rest >= den - rest ) { if( num >= 0 ) ++result; else --result; } return result; } // Recognized formats: 123 123/456 123.456 .123 12% 12/3% 12.3% .12% // Values may be preceded by an optional '+' or '-' sign. // Returns the number of chars read from 's', or 0 if input is invalid. // In case of invalid input, the Rational is not changed. // int Rational::parse( const char * const s ) { if( !s || !s[0] ) return 0; long long n = 0, d = 1; // restrain intermediate overflow int c = 0; bool minus = false; while( std::isspace( s[c] ) ) ++c; if( s[c] == '+' ) ++c; else if( s[c] == '-' ) { ++c; minus = true; } if( !std::isdigit( s[c] ) && s[c] != '.' ) return 0; while( std::isdigit( s[c] ) ) { if( ( LLONG_MAX - (s[c] - '0') ) / 10 < n ) return 0; n = (n * 10) + (s[c] - '0'); ++c; } if( s[c] == '.' ) { ++c; if( !std::isdigit( s[c] ) ) return 0; while( std::isdigit( s[c] ) ) { if( ( LLONG_MAX - (s[c] - '0') ) / 10 < n || LLONG_MAX / 10 < d ) return 0; n = (n * 10) + (s[c] - '0'); d *= 10; ++c; } } else if( s[c] == '/' ) { ++c; d = 0; while( std::isdigit( s[c] ) ) { if( ( LLONG_MAX - (s[c] - '0') ) / 10 < d ) return 0; d = (d * 10) + (s[c] - '0'); ++c; } if( d == 0 ) return 0; } if( s[c] == '%' ) { ++c; if( n % 100 == 0 ) n /= 100; else if( n % 10 == 0 && LLONG_MAX / 10 >= d ) { n /= 10; d *= 10; } else if( LLONG_MAX / 100 >= d ) d *= 100; else return 0; } if( minus ) n = -n; Rational tmp; tmp.normalize( n, d ); if( !tmp.error() ) { *this = tmp; return c; } return 0; } // Returns a string representing the value 'num/den' in decimal point // format with 'prec' decimals. // 'iwidth' is the minimum width of the integer part, prefixed with // spaces if needed. // If 'prec' is negative, only the needed decimals are produced. // const std::string Rational::to_decimal( const unsigned iwidth, int prec ) const { if( den <= 0 ) return overflow_string( num ); std::string s; int ipart = std::abs( num / den ); const bool truncate = ( prec < 0 ); if( prec < 0 ) prec = -prec; do { s += '0' + ( ipart % 10 ); ipart /= 10; } while( ipart > 0 ); if( num < 0 ) s += '-'; if( iwidth > s.size() ) s.append( iwidth - s.size(), ' ' ); std::reverse( s.begin(), s.end() ); long long rest = std::abs( num ) % den; if( prec > 0 && ( rest > 0 || !truncate ) ) { s += '.'; while( prec > 0 && ( rest > 0 || !truncate ) ) { rest *= 10; s += '0' + ( rest / den ); rest %= den; --prec; } } return s; } // Returns a string representing the value 'num/den' in fractional form. // 'width' is the minimum width to be produced, prefixed with spaces if // needed. // const std::string Rational::to_fraction( const unsigned width ) const { if( den <= 0 ) return overflow_string( num ); std::string s; int n = std::abs( num ), d = den; do { s += '0' + ( d % 10 ); d /= 10; } while( d > 0 ); s += '/'; do { s += '0' + ( n % 10 ); n /= 10; } while( n > 0 ); if( num < 0 ) s += '-'; if( width > s.size() ) s.append( width - s.size(), ' ' ); std::reverse( s.begin(), s.end() ); return s; } ocrad-0.22/rectangle.cc0000644000076400001440000001666012123636414013365 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include "common.h" #include "rectangle.h" namespace { void error( const char * const msg ) { Ocrad::internal_error( msg ); } } // end namespace Rectangle::Rectangle( const int l, const int t, const int r, const int b ) { if( r < l || b < t ) { if( verbosity >= 0 ) std::fprintf( stderr, "l = %d, t = %d, r = %d, b = %d\n", l, t, r, b ); error( "bad parameter building a Rectangle" ); } left_ = l; top_ = t; right_ = r; bottom_ = b; } void Rectangle::left( const int l ) { if( l > right_ ) error( "left, bad parameter resizing a Rectangle" ); left_ = l; } void Rectangle::top( const int t ) { if( t > bottom_ ) error( "top, bad parameter resizing a Rectangle" ); top_ = t; } void Rectangle::right( const int r ) { if( r < left_ ) error( "right, bad parameter resizing a Rectangle" ); right_ = r; } void Rectangle::bottom( const int b ) { if( b < top_ ) error( "bottom, bad parameter resizing a Rectangle" ); bottom_ = b; } void Rectangle::height( const int h ) { if( h <= 0 ) error( "height, bad parameter resizing a Rectangle" ); bottom_ = top_ + h - 1; } void Rectangle::width( const int w ) { if( w <= 0 ) error( "width, bad parameter resizing a Rectangle" ); right_ = left_ + w - 1; } void Rectangle::add_point( const int row, const int col ) { if( row > bottom_ ) bottom_ = row; else if( row < top_ ) top_ = row; if( col > right_ ) right_ = col; else if( col < left_ ) left_ = col; } void Rectangle::add_rectangle( const Rectangle & re ) { if( re.left_ < left_ ) left_ = re.left_; if( re.top_ < top_ ) top_ = re.top_; if( re.right_ > right_ ) right_ = re.right_; if( re.bottom_ > bottom_ ) bottom_ = re.bottom_; } void Rectangle::enlarge( const int scale ) { if( scale > 1 ) { left_ *= scale; top_ *= scale; right_ *= scale; bottom_ *= scale; } } void Rectangle::move( const int row, const int col ) { int d = row - top_; if( d ) { top_ += d; bottom_ += d; } d = col - left_; if( d ) { left_ += d; right_ += d; } } bool Rectangle::includes( const Rectangle & re ) const { return ( left_ <= re.left_ && top_ <= re.top_ && right_ >= re.right_ && bottom_ >= re.bottom_ ); } bool Rectangle::includes( const int row, const int col ) const { return ( left_ <= col && right_ >= col && top_ <= row && bottom_ >= row ); } bool Rectangle::strictly_includes( const Rectangle & re ) const { return ( left_ < re.left_ && top_ < re.top_ && right_ > re.right_ && bottom_ > re.bottom_ ); } bool Rectangle::strictly_includes( const int row, const int col ) const { return ( left_ < col && right_ > col && top_ < row && bottom_ > row ); } bool Rectangle::includes_hcenter( const Rectangle & re ) const { return ( left_ <= re.hcenter() && right_ >= re.hcenter() ); } bool Rectangle::includes_vcenter( const Rectangle & re ) const { return ( top_ <= re.vcenter() && bottom_ >= re.vcenter() ); } bool Rectangle::h_includes( const Rectangle & re ) const { return ( left_ <= re.left_ && right_ >= re.right_ ); } bool Rectangle::v_includes( const Rectangle & re ) const { return ( top_ <= re.top_ && bottom_ >= re.bottom_ ); } bool Rectangle::h_includes( const int col ) const { return ( left_ <= col && right_ >= col ); } bool Rectangle::v_includes( const int row ) const { return ( top_ <= row && bottom_ >= row ); } bool Rectangle::h_overlaps( const Rectangle & re ) const { return ( left_ <= re.right_ && right_ >= re.left_ ); } bool Rectangle::v_overlaps( const Rectangle & re ) const { return ( top_ <= re.bottom_ && bottom_ >= re.top_ ); } int Rectangle::v_overlap_percent( const Rectangle & re ) const { int ov = std::min( bottom_, re.bottom_ ) - std::max( top_, re.top_ ) + 1; if( ov > 0 ) ov = std::max( 1, ( ov * 100 ) / std::min( height(), re.height() ) ); else ov = 0; return ov; } bool Rectangle::is_hcentred_in( const Rectangle & re ) const { if( this->h_includes( re.hcenter() ) ) return true; int w = std::min( re.height(), re.width() ) / 2; if( width() < w ) { int d = ( w + 1 ) / 2; if( hcenter() - d <= re.hcenter() && hcenter() + d >= re.hcenter() ) return true; } return false; } bool Rectangle::is_vcentred_in( const Rectangle & re ) const { if( this->v_includes( re.vcenter() ) ) return true; int h = std::min( re.height(), re.width() ) / 2; if( height() < h ) { int d = ( h + 1 ) / 2; if( vcenter() - d <= re.vcenter() && vcenter() + d >= re.vcenter() ) return true; } return false; } bool Rectangle::precedes( const Rectangle & re ) const { if( right_ < re.left_ ) return true; if( this->h_overlaps( re ) && ( ( top_ < re.top_ ) || ( top_ == re.top_ && left_ < re.left_ ) ) ) return true; return false; } bool Rectangle::h_precedes( const Rectangle & re ) const { return ( hcenter() < re.hcenter() ); } bool Rectangle::v_precedes( const Rectangle & re ) const { if( bottom_ < re.vcenter() || vcenter() < re.top_ ) return true; if( this->includes_vcenter( re ) && re.includes_vcenter( *this ) ) return this->h_precedes( re ); return false; } int Rectangle::distance( const Rectangle & re ) const { return hypoti( h_distance( re ), v_distance( re ) ); } int Rectangle::distance( const int row, const int col ) const { return hypoti( h_distance( col ), v_distance( row ) ); } int Rectangle::h_distance( const Rectangle & re ) const { if( re.right_ <= left_ ) return left_ - re.right_; if( re.left_ >= right_ ) return re.left_ - right_; return 0; } int Rectangle::h_distance( const int col ) const { if( col <= left_ ) return left_ - col; if( col >= right_ ) return col - right_; return 0; } int Rectangle::v_distance( const Rectangle & re ) const { if( re.bottom_ <= top_ ) return top_ - re.bottom_; if( re.top_ >= bottom_ ) return re.top_ - bottom_; return 0; } int Rectangle::v_distance( const int row ) const { if( row <= top_ ) return top_ - row; if( row >= bottom_ ) return row - bottom_; return 0; } int Rectangle::hypoti( const int c1, const int c2 ) { long long temp = c1; temp *= temp; long long target = c2; target *= target; target += temp; int lower = std::max( std::abs(c1), std::abs(c2) ); int upper = std::abs(c1) + std::abs(c2); while( upper - lower > 1 ) { int m = ( lower + upper ) / 2; temp = m; temp *= temp; if( temp < target ) lower = m; else upper = m; } temp = lower; temp *= temp; target *= 2; target -= temp; temp = upper; temp *= temp; if( target < temp ) return lower; else return upper; } ocrad-0.22/segment.cc0000644000076400001440000000320512140443140013041 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include "segment.h" void Csegment::add_point( const int col ) { if( !valid() ) left = right = col; else if( col < left ) left = col; else if( col > right ) right = col; } void Csegment::add_csegment( const Csegment & seg ) { if( seg.valid() ) { if( !valid() ) *this = seg; else { if( seg.left < left ) left = seg.left; if( seg.right > right ) right = seg.right; } } } int Csegment::distance( const Csegment & seg ) const { if( !valid() || !seg.valid() ) return INT_MAX; if( seg.right < left ) return left - seg.right; if( seg.left > right ) return seg.left - right; return 0; } int Csegment::distance( const int col ) const { if( !valid() ) return INT_MAX; if( col < left ) return left - col; if( col > right ) return col - right; return 0; } ocrad-0.22/textblock.cc0000644000076400001440000003772012160662413013417 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include #include "common.h" #include "rational.h" #include "rectangle.h" #include "track.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "page_image.h" #include "textline.h" #include "textblock.h" namespace { void insert_line( std::vector< Textline * > & textlinep_vector, int i ) { textlinep_vector.insert( textlinep_vector.begin() + i, new Textline ); } void delete_line( std::vector< Textline * > & textlinep_vector, int i ) { delete textlinep_vector[i]; textlinep_vector.erase( textlinep_vector.begin() + i ); } // Build the vertical composite characters. // void join_characters( std::vector< Textline * > & tlpv ) { for( unsigned current_line = 0; current_line < tlpv.size(); ++current_line ) { Textline & line = *tlpv[current_line]; for( int i = 0 ; i < line.characters() - 1; ) { Character & c1 = line.character( i ); bool joined = false; for( int j = i + 1 ; j < line.characters(); ++j ) { Character & c2 = line.character( j ); if( !c1.h_overlaps( c2 ) ) continue; Character *cup, *cdn; if( c1.vcenter() < c2.vcenter() ) cup = &c1, cdn = &c2; else cup = &c2, cdn = &c1; if( cdn->includes_hcenter( *cup ) || cup->includes_hcenter( *cdn ) || ( cdn->top() > cup->bottom() && cdn->hcenter() < cup->hcenter() ) || ( cdn->blobs() == 2 && 2 * cdn->blob( 0 ).size() < cdn->blob( 1 ).size() && cdn->blob( 0 ).includes_vcenter( *cup ) ) ) { int k; if( 64 * c1.size() < c2.main_blob().size() ) k = i; else if( 64 * c2.size() < c1.main_blob().size() ) k = j; else if( cdn == &c2 ) { c2.join( c1 ); k = i; } else { c1.join( c2 ); k = j; } line.delete_character( k ); joined = true; break; } } if( !joined ) ++i; } } } } // end namespace Textblock::Textblock( const Rectangle & page, const Rectangle & block, std::vector< Blob * > & blobp_vector ) : Rectangle( block ) { std::vector< Blob * > pending; std::vector< Blob * > pending_tall; std::vector< Blob * > pending_short; for( unsigned begin = 0, end = 0; end < blobp_vector.size(); begin = end ) { int botmax = blobp_vector[begin]->bottom(); // make cuts while( ++end < blobp_vector.size() ) { if( blobp_vector[end]->top() > botmax ) break; botmax = std::max( botmax, blobp_vector[end]->bottom() ); } // Classify blobs by height. unsigned samples = 0; std::vector< int > height_distrib; for( unsigned i = begin; i < end; ++i ) { if( blobp_vector[i]->is_abnormal() ) continue; unsigned h = blobp_vector[i]->height(); if( h >= height_distrib.size() ) height_distrib.resize( h + 1 ); ++height_distrib[h]; ++samples; } if( !height_distrib.size() ) // all blobs are abnormal for( unsigned i = begin; i < end; ++i ) { unsigned h = blobp_vector[i]->height(); if( h >= height_distrib.size() ) height_distrib.resize( h + 1 ); ++height_distrib[h]; ++samples; } int mean_height = 0; int valid_samples = 0; for( unsigned i = 0, count = 0; i < height_distrib.size(); ++i ) { int a = height_distrib[i]; if( 10 * ( count + a ) >= samples && 10 * count < 9 * samples ) { mean_height += a * i; valid_samples += a; } count += a; } if( valid_samples ) mean_height /= valid_samples; for( unsigned i = begin; i < end; ++i ) { Blob * const p = blobp_vector[i]; const bool a = p->is_abnormal(); if( p->height() >= 2 * mean_height || ( a && p->height() > mean_height ) ) pending_tall.push_back( p ); else if( 2 * p->height() <= mean_height || p->height() <= 5 || ( a && p->height() < mean_height ) ) pending_short.push_back( p ); else pending.push_back( p ); } } if( !pending.size() ) { for( unsigned i = 0; i < blobp_vector.size(); ++i ) delete blobp_vector[i]; blobp_vector.clear(); return; } blobp_vector.clear(); // Assign normal blobs to characters and create lines. int min_line = 0; // first line of current cut tlpv.push_back( new Textline ); int current_line = min_line = textlines() - 1; tlpv[current_line]->shift_characterp( new Character( pending[0] ) ); for( unsigned i = 1; i < pending.size(); ++i ) { Blob & b = *pending[i]; current_line = std::max( min_line, current_line - 2 ); while( true ) { const Character *cl = 0, *cr = 0; for( int j = tlpv[current_line]->characters() - 1; j >= 0; --j ) { const Character & cj = tlpv[current_line]->character( j ); if( !b.includes_hcenter( cj ) && !cj.includes_hcenter( b ) ) { if( b.h_precedes( cj ) ) cr = &cj; else { cl = &cj; break; } } } if( ( cl && ( cl->includes_vcenter( b ) || b.includes_vcenter( *cl ) ) ) || ( cr && ( cr->includes_vcenter( b ) || b.includes_vcenter( *cr ) ) ) ) { tlpv[current_line]->shift_characterp( new Character( &b ) ); break; } else if( ( cl && cl->top() > b.bottom() ) || ( cr && cr->top() > b.bottom() ) ) { insert_line( tlpv, current_line ); tlpv[current_line]->shift_characterp( new Character( &b ) ); break; } else if( ( cl && cl->v_overlap_percent( b ) > 5 ) || ( cr && cr->v_overlap_percent( b ) > 5 ) ) { tlpv[current_line]->shift_characterp( new Character( &b ) ); break; } else if( ++current_line >= textlines() ) { tlpv.push_back( new Textline ); current_line = textlines() - 1; tlpv[current_line]->shift_characterp( new Character( &b ) ); break; } } } for( int i = textlines() - 1; i >= 0; --i ) if( !tlpv[i]->characters() ) delete_line( tlpv, i ); join_characters( tlpv ); // Create tracks of lines. for( int i = 0; i < textlines(); ++i ) tlpv[i]->set_track(); // Insert tall blobs. // Seek up, then seek down, needed for slanted or curved lines. current_line = 0; for( unsigned i = 0; i < pending_tall.size(); ++i ) { Blob & b = *pending_tall[i]; while( current_line > 0 && b.bottom() < tlpv[current_line]->vcenter( b.hcenter() ) ) --current_line; while( current_line < textlines() && b.top() > tlpv[current_line]->vcenter( b.hcenter() ) ) ++current_line; if( current_line >= textlines() ) { --current_line; delete &b; continue; } Textline & l = *tlpv[current_line]; const int bi = l.big_initials(); const int mh = l.mean_height(); if( b.height() <= 3 * mh && ( b.height() <= 2 * mh || l.character( bi ).left() < b.left() ) ) l.shift_characterp( new Character( &b ) ); else if( !l.characters() || l.character( std::min( bi+1, l.characters() - 1 ) ).left() > b.hcenter() ) l.shift_characterp( new Character( &b ), true ); // big initial else delete &b; } // for( int i = 0; i < textlines(); ++i ) tlpv[i]->verify_big_initials(); // Insert short blobs. // Seek up, then seek down, needed for slanted or curved lines. current_line = 0; for( unsigned i = 0; i < pending_short.size(); ++i ) { Blob & b = *pending_short[i]; while( current_line > 0 && b.bottom() < tlpv[current_line]->top( b.hcenter() ) ) --current_line; int temp = std::max( 0, current_line - 1 ); while( current_line < textlines() && b.top() > tlpv[current_line]->bottom( b.hcenter() ) ) ++current_line; if( current_line >= textlines() ) { const Textline & l = *tlpv[--current_line]; const Character *p = l.character_at( b.hcenter() ); if( b.top() > l.bottom( b.hcenter() ) + l.height() / 2 && ( !p || b.top() > p->bottom() + l.height() / 2 ) ) { delete &b; continue; } else temp = current_line; } if( current_line - temp > 1 ) temp = current_line - 1; if( current_line != temp && 2 * ( b.top() - tlpv[temp]->bottom( b.hcenter() ) ) < tlpv[current_line]->top( b.hcenter() ) - b.bottom() ) current_line = temp; tlpv[current_line]->shift_characterp( new Character( &b ) ); } // remove clipped lines at top or bottom of page if( textlines() > 2 ) { const Textline * lp = tlpv[textlines()-1]; for( int i = 0, c = 0; i < lp->characters(); ++i ) if( lp->character( i ).bottom() >= page.bottom() && 2 * ++c >= lp->characters() ) { delete_line( tlpv, textlines() - 1 ); break; } lp = tlpv[0]; const int t = std::max( page.top(), 1 ); for( int i = 0, c = 0; i < lp->characters(); ++i ) if( lp->character( i ).top() <= t && 2 * ++c >= lp->characters() ) { delete_line( tlpv, 0 ); break; } } // Second pass. Join lines of i-dots and tildes. for( int current_line = 0; current_line < textlines() - 1; ) { bool joined = false; Textline & line1 = *tlpv[current_line]; Textline & line2 = *tlpv[current_line+1]; if( line1.characters() <= 2 * line2.characters() && 2 * line1.mean_height() < line2.mean_height() ) for( int i1 = 0; !joined && i1 < line1.characters(); ++i1 ) { Character & c1 = line1.character( i1 ); if( 2 * c1.height() >= line2.mean_height() ) continue; for( int i2 = 0; !joined && i2 < line2.characters(); ++i2 ) { Character & c2 = line2.character( i2 ); if( c2.right() < c1.left() ) continue; if( c2.left() > c1.right() ) break; if( ( c2.includes_hcenter( c1 ) || c1.includes_hcenter( c2 ) ) && c2.top() - c1.bottom() < line2.mean_height() ) { joined = true; line2.join( line1 ); delete_line( tlpv, current_line ); } } } if( !joined ) ++current_line; } join_characters( tlpv ); for( int i = 0; i < textlines(); ++i ) tlpv[i]->verify_big_initials(); // Fourth pass. Remove noise lines. if( textlines() >= 3 ) { for( int i = 0; i + 2 < textlines(); ++i ) { Textline & line1 = *tlpv[i]; Textline & line2 = *tlpv[i+1]; Textline & line3 = *tlpv[i+2]; if( line2.characters() > 2 || line1.characters() < 4 || line3.characters() < 4 ) continue; if( !Ocrad::similar( line1.height(), line3.height(), 10 ) ) continue; if( 8 * line2.height() > line1.height() + line3.height() ) continue; delete_line( tlpv, i + 1 ); } } // Remove leading and trailing noise characters. for( int i = 0; i < textlines(); ++i ) { Textline & l = *tlpv[i]; if( !l.big_initials() && l.characters() > 2 ) { const Character & c0 = l.character( 0 ); const Character & c1 = l.character( 1 ); const Character & c2 = l.character( 2 ); if( c0.blobs() == 1 && 4 * c0.size() < c1.size() && c1.left() - c0.right() > 2 * l.height() && 4 * c0.size() < c2.size() && c2.left() - c1.right() < l.height() ) l.delete_character( 0 ); } if( l.characters() > 2 ) { const Character & c0 = l.character( l.characters() - 1 ); const Character & c1 = l.character( l.characters() - 2 ); const Character & c2 = l.character( l.characters() - 3 ); if( c0.blobs() == 1 && 4 * c0.size() < c1.size() && c0.left() - c1.right() > 2 * l.height() && 4 * c0.size() < c2.size() && c1.left() - c2.right() < l.height() ) l.delete_character( l.characters() - 1 ); } } for( int i = 0; i < textlines(); ++i ) tlpv[i]->insert_spaces(); } Textblock::~Textblock() { for( int i = textlines() - 1; i >= 0; --i ) delete tlpv[i]; } void Textblock::recognize( const Charset & charset, const Filter & filter ) { // Recognize characters. for( int i = 0; i < textlines(); ++i ) { // First pass. Recognize the easy characters. tlpv[i]->recognize1( charset ); // Second pass. Use context to clear up ambiguities. tlpv[i]->recognize2( charset ); } if( filter.type() != Filter::none ) for( int i = 0; i < textlines(); ++i ) tlpv[i]->apply_filter( filter ); // Remove unrecognized lines. for( int i = textlines() - 1; i >= 0; --i ) { Textline & line1 = *tlpv[i]; bool recognized = false; for( int j = 0 ; j < line1.characters(); ++j ) { if( line1.character( j ).guesses() ) { recognized = true; break; } } if( !recognized ) delete_line( tlpv, i ); } // Add blank lines. if( textlines() >= 3 ) { int min_vdistance = ( tlpv.back()->mean_vcenter() - tlpv.front()->mean_vcenter() ) / ( textlines() - 1 ); for( int i = 0; i + 1 < textlines(); ++i ) { const Textline & line1 = *tlpv[i]; const Textline & line2 = *tlpv[i+1]; if( !Ocrad::similar( line1.characters(), line2.characters(), 50 ) || !Ocrad::similar( line1.width(), line2.width(), 30 ) ) continue; const int vdistance = line2.mean_vcenter() - line1.mean_vcenter(); if( vdistance >= min_vdistance ) continue; const int mh1 = line1.mean_height(), mh2 = line2.mean_height(); if( mh1 < 10 || mh2 < 10 ) continue; if( Ocrad::similar( mh1, mh2, 20 ) && 2 * vdistance > mh1 + mh2 ) min_vdistance = vdistance; } if( min_vdistance > 0 ) for( int i = 0; i + 1 < textlines(); ++i ) { const Textline & line1 = *tlpv[i]; const Textline & line2 = *tlpv[i+1]; int vdistance = line2.mean_vcenter() - line1.mean_vcenter() - min_vdistance; while( 2 * vdistance > min_vdistance ) { insert_line( tlpv, ++i ); vdistance -= min_vdistance; } } } } const Textline & Textblock::textline( const int i ) const { if( i < 0 || i >= textlines() ) Ocrad::internal_error( "line, index out of bounds" ); return *tlpv[i]; } int Textblock::characters() const { int total = 0; for( int i = 0; i < textlines(); ++i ) total += tlpv[i]->characters(); return total; } void Textblock::print( const Control & control ) const { for( int i = 0; i < textlines(); ++i ) tlpv[i]->print( control ); std::fputs( "\n", control.outfile ); } void Textblock::dprint( const Control & control, bool graph, bool recursive ) const { std::fprintf( control.outfile, "%d lines\n\n", textlines() ); for( int i = 0; i < textlines(); ++i ) { std::fprintf( control.outfile, "%d characters in line %d\n", tlpv[i]->characters(), i + 1 ); tlpv[i]->dprint( control, graph, recursive ); } std::fputs( "\n", control.outfile ); } void Textblock::xprint( const Control & control ) const { std::fprintf( control.exportfile, "lines %d\n", textlines() ); for( int i = 0; i < textlines(); ++i ) { std::fprintf( control.exportfile, "line %d chars %d height %d\n", i + 1, tlpv[i]->characters(), tlpv[i]->mean_height() ); tlpv[i]->xprint( control ); } } void Textblock::cmark( Page_image & page_image ) const { for( int i = 0; i < textlines(); ++i ) tlpv[i]->cmark( page_image ); } void Textblock::lmark( Page_image & page_image ) const { for( int i = 0; i < textlines(); ++i ) page_image.draw_track( *tlpv[i] ); } ocrad-0.22/textline.cc0000644000076400001440000002233612123645321013247 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include #include #include "common.h" #include "rational.h" #include "rectangle.h" #include "track.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "page_image.h" #include "textline.h" namespace { // Return the character position >= first preceding a big gap or eol. // int find_big_gap( const Textline & line, const int first, const int space_width_limit ) { int i = first; while( i + 1 < line.characters() ) { const Character & c1 = line.character( i ); const Character & c2 = line.character( i + 1 ); const int gap = c2.left() - c1.right() - 1; if( gap > space_width_limit ) break; else ++i; } return i; } } // end namespace Textline::Textline( const Textline & tl ) : Track( tl ), big_initials_( tl.big_initials_ ) { cpv.reserve( tl.cpv.size() ); for( unsigned i = 0; i < tl.cpv.size(); ++i ) cpv.push_back( new Character( *tl.cpv[i] ) ); } Textline & Textline::operator=( const Textline & tl ) { if( this != &tl ) { Track::operator=( tl ); big_initials_ = tl.big_initials_; for( unsigned i = 0; i < cpv.size(); ++i ) delete cpv[i]; cpv.clear(); cpv.reserve( tl.cpv.size() ); for( unsigned i = 0; i < tl.cpv.size(); ++i ) cpv.push_back( new Character( *tl.cpv[i] ) ); } return *this; } Textline::~Textline() { for( unsigned i = 0; i < cpv.size(); ++i ) delete cpv[i]; } void Textline::set_track() { std::vector< Rectangle > rv; for( unsigned i = big_initials_; i < cpv.size(); ++i ) if( !cpv[i]->maybe(' ') ) rv.push_back( *cpv[i] ); Track::set_track( rv ); } void Textline::verify_big_initials() { while( big_initials_ > 0 && cpv[big_initials_-1]->height() <= 2 * mean_height() ) --big_initials_; } Character & Textline::character( const int i ) const { if( i < 0 || i >= characters() ) Ocrad::internal_error( "character, index out of bounds" ); return *cpv[i]; } Character * Textline::character_at( const int col ) const { for( int i = 0; i < characters(); ++i ) if( cpv[i]->h_includes( col ) ) return cpv[i]; return 0; } Rectangle Textline::charbox( const Character & c ) const { return Rectangle( c.left(), top( c.hcenter() ), c.right(), bottom( c.hcenter() ) ); } void Textline::delete_character( const int i ) { if( i < 0 || i >= characters() ) Ocrad::internal_error( "delete_character, index out of bounds" ); if( i < big_initials_ ) --big_initials_; delete cpv[i]; cpv.erase( cpv.begin() + i ); } int Textline::shift_characterp( Character * const p, const bool big ) { int i = characters(); while( i > 0 && p->h_precedes( *cpv[i-1] ) ) --i; cpv.insert( cpv.begin() + i, p ); if( i < big_initials_ ) ++big_initials_; else if( big ) big_initials_ = i + 1; return i; } bool Textline::insert_space( const int i, const bool tab ) { if( i <= 0 || i >= characters() ) Ocrad::internal_error( "insert_space, index out of bounds" ); if( !height() ) Ocrad::internal_error( "insert_space, track not set yet" ); Character & c1 = *cpv[i-1]; Character & c2 = *cpv[i]; int l = c1.right() + 1; int r = c2.left() - 1; if( l > r ) return false; int t = top( ( l + r ) / 2 ); int b = bottom( ( l + r ) / 2 ); Rectangle re( l, t, r, b ); Character * const p = new Character( re, ' ', tab ? 1 : 0 ); if( tab ) p->add_guess( '\t', 0 ); cpv.insert( cpv.begin() + i, p ); return true; } // Insert spaces between characters. // void Textline::insert_spaces() { const Rational mw = mean_width(); if( mw < 2 ) return; const int mwt = mw.trunc(); const int space_width_limit = ( 3 * mw ).trunc(); int first = big_initials_; while( first + 1 < characters() ) { int last = find_big_gap( *this, first, space_width_limit ); const Rational mg = mean_gap_width( first, last ); if( first < last && mg >= 0 ) { int spaces = 0, nospaces = 0, spsum = 0, nospsum = 0; for( int i = first ; i < last; ++i ) { const Character & c1 = character( i ); const Character & c2 = character( i + 1 ); const int gap = c2.left() - c1.right() - 1; if( gap >= mwt || gap > 3 * mg || ( 5 * gap > 2 * mw && gap > 2 * mg ) || ( 3 * c1.width() > 2 * mw && 3 * c2.width() > 2 * mw && 2 * gap > mw && 5 * gap > 8 * mg ) ) { ++spaces; spsum += gap; if( insert_space( i + 1 ) ) { ++i; ++last; } } else { ++nospaces; nospsum += gap; } } if( spaces && nospaces ) { const Rational th = ( Rational( 3 * spsum, spaces ) + Rational( nospsum, nospaces ) ) / 4; for( int i = first ; i < last; ++i ) { const Character & c1 = character( i ); const Character & c2 = character( i + 1 ); const int gap = c2.left() - c1.right() - 1; if( gap > th && insert_space( i + 1 ) ) { ++i; ++last; } } } } if( ++last < characters() && insert_space( last, true ) ) ++last; first = last; } } void Textline::join( Textline & tl ) { for( int i = 0; i < tl.characters(); ++i ) shift_characterp( tl.cpv[i], i < tl.big_initials_ ); tl.big_initials_ = 0; tl.cpv.clear(); } int Textline::mean_height() const { int c = 0, sum = 0; for( int i = big_initials_; i < characters(); ++i ) if( !cpv[i]->maybe(' ') ) { ++c; sum += cpv[i]->height(); } if( c ) sum /= c; return sum; } Rational Textline::mean_width() const { int c = 0, sum = 0; for( int i = big_initials_; i < characters(); ++i ) if( !cpv[i]->maybe(' ') ) { ++c; sum += cpv[i]->width(); } if( c ) return Rational( sum, c ); return Rational( 0 ); } Rational Textline::mean_gap_width( const int first, int last ) const { if( last < 0 ) last = characters() - 1; int sum = 0; for( int i = first; i < last; ++i ) sum += std::max( 0, cpv[i+1]->left() - cpv[i]->right() - 1 ); if( last > first ) return Rational( sum, last - first ); return Rational( 0 ); } int Textline::mean_hcenter() const { int c = 0, sum = 0; for( int i = big_initials_; i < characters(); ++i ) { ++c; sum += cpv[i]->hcenter(); } if( c ) sum /= c; return sum; } int Textline::mean_vcenter() const { int c = 0, sum = 0; for( int i = big_initials_; i < characters(); ++i ) { ++c; sum += cpv[i]->vcenter(); } if( c ) sum /= c; return sum; } void Textline::print( const Control & control ) const { for( int i = 0; i < characters(); ++i ) character( i ).print( control ); std::fputs( "\n", control.outfile ); } void Textline::dprint( const Control & control, const bool graph, const bool recursive ) const { if( graph || recursive ) std::fprintf( control.outfile, "mean height = %d, track segments = %d\n", mean_height(), segments() ); for( int i = 0; i < characters(); ++i ) { const Character & c = character( i ); if( i < big_initials_ ) c.dprint( control, c, graph, recursive ); else c.dprint( control, charbox( c ), graph, recursive ); } std::fputs( "\n", control.outfile ); } void Textline::xprint( const Control & control ) const { for( int i = 0; i < characters(); ++i ) character( i ).xprint( control ); } void Textline::cmark( Page_image & page_image ) const { for( int i = 0; i < characters(); ++i ) page_image.draw_rectangle( character( i ) ); } void Textline::recognize1( const Charset & charset ) const { for( int i = 0; i < characters(); ++i ) { Character & c = character( i ); if( i < big_initials_ ) { c.recognize1( charset, c ); if( c.guesses() ) { const int code = c.guess( 0 ).code; if( UCS::islower_ambiguous( code ) ) c.only_guess( UCS::toupper( code ), 0 ); } } else c.recognize1( charset, charbox( c ) ); } } void Textline::apply_filter( const Filter & filter ) { bool flag = false; for( int i = 0; i < characters(); ) { Character & c = character( i ); const int guesses = c.guesses(); c.apply_filter( filter ); if( guesses && !c.guesses() ) { delete_character( i ); flag = true; } else ++i; } if( flag ) for( int i = characters() - 1; i >= 0; --i ) if( character(i).maybe(' ') && ( i >= characters() - 1 || ( i > 0 && character(i-1).maybe(' ') ) ) ) delete_character( i ); } ocrad-0.22/textline_r2.cc0000644000076400001440000007075412160434125013660 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include #include "common.h" #include "rectangle.h" #include "track.h" #include "ucs.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "textline.h" // All the code in this file is provisional and will be rewritten someday namespace { int find_space_or_hyphen( const std::vector< Character * > & cpv, unsigned i ) { while( i < cpv.size() && !cpv[i]->maybe(' ') && !cpv[i]->maybe('-') ) ++i; return i; } } // end namespace // transform some small letters to capitals void Textline::check_lower_ambiguous() { int begin = big_initials(); bool isolated = false; // isolated letters compare with all line for( int i = big_initials(); i < characters(); ++i ) { Character & c1 = character( i ); if( c1.maybe(' ') ) { if( i + 2 < characters() && character( i + 2 ).maybe(' ') ) { begin = big_initials(); isolated = true; } else { begin = i + 1; isolated = false; } continue; } if( c1.guesses() == 1 ) { const int code = c1.guess( 0 ).code; if( !UCS::islower_small_ambiguous( code ) ) continue; if( 5 * c1.height() < 4 * mean_height() ) continue; bool capital = ( 4 * c1.height() > 5 * mean_height() ); bool small = false; for( int j = begin; j < characters(); ++j ) if( j != i ) { const Character & c2 = character( j ); if( !c2.guesses() ) continue; if( c2.maybe(' ') ) { if( isolated ) continue; else break; } const int code2 = c2.guess( 0 ).code; if( code2 >= 128 || !std::isalpha( code2 ) ) continue; if( !capital ) { if( 4 * c1.height() > 5 * c2.height() ) capital = true; else if( std::isupper( code2 ) && code2 != 'B' && code2 != 'Q' && ( c1.height() >= c2.height() || Ocrad::similar( c1.height(), c2.height(), 10 ) ) ) capital = true; else if( code2 == 't' && c1.height() >= c2.height() ) capital = true; } if( !small && std::islower( code2 ) && code2 != 'l' && code2 != 'j' ) { if( 5 * c1.height() < 4 * c2.height() ) small = true; else if( UCS::islower_small( code2 ) && code2 != 'r' && !c2.maybe('Q') && ( j < i || !UCS::islower_small_ambiguous( code2 ) ) && Ocrad::similar( c1.height(), c2.height(), 10 ) ) small = true; } } if( capital && !small ) c1.insert_guess( 0, std::toupper( code ), 1 ); } } } void Textline::recognize2( const Charset & charset ) { if( big_initials() >= characters() ) return; // try to recognize separately the 3 overlapped blobs of an // unrecognized character for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( !c.guesses() && c.blobs() == 3 ) { const Blob & b1 = c.blob( 0 ); const Blob & b2 = c.blob( 1 ); const Blob & b3 = c.blob( 2 ); // lower blob if( Ocrad::similar( b2.height(), b3.height(), 20 ) && !b2.h_overlaps( b3 ) && b2.v_includes( b3.vcenter() ) && b3.v_includes( b2.vcenter() ) && b1.bottom() < b2.top() && b1.bottom() < b3.top() ) { if( b1.height() > b2.height() && b1.height() > b3.height() ) { Character c1( new Blob( b1 ) ); c1.recognize1( charset, charbox( c1 ) ); if( c1.guesses() ) c = c1; } else { Character c2( new Blob( b2 ) ); Character c3( new Blob( b3 ) ); if( b2.h_includes( b1.hcenter() ) ) c2.shift_blobp( new Blob( b1 ) ); else if( b3.h_includes( b1.hcenter() ) ) c3.shift_blobp( new Blob( b1 ) ); c2.recognize1( charset, charbox( c2 ) ); c3.recognize1( charset, charbox( c3 ) ); if( c2.guesses() && c3.guesses() ) { c = c2; shift_characterp( new Character( c3 ) ); ++i; } } } } } // try to recognize separately the 2 overlapped blobs of an // unrecognized character for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( !c.guesses() && c.blobs() == 2 && c.blob( 0 ).v_overlaps( c.blob( 1 ) ) ) { Character c1( new Blob( c.blob( 0 ) ) ); c1.recognize1( charset, charbox( c1 ) ); Character c2( new Blob( c.blob( 1 ) ) ); c2.recognize1( charset, charbox( c2 ) ); if( ( c1.guesses() && c2.guesses() ) || Ocrad::similar( c1.height(), c2.height(), 20 ) ) { if( c1.height() > c2.height() ) c = c1; else { c = c2; c2 = c1; } // discards spurious dots if( !c2.maybe('.') || c2.top() > c.vcenter() ) { shift_characterp( new Character( c2 ) ); ++i; } } } } // remove speckles under the charbox' bottom of an unrecognized character for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( !c.guesses() && c.blobs() == 2 && c.blob( 0 ).size() > 10 * c.blob( 1 ).size() && c.blob( 1 ).top() > charbox( c ).bottom() ) { Character c1( new Blob( c.blob( 0 ) ) ); c1.recognize1( charset, charbox( c1 ) ); if( c1.guesses() ) c = c1; } } // remove speckles above the charbox' top of an unrecognized character for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( !c.guesses() && c.blobs() == 2 && c.blob( 1 ).size() > 5 * c.blob( 0 ).size() && c.blob( 0 ).bottom() + 2 * c.blob( 0 ).height() < charbox( c ).top() ) { Character c1( new Blob( c.blob( 1 ) ) ); c1.recognize1( charset, charbox( c1 ) ); if( c1.guesses() ) c = c1; } } // try to separate lightly merged characters // FIXME try relative minima (small pixel count surrounded by larger counts) // FIXME try all possible separation points // FIXME try other separation paths (an irregular line, not a column) // FIXME sometimes leaves unconnected blobs for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( !c.guesses() && c.width() > 20 && 5 * c.width() >= 3 * c.height() && 5 * c.height() >= 3 * mean_height() ) { int ib = c.blobs() - 1; for( int k = ib - 1; k >= 0; --k ) if( c.blob( k ).width() > c.blob( ib ).width() ) ib = k; if( ib < 0 || 10 * c.blob( ib ).width() < 9 * c.width() || c.blob( ib ).bottom() < c.bottom() ) continue; const Blob & b = c.blob( ib ); // widest blob int colmin = 0, cmin = b.height() + 1; for( int col = b.hpos( 30 ); col <= b.hpos( 70 ); ++col ) { int c = 0; for( int row = b.top(); row <= b.bottom(); ++row ) if( b.id( row, col ) ) ++c; if( c < cmin || ( c == cmin && col <= b.hcenter() ) ) { cmin = c; colmin = col; } } if( 4 * cmin > b.height() || ( 5 * cmin > b.height() && ( colmin <= b.hpos( 40 ) || colmin >= b.hpos( 60 ) ) ) ) continue; if( colmin <= b.left() || colmin >= b.right() ) continue; Rectangle r1( b.left(), b.top(), colmin - 1, b.bottom() ); Rectangle r2( colmin + 1, b.top(), b.right(), b.bottom() ); Blob b1( b, r1 ); b1.adjust_height(); if( 2 * b1.height() < b.height() ) continue; Blob b2( b, r2 ); b2.adjust_height(); if( 2 * b2.height() < b.height() ) continue; b1.find_holes(); b2.find_holes(); Character c1( new Blob( b1 ) ); Character c2( new Blob( b2 ) ); for( int j = 0; j < c.blobs(); ++j ) if( j != ib ) { const Blob & bj = c.blob( j ); if( c1.includes_hcenter( bj ) ) c1.shift_blobp( new Blob( bj ) ); else if( c2.includes_hcenter( bj ) ) c2.shift_blobp( new Blob( bj ) ); } c1.recognize1( charset, charbox( c1 ) ); c2.recognize1( charset, charbox( c2 ) ); if( ( c1.guesses() && c2.guesses() ) || ( ( c1.guesses() || c2.guesses() ) && c.width() > c.height() ) ) { c = c1; shift_characterp( new Character( c2 ) ); if( !c1.guesses() ) --i; else if( c2.guesses() ) ++i; } } } // try to recognize 1 blob unrecognized characters with holes by // removing small holes (noise) for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( !c.guesses() && c.blobs() == 1 && c.blob( 0 ).holes() ) { Character c1( c ); Blob & b = c1.blob( 0 ); for( int j = b.holes() - 1; j >= 0; --j ) if( 64 * b.hole( j ).size() <= b.size() || 16 * b.hole( j ).height() <= b.height() ) b.fill_hole( j ); if( b.holes() < c.blob( 0 ).holes() ) { c1.recognize1( charset, charbox( c1 ) ); if( c1.guesses() ) { c = c1; continue; } } /* if( b.holes() == 1 && 25 * b.hole( 0 ).size() < b.size() && Ocrad::similar( b.height(), b.width(), 40 ) ) { b.fill_hole( 0 ); c1.recognize1( charset, charbox( c1 ) ); if( c1.guesses() ) { c = c1; continue; } }*/ } } // separate merged characters recognized by recognize1 for( int i = big_initials(); i < characters(); ) { if( !cpv[i]->guesses() || cpv[i]->guess( 0 ).code >= 0 ) { ++i; continue; } const Character c( *cpv[i] ); const int blob_index = -(c.guess( 0 ).code + 1); delete_character( i ); if( c.guesses() >= 3 && c.blobs() >= 1 && blob_index < c.blobs() ) { int left = c.guess( 0 ).value; for( int g = 1; g < c.guesses(); ++g ) { Blob b( c.blob( blob_index ) ); Rectangle re( left, b.top(), c.guess( g ).value, b.bottom() ); b.add_rectangle( re ); Blob b1( b, re ); b1.adjust_height(); b1.adjust_width(); b1.find_holes(); Character c1( new Blob( b1 ) ); for( int k = 0; k < c.blobs(); ++k ) if( k != blob_index && !c.blob( k ).includes( re ) && re.includes_hcenter( c.blob( k ) ) ) c1.shift_blobp( new Blob( c.blob( k ) ) ); c1.add_guess( c.guess( g ).code, 0 ); shift_characterp( new Character( c1 ) ); left = re.right() + 1; } } } // choose between 'B' and 'a' for( int i = big_initials(), begin = i; i < characters(); ++i ) { Character & c1 = character( i ); if( c1.maybe(' ') ) { begin = i + 1 ; continue; } if( c1.guesses() ) { int code = c1.guess( 0 ).code; if( c1.guesses() != 2 || code != 'B' || c1.guess( 1 ).code != 'a' ) continue; if( 4 * c1.height() > 5 * mean_height() ) continue; for( int j = begin; j < characters(); ++j ) if( j != i ) { Character & c2 = character( j ); if( c2.maybe(' ') ) break; if( c2.guesses() >= 1 ) { int code2 = c2.guess( 0 ).code; if( code2 >= 128 ) continue; if( ( std::isupper( code2 ) && code2 != 'B' && code2 != 'Q' && 5 * c1.height() < 4 * c2.height() ) || ( UCS::islower_small( code2 ) && code2 != 'r' && !UCS::islower_small_ambiguous( code2 ) && ( c1.height() <= c2.height() || Ocrad::similar( c1.height(), c2.height(), 10 ) ) ) ) { c1.swap_guesses( 0, 1 ); break; } } } } } // choose between '8' and 'a' or 'e' for( int i = big_initials(), begin = i; i < characters(); ++i ) { Character & c1 = character( i ); if( c1.maybe(' ') ) { begin = i + 1 ; continue; } if( c1.guesses() == 2 && c1.guess( 1 ).code == '8' ) { int code = c1.guess( 0 ).code; if( ( code != 'a' && code != 'e' ) || 5 * c1.height() < 4 * mean_height() ) continue; for( int j = begin; j < characters(); ++j ) if( j != i ) { Character & c2 = character( j ); if( c2.maybe(' ') ) break; if( c2.guesses() >= 1 ) { int code2 = c2.guess( 0 ).code; if( code2 >= 128 ) continue; if( ( ( std::isalpha( code2 ) || code2 == ':' ) && 4 * c1.height() > 5 * c2.height() ) || ( ( std::isdigit( code2 ) || std::isupper( code2 ) || code2 == 'l' ) && ( c1.height() >= c2.height() || Ocrad::similar( c1.height(), c2.height(), 10 ) ) ) ) { c1.swap_guesses( 0, 1 ); break; } } } } } check_lower_ambiguous(); // transform 'i' into 'j' for( int i = big_initials(); i < characters(); ++i ) { Character & c1 = character( i ); if( c1.guesses() == 1 && c1.guess( 0 ).code == 'i' ) { int j = i + 1; if( j >= characters() || !character( j ).guesses() ) { j = i - 1; if( j < big_initials() || !character( j ).guesses() ) continue; } Character & c2 = character( j ); if( UCS::isvowel( c2.guess( 0 ).code ) && c1.bottom() >= c2.bottom() + ( c2.height() / 4 ) ) c1.insert_guess( 0, 'j', 1 ); } } // transform small o or u with accent or diaeresis to capital { int begin = big_initials(); bool isolated = false; // isolated letters compare with all line for( int i = big_initials(); i < characters(); ++i ) { Character & c1 = character( i ); if( c1.guesses() >= 1 ) { if( c1.maybe(' ') ) { if( i + 2 < characters() && character( i + 2 ).maybe(' ') ) { begin = big_initials(); isolated = true; } else { begin = i + 1; isolated = false; } continue; } int code = c1.guess( 0 ).code; if( code < 128 || c1.blobs() < 2 ) continue; int codeb = UCS::base_letter( code ); if( codeb != 'o' && codeb != 'u' ) continue; const Blob & b1 = c1.blob( c1.blobs() - 1 ); // lower blob for( int j = begin; j < characters(); ++j ) if( j != i ) { Character & c2 = character( j ); if( c2.guesses() >= 1 ) { if( c2.maybe(' ') ) { if( isolated ) continue; else break; } int code2 = c2.guess( 0 ).code; int code2b = UCS::base_letter( code2 ); if( !code2b && code2 >= 128 ) continue; if( ( std::isalpha( code2 ) && 4 * b1.height() > 5 * c2.height() ) || ( std::isupper( code2 ) && Ocrad::similar( b1.height(), c2.height(), 10 ) ) || ( std::isalpha( code2b ) && 4 * c1.height() > 5 * c2.height() ) || ( std::isupper( code2b ) && Ocrad::similar( c1.height(), c2.height(), 10 ) ) ) { c1.insert_guess( 0, UCS::toupper( code ), 1 ); break; } } } } } } // transform 'O' or 'l' into '0' or '1' for( int i = big_initials(), begin = i; i < characters(); ++i ) { Character & c1 = character( i ); if( c1.maybe(' ') ) { begin = i + 1 ; continue; } if( c1.guesses() >= 1 ) { int code = c1.guess( 0 ).code; if( code != 'o' && code != 'O' && code != 'l' ) continue; for( int j = begin; j < characters(); ++j ) if( j != i ) { Character & c2 = character( j ); if( c2.maybe(' ') ) break; if( c2.guesses() >= 1 ) { int code2 = c2.guess( 0 ).code; if( UCS::isdigit( code2 ) ) { if( Ocrad::similar( c1.height(), c2.height(), 10 ) ) c1.insert_guess( 0, (code == 'l') ? '1' : '0', c1.guess( 0 ).value + 1 ); break; } if( UCS::isalpha( code2 ) && code2 != 'o' && code2 != 'O' && code2 != 'l' ) break; } } } } // transform a small 'p' to a capital 'P' for( int i = characters() - 1; i >= big_initials(); --i ) { Character & c1 = character( i ); if( c1.guesses() == 1 && c1.guess( 0 ).code == 'p' ) { const int noise = std::max( 2, c1.height() / 20 ); bool cap = false, valid_c2 = false; if( i < characters() - 1 && character(i+1).guesses() ) { Character & c2 = character( i + 1 ); int code = c2.guess( 0 ).code; if( UCS::isalnum( code ) || code == '.' || code == '|' ) { valid_c2 = true; switch( code ) { case 'g': case 'j': case 'p': case 'q': case 'y': cap = ( c1.bottom() + noise <= c2.bottom() ); break; case 'Q': cap = ( std::abs( c1.top() - c2.top() ) <= noise ); break; default : cap = ( std::abs( c1.bottom() - c2.bottom() ) <= noise ); } } } if( !valid_c2 && i > big_initials() && !character(i-1).maybe(' ') ) cap = ( std::abs( c1.bottom() - charbox(c1).bottom() ) <= noise ); if( cap ) c1.only_guess( 'P', 0 ); } } // transform a capital 'Y' to a small 'y' for( int i = characters() - 1; i > big_initials(); --i ) { Character & c1 = character( i - 1 ); if( c1.guesses() == 1 && c1.guess( 0 ).code == 'Y' ) { Character & c2 = character( i ); if( !c2.guesses() ) continue; int code = c2.guess( 0 ).code; if( UCS::isalnum( code ) || code == '.' || code == '|' ) { switch( code ) { case 'g': case 'j': case 'p': case 'q': case 'y': if( c1.bottom() < c2.bottom() - 2 ) continue; break; case 'Q': if( c1.top() < c2.top() + 2 ) continue; break; default : if( c1.bottom() < c2.bottom() + 2 ) continue; } c1.only_guess( 'y', 0 ); } } } // transform a SSCEDI to a CSCEDI if( charset.enabled( Charset::iso_8859_9 ) ) for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( c.guesses() == 1 && c.guess( 0 ).code == UCS::SSCEDI ) { if( i > big_initials() && character( i - 1 ).guesses() ) { Character & c1 = character( i - 1 ); int code = c1.guess( 0 ).code; if( ( UCS::islower( code ) && c.top() < c1.top() - 2 ) || ( UCS::base_letter( code ) && code != UCS::SINODOT && Ocrad::similar( c.top(), c1.top(), 10 ) ) ) { c.insert_guess( 0, UCS::CSCEDI, 1 ); continue; } } if( i < characters() - 1 && character( i + 1 ).guesses() ) { Character & c1 = character( i + 1 ); int code = c1.guess( 0 ).code; if( ( UCS::islower( code ) && c.top() < c1.top() - 2 ) || ( UCS::base_letter( code ) && code != UCS::SINODOT && Ocrad::similar( c.top(), c1.top(), 10 ) ) ) { c.insert_guess( 0, UCS::CSCEDI, 1 ); continue; } } } } // transform words like 'lO.OOO' into numbers like '10.000' for( int begin = big_initials(), end = begin; begin < characters(); begin = end + 1 ) { end = find_space_or_hyphen( cpv, begin ); if( end - begin < 2 ) continue; Character & c1 = character( begin ); if( !c1.guesses() ) continue; int height = c1.height(); int code = c1.guess( 0 ).code; if( UCS::isdigit( code ) || code == 'l' || code == 'O' || code == 'o' ) { int digits = 1; int i = begin + 1; for( ; i < end; ++i ) { Character & c = character( i ); if( !c.guesses() ) break; bool valid = false; int code = c.guess( 0 ).code; if( ( UCS::isdigit( code ) || code == 'l' || code == 'O' || code == 'o' ) && Ocrad::similar( c.height(), height, 10 ) ) { valid = true; ++digits; } if( code == '.' || code == ',' || code == ':' || code == '+' || code == '-' ) valid = true; if( !valid ) break; } if( i >= end && digits >= 2 ) for( i = begin; i < end; ++i ) { Character & c = character( i ); int code = c.guess( 0 ).code; if( code == 'l' ) code = '1'; else if( code == 'O' || code == 'o' ) code = '0'; else code = 0; if( code ) c.insert_guess( 0, code, c.guess( 0 ).value + 1 ); } } } // detects Roman numerals 'II', 'III' and 'IIII' for( int begin = big_initials(), end = begin; begin < characters(); begin = end + 1 ) { end = find_space_or_hyphen( cpv, begin ); if( end - begin < 2 || end - begin > 4 ) continue; const int height = character( begin ).height(); int i; for( i = begin; i < end; ++i ) { Character & c = character( i ); if( !c.maybe('|') || !Ocrad::similar( c.height(), height, 10 ) ) break; } if( i >= end ) for( i = begin; i < end; ++i ) { Character & c = character( i ); if( !character(i).maybe('I') ) c.insert_guess( 0, 'I', c.guess( 0 ).value + 1 ); } } // choose between 'a' and 'Q' for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( c.guesses() == 2 && c.guess( 0 ).code == 'a' && c.guess( 1 ).code == 'Q' ) { if( 4 * c.height() > 5 * mean_height() ) { c.swap_guesses( 0, 1 ); check_lower_ambiguous(); continue; } if( i < characters() - 1 && character( i + 1 ).guesses() ) { const int code = character( i + 1 ).guess( 0 ).code; if( ( UCS::ishigh( code ) ) && 10 * c.height() > 9 * character( i + 1 ).height() ) { c.swap_guesses( 0, 1 ); check_lower_ambiguous(); continue; } } if( i > big_initials() && character( i - 1 ).guesses() ) { const int code = character( i - 1 ).guess( 0 ).code; if( ( UCS::ishigh( code ) ) && 10 * c.height() > 9 * character( i - 1 ).height() ) { c.swap_guesses( 0, 1 ); check_lower_ambiguous(); } } } } // transform a vertical bar into 'l' or 'I' (or a 'l' into an 'I') for( int i = big_initials(); i < characters(); ++i ) { Character & c = character( i ); if( c.guesses() != 1 ) continue; int code = c.guess( 0 ).code; if( code == '|' || code == 'l' ) { int lcode = 0, rcode = 0; if( i > 0 && character( i - 1 ).guesses() ) lcode = character( i - 1 ).guess( 0 ).code; if( i < characters() - 1 && character( i + 1 ).guesses() ) rcode = character( i + 1 ).guess( 0 ).code; if( ( UCS::isupper( rcode ) || UCS::isdigit( rcode ) ) && ( !lcode || UCS::isupper( lcode ) || !UCS::isalnum( lcode ) ) ) { c.insert_guess( 0, 'I', 1 ); continue; } if( code == 'l' ) continue; if( UCS::isalpha( lcode ) || UCS::isalpha( rcode ) ) { c.insert_guess( 0, 'l', 1 ); continue; } if( rcode == '|' && ( !lcode || !UCS::isalnum( lcode ) ) ) { if( i < characters() - 2 && character( i + 2 ).guesses() && UCS::isalpha( character( i + 2 ).guess( 0 ).code ) ) { c.insert_guess( 0, 'l', 1 ); continue; } if( i >= 2 && character( i - 2 ).guesses() && UCS::isalpha( character( i - 2 ).guess( 0 ).code ) ) { c.insert_guess( 0, 'l', 1 ); continue; } } } } // transform a vertical bar into 'I' at end of word for( int begin = big_initials(), end = begin; begin < characters(); begin = end + 1 ) { end = find_space_or_hyphen( cpv, begin ); if( end - begin < 3 ) continue; Character & ce = character( end - 1 ); if( !ce.maybe('|') || ce.maybe('I') ) continue; const int height = ce.height(); int i; for( i = begin; i < end - 1; ++i ) { const Character & c = character( i ); if( !c.guesses() ) break; const int code = c.guess( 0 ).code; if( ( !UCS::isupper( code ) && !UCS::isdigit( code ) ) || !Ocrad::similar( c.height(), height, 10 ) ) break; } if( i >= end - 1 ) ce.insert_guess( 0, 'I', ce.guess( 0 ).value + 1 ); } // transform 'l' or '|' into UCS::SINODOT if( charset.enabled( Charset::iso_8859_9 ) ) for( int i = big_initials(), begin = i; i < characters(); ++i ) { Character & c1 = character( i ); if( c1.maybe(' ') ) { begin = i + 1 ; continue; } if( c1.guesses() ) { int code = c1.guess( 0 ).code; if( code != 'l' && code != '|' ) continue; if( 4 * c1.height() > 5 * mean_height() ) continue; if( 5 * c1.height() < 4 * mean_height() ) { c1.only_guess( UCS::SINODOT, 0 ); continue; } bool capital = false, small = false; for( int j = begin; j < characters(); ++j ) if( j != i ) { Character & c2 = character( j ); if( c2.maybe(' ') ) break; if( !c2.guesses() ) continue; int code2 = c2.guess( 0 ).code; if( code2 >= 128 || !std::isalpha( code2 ) ) continue; if( !capital ) { if( 4 * c1.height() > 5 * c2.height() ) capital = true; else if( std::isupper( code2 ) && code2 != 'B' && code2 != 'Q' && ( c1.height() >= c2.height() || Ocrad::similar( c1.height(), c2.height(), 10 ) ) ) capital = true; } if( !small && std::islower( code2 ) && code2 != 'l' ) { if( 5 * c1.height() < 4 * c2.height() ) small = true; else if( UCS::islower_small( code2 ) && ( j < i || !UCS::islower_small_ambiguous( code2 ) ) && Ocrad::similar( c1.height(), c2.height(), 10 ) ) small = true; } } if( !capital && small ) c1.insert_guess( 0, UCS::SINODOT, 1 ); } } // join two adjacent single quotes into a double quote for( int i = big_initials(); i < characters() - 1; ++i ) { Character & c1 = character( i ); Character & c2 = character( i + 1 ); if( c1.guesses() == 1 && c2.guesses() == 1 ) { int code1 = c1.guess( 0 ).code; int code2 = c2.guess( 0 ).code; if( ( code1 == '\'' || code1 == '`' ) && code1 == code2 && 2 * ( c2.left() - c1.right() ) < 3 * c1.width() ) { c1.join( c2 ); c1.only_guess( '"', 0 ); delete_character( i + 1 ); } } } // join a comma followed by a period into a semicolon for( int i = big_initials(); i < characters() - 1; ++i ) { Character & c1 = character( i ); Character & c2 = character( i + 1 ); if( c1.guesses() == 1 && c2.guesses() == 1 ) { int code1 = c1.guess( 0 ).code; int code2 = c2.guess( 0 ).code; if( code1 == ',' && code2 == '.' && c1.top() > c2.bottom() && c2.left() - c1.right() < c2.width() ) { c1.join( c2 ); c1.only_guess( ';', 0 ); delete_character( i + 1 ); } } } // choose between '.' and '-' if( characters() >= 2 ) { Character & c = character( characters() - 1 ); if( c.guesses() >= 2 && c.guess( 0 ).code == '.' && c.guess( 1 ).code == '-' ) { const Character & lc = character( characters() - 2 ); if( lc.guesses() && UCS::isalpha( lc.guess( 0 ).code ) ) c.swap_guesses( 0, 1 ); } } // join a 'n' followed by a 'I' into a 'm' for( int i = big_initials(); i < characters() - 1; ++i ) { Character & c1 = character( i ); Character & c2 = character( i + 1 ); if( c1.guesses() == 1 && c2.guesses() == 1 ) { int code1 = c1.guess( 0 ).code; int code2 = c2.guess( 0 ).code; if( code1 == 'n' && ( code2 == 'I' || code2 == 'l' ) && Ocrad::similar( c1.height(), c2.height(), 10 ) && c2.left() - c1.right() < c2.width() ) { c1.join( c2 ); c1.only_guess( 'm', 0 ); delete_character( i + 1 ); } } } // join the secuence '°', '/', 'o', ' ' into a '%' for( int i = big_initials(); i + 2 < characters(); ++i ) { Character & c1 = character( i ); if( c1.guesses() == 1 && c1.guess( 0 ).code == UCS::DEG ) { if( character( i + 1 ).maybe('/') && character( i + 2 ).maybe('o') && ( i + 3 >= characters() || character( i + 3 ).maybe(' ') ) ) { c1.join( character( i + 1 ) ); c1.join( character( i + 2 ) ); delete_character( i + 2 ); delete_character( i + 1 ); c1.only_guess( '%', 0 ); } } } } ocrad-0.22/textpage.cc0000644000076400001440000004116412140443140013226 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include "common.h" #include "rectangle.h" #include "segment.h" #include "mask.h" #include "track.h" #include "bitmap.h" #include "blob.h" #include "character.h" #include "page_image.h" #include "textline.h" #include "textblock.h" #include "textpage.h" namespace { struct Zone { Mask mask; std::vector< Blob * > blobp_vector; Zone( const Rectangle & re ) : mask( re ) {} void join( Zone & z ); }; void Zone::join( Zone & z ) { mask.add_mask( z.mask ); blobp_vector.insert( blobp_vector.end(), z.blobp_vector.begin(), z.blobp_vector.end() ); z.blobp_vector.clear(); } int blobs_in_page( const std::vector< Zone > & zone_vector ) { int sum = 0; for( unsigned i = 0; i < zone_vector.size(); ++i ) sum += zone_vector[i].blobp_vector.size(); return sum; } void bprint( const std::vector< Zone > & zone_vector, FILE * const outfile ) { // std::fprintf( outfile, "page size %dw x %dh\n", width(), height() ); std::fprintf( outfile, "total zones in page %d\n", (int)zone_vector.size() ); std::fprintf( outfile, "total blobs in page %d\n\n", blobs_in_page( zone_vector ) ); for( unsigned zindex = 0; zindex < zone_vector.size(); ++zindex ) { const Rectangle & r = zone_vector[zindex].mask; const std::vector< Blob * > & blobp_vector = zone_vector[zindex].blobp_vector; std::fprintf( outfile, "zone %d of %d\n", zindex + 1, (int)zone_vector.size() ); std::fprintf( outfile, "zone size %dw x %dh\n", r.width(), r.height() ); std::fprintf( outfile, "total blobs in zone %u\n\n", (unsigned)zone_vector[zindex].blobp_vector.size() ); for( unsigned i = 0; i < blobp_vector.size(); ++i ) blobp_vector[i]->print( outfile ); } } inline void join_blobs( std::vector< Blob * > & blobp_vector, std::vector< Blob * > & v1, std::vector< Blob * > & v2, Blob * p1, Blob * p2, int i ) { if( p1->top() > p2->top() ) { Blob * const temp = p1; p1 = p2; p2 = temp; std::replace( v2.begin(), v2.begin() + ( i + 1 ), p2, p1 ); } else std::replace( v1.begin() + i, v1.end(), p2, p1 ); i = blobp_vector.size(); while( --i >= 0 && blobp_vector[i] != p2 ) ; if( i < 0 ) Ocrad::internal_error( "join_blobs, lost blob" ); blobp_vector.erase( blobp_vector.begin() + i ); p1->add_bitmap( *p2 ); delete p2; } void ignore_abnormal_blobs( std::vector< Blob * > & blobp_vector ) { for( int i = blobp_vector.size() - 1; i >= 0; --i ) { Blob & b = *blobp_vector[i]; if( b.height() > 35 * b.width() || b.width() > 25 * b.height() ) { delete blobp_vector[i]; blobp_vector.erase( blobp_vector.begin() + i ); } } } void ignore_small_blobs( std::vector< Blob * > & blobp_vector ) { int to = 0, blobs = blobp_vector.size(); for( int from = 0; from < blobs; ++from ) { Blob * const p = blobp_vector[from]; if( p->height() > 4 || p->width() > 4 || ( ( p->height() > 2 || p->width() > 2 ) && p->area() > 5 ) ) { blobp_vector[from] = blobp_vector[to]; blobp_vector[to] = p; ++to; } } if( to < blobs ) { for( int i = to; i < blobs; ++i ) delete blobp_vector[i]; blobp_vector.erase( blobp_vector.begin() + to, blobp_vector.end() ); } } void remove_top_bottom_noise( std::vector< Blob * > & blobp_vector ) { int blobs = blobp_vector.size(); for( int i = 0; i < blobs; ++i ) { Blob & b = *blobp_vector[i]; if( b.height() < 11 ) continue; int c = 0; for( int col = b.left(); col <= b.right(); ++col ) if( b.get_bit( b.top(), col ) && ++c > 1 ) break; if( c <= 1 ) b.top( b.top() + 1 ); c = 0; for( int col = b.left(); col <= b.right(); ++col ) if( b.get_bit( b.bottom(), col ) && ++c > 1 ) break; if( c <= 1 ) b.bottom( b.bottom() - 1 ); } } void remove_left_right_noise( std::vector< Blob * > & blobp_vector ) { int blobs = blobp_vector.size(); for( int i = 0; i < blobs; ++i ) { Blob & b = *blobp_vector[i]; if( b.width() < 6 ) continue; int c = 0; for( int row = b.top(); row <= b.bottom(); ++row ) if( b.get_bit( row, b.left() ) && ++c > 1 ) break; if( c <= 1 ) b.left( b.left() + 1 ); c = 0; for( int row = b.top(); row <= b.bottom(); ++row ) if( b.get_bit( row, b.right() ) && ++c > 1 ) break; if( c <= 1 ) b.right( b.right() - 1 ); } } void find_holes( std::vector< Zone > & zone_vector ) { for( unsigned zi = 0; zi < zone_vector.size(); ++zi ) { std::vector< Blob * > & blobp_vector = zone_vector[zi].blobp_vector; for( unsigned bvi = 0; bvi < blobp_vector.size(); ++bvi ) blobp_vector[bvi]->find_holes(); } } void ignore_wide_blobs( const Rectangle & re, std::vector< Blob * > & blobp_vector ) { for( unsigned i = 0; i < blobp_vector.size(); ) { Blob & b = *blobp_vector[i]; if( 2 * b.width() < re.width() ) { ++i; continue; } blobp_vector.erase( blobp_vector.begin() + i ); if( 4 * b.area() <= 3 * b.size() ) { int blobs = 0; for( unsigned j = i; j < blobp_vector.size(); ++j ) { if( blobp_vector[j]->top() > b.bottom() ) break; if( blobp_vector[j]->size() >= 16 ) ++blobs; } if( blobs <= b.size() / 400 ) { if( 4 * b.area() <= b.size() ) // thin grid or frame { delete &b; continue; } b.find_holes(); bool frame = false; if( b.holes() < std::min( b.height(), b.width() ) ) for( int j = 0; j < b.holes(); ++j ) { if( 4 * b.hole( j ).size() >= b.size() && 4 * b.hole( j ).area() >= b.size() ) { frame = true; break; } } if( frame ) { delete &b; continue; } } } // picture, not frame if( 5 * b.width() > 4 * re.width() && 5 * b.height() > 4 * re.height() ) { for( unsigned j = 0; j < blobp_vector.size(); ++j ) delete blobp_vector[j]; blobp_vector.clear(); delete &b; break; } for( unsigned j = blobp_vector.size(); j > i; ) { const Blob & b2 = *blobp_vector[--j]; if( b.includes( b2 ) ) { delete &b2; blobp_vector.erase( blobp_vector.begin() + j ); } } delete &b; } } int mean_blob_height( const std::vector< Blob * > & blobp_vector ) { int mean_height = 0; unsigned samples = 0; std::vector< int > height_distrib; for( unsigned i = 0; i < blobp_vector.size(); ++i ) { const unsigned h = blobp_vector[i]->height(); const unsigned w = blobp_vector[i]->width(); if( h < 10 || w >= 3 * h ) continue; if( h >= height_distrib.size() ) height_distrib.resize( h + 1 ); ++height_distrib[h]; ++samples; } if( !height_distrib.size() ) for( unsigned i = 0; i < blobp_vector.size(); ++i ) { const unsigned h = blobp_vector[i]->height(); if( h >= height_distrib.size() ) height_distrib.resize( h + 1 ); ++height_distrib[h]; ++samples; } int valid_samples = 0; for( unsigned i = 0, count = 0; i < height_distrib.size(); ++i ) { const int a = height_distrib[i]; if( 10 * ( count + a ) >= samples && 10 * count < 9 * samples ) { mean_height += a * i; valid_samples += a; } count += a; } if( valid_samples ) mean_height /= valid_samples; return mean_height; } int analyse_layout( std::vector< Blob * > & blobp_vector, std::vector< Zone > & zone_vector ) { if( !blobp_vector.size() ) return 0; const int mean_height = mean_blob_height( blobp_vector ); zone_vector.push_back( Zone( *blobp_vector[0] ) ); zone_vector.back().blobp_vector.push_back( blobp_vector[0] ); for( unsigned i = 1; i < blobp_vector.size(); ++i ) { Blob & b = *blobp_vector[i]; if( b.height() > 10 * mean_height ) { delete &b; continue; } int first = -1; for( unsigned j = 0; j < zone_vector.size(); ++j ) { if( zone_vector[j].mask.distance( b ) < 2 * mean_height ) { if( first < 0 ) first = j; else { zone_vector[first].join( zone_vector[j] ); zone_vector.erase( zone_vector.begin() + j ); --j; } } } if( first >= 0 ) { zone_vector[first].mask.add_rectangle( b ); zone_vector[first].blobp_vector.push_back( &b ); } else { zone_vector.push_back( Zone( b ) ); zone_vector.back().blobp_vector.push_back( &b ); } } blobp_vector.clear(); // sort zone_vector int botmax = ( zone_vector.size() ? zone_vector[0].mask.bottom() : 0 ); std::vector< int > cut_index_vector; for( unsigned i = 1; i < zone_vector.size(); ++i ) { if( zone_vector[i].mask.top() > botmax ) cut_index_vector.push_back( i ); botmax = std::max( botmax, zone_vector[i].mask.bottom() ); } cut_index_vector.push_back( zone_vector.size() ); for( unsigned begin = 0, cut = 0; cut < cut_index_vector.size(); ++cut ) { const unsigned end = cut_index_vector[cut]; for( unsigned i = begin; i + 1 < end; ++i ) { unsigned first = i; for( unsigned j = i + 1; j < end; ++j ) if( zone_vector[j].mask.precedes( zone_vector[first].mask ) ) first = j; if( first != i ) std::swap( zone_vector[i], zone_vector[first] ); } bool join = ( end - begin > 1 ); for( unsigned i = begin; join && i < end; ++i ) if( zone_vector[i].blobp_vector.size() > 80 || zone_vector[i].mask.v_distance( zone_vector[begin].mask ) > zone_vector[i].mask.height() + zone_vector[begin].mask.height() ) join = false; for( unsigned i = begin; join && i < end; ++i ) if( zone_vector[i].mask.height() > 4 * mean_blob_height( zone_vector[i].blobp_vector ) ) join = false; if( join ) { for( unsigned i = begin + 1; i < end; ++i ) zone_vector[begin].join( zone_vector[i] ); zone_vector.erase( zone_vector.begin() + ( begin + 1 ), zone_vector.begin() + end ); for( unsigned i = cut; i < cut_index_vector.size(); ++i ) cut_index_vector[i] -= ( end - begin - 1 ); ++begin; } else begin = end; } return zone_vector.size(); } void scan_page( const Page_image & page_image, std::vector< Zone > & zone_vector, const int debug_level, const bool layout ) { const Rectangle & re = page_image; const int zthreshold = page_image.threshold(); std::vector< Blob * > blobp_vector; std::vector< Blob * > old_data( re.width(), (Blob *) 0 ); std::vector< Blob * > new_data( re.width(), (Blob *) 0 ); for( int row = re.top(); row <= re.bottom(); ++row ) { old_data.swap( new_data ); for( int col = re.left(); col <= re.right(); ++col ) { const int dcol = col - re.left(); if( !page_image.get_bit( row, col, zthreshold ) ) new_data[dcol] = 0; // white pixel else // black pixel { Blob *p; Blob *lp = ( (dcol > 0) ? new_data[dcol-1] : 0 ); Blob *ltp = ( (dcol > 0) ? old_data[dcol-1] : 0 ); Blob *tp = old_data[dcol]; Blob *rtp = ( (col < re.right()) ? old_data[dcol+1] : 0 ); if( lp ) { p = lp; p->add_point( row, col ); } else if( ltp ) { p = ltp; p->add_point( row, col ); } else if( tp ) { p = tp; p->add_point( row, col ); } else if( rtp ) { p = rtp; p->add_point( row, col ); } else { p = new Blob( col, row, col, row ); p->set_bit( row, col, true ); blobp_vector.push_back( p ); } new_data[dcol] = p; if( rtp && p != rtp ) join_blobs( blobp_vector, old_data, new_data, p, rtp, dcol ); } } } if( debug_level <= 99 && blobp_vector.size() > 3 ) { ignore_wide_blobs( re, blobp_vector ); ignore_small_blobs( blobp_vector ); ignore_abnormal_blobs( blobp_vector ); remove_top_bottom_noise( blobp_vector ); remove_left_right_noise( blobp_vector ); } if( layout && re.width() > 200 && re.height() > 200 && blobp_vector.size() > 3 ) { analyse_layout( blobp_vector, zone_vector ); if( debug_level <= 99 && zone_vector.size() > 1 ) for( unsigned i = 0; i < zone_vector.size(); ++i ) ignore_wide_blobs( zone_vector[i].mask, zone_vector[i].blobp_vector ); } else { zone_vector.push_back( Zone( re ) ); zone_vector.back().blobp_vector.swap( blobp_vector ); } find_holes( zone_vector ); } } // end namespace Textpage::Textpage( const Page_image & page_image, const char * const filename, const Control & control, const bool layout ) : Rectangle( page_image ), name( filename ) { const int debug_level = control.debug_level; if( debug_level < 0 || debug_level > 100 ) return; std::vector< Zone > zone_vector; // layout zones scan_page( page_image, zone_vector, debug_level, layout ); if( verbosity > 0 ) std::fprintf( stderr, "number of text blocks = %d\n", (int)zone_vector.size() ); if( debug_level >= 98 ) { if( control.outfile ) bprint( zone_vector, control.outfile ); return; } if( debug_level > 95 || ( debug_level > 89 && debug_level < 94 ) ) return; // build a Textblock for every zone with text for( unsigned i = 0; i < zone_vector.size(); ++i ) { Textblock * const tbp = new Textblock( page_image, zone_vector[i].mask, zone_vector[i].blobp_vector ); if( tbp->textlines() && debug_level < 90 ) tbp->recognize( control.charset, control.filter ); if( tbp->textlines() ) tbpv.push_back( tbp ); else delete tbp; } if( debug_level == 0 ) return; if( !control.outfile ) return; if( debug_level >= 86 ) { bool graph = ( debug_level >= 88 ); bool recursive = ( debug_level & 1 ); for( int i = 0; i < textblocks(); ++i ) tbpv[i]->dprint( control, graph, recursive ); return; } if( debug_level > 77 ) return; if( debug_level >= 70 ) { Page_image tmp( page_image ); if( ( debug_level - 70 ) & 1 ) // mark zones for( unsigned i = 0; i < zone_vector.size(); ++i ) { if( debug_level == 71 ) tmp.draw_mask( zone_vector[i].mask ); else tmp.draw_rectangle( zone_vector[i].mask ); } if( ( debug_level - 70 ) & 2 ) // mark lines { for( int i = 0; i < textblocks(); ++i ) tbpv[i]->lmark( tmp ); } if( ( debug_level - 70 ) & 4 ) // mark characters { for( int i = 0; i < textblocks(); ++i ) tbpv[i]->cmark( tmp ); } tmp.save( control.outfile, control.filetype ); return; } } Textpage::~Textpage() { for( int i = textblocks() - 1; i >= 0; --i ) delete tbpv[i]; } const Textblock & Textpage::textblock( const int i ) const { if( i < 0 || i >= textblocks() ) Ocrad::internal_error( "Textpage::textblock, index out of bounds" ); return *(tbpv[i]); } int Textpage::textlines() const { int total = 0; for( int i = 0; i < textblocks(); ++i ) total += tbpv[i]->textlines(); return total; } int Textpage::characters() const { int total = 0; for( int i = 0; i < textblocks(); ++i ) total += tbpv[i]->characters(); return total; } void Textpage::print( const Control & control ) const { if( control.outfile ) for( int i = 0; i < textblocks(); ++i ) tbpv[i]->print( control ); } void Textpage::xprint( const Control & control ) const { if( !control.exportfile ) return; std::fprintf( control.exportfile, "source file %s\n", name.c_str() ); std::fprintf( control.exportfile, "total text blocks %d\n", textblocks() ); for( int i = 0; i < textblocks(); ++i ) { const Textblock & tb = *(tbpv[i]); std::fprintf( control.exportfile, "text block %d %d %d %d %d\n", i + 1, tb.left(), tb.top(), tb.width(), tb.height() ); tb.xprint( control ); } } ocrad-0.22/track.cc0000644000076400001440000002307712123636414012525 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include "common.h" #include "rectangle.h" #include "track.h" namespace { void error( const char * const msg ) { Ocrad::internal_error( msg ); } int good_reference( const Rectangle & r1, const Rectangle & r2, int & val, const int mean_height, const int mean_width ) { if( 4 * r1.height() >= 3 * mean_height && 4 * r2.height() >= 3 * mean_height && ( r1.width() >= mean_width || r2.width() >= mean_width ) && val > 0 ) { if( 4 * r1.height() <= 5 * mean_height && 4 * r2.height() <= 5 * mean_height ) { if( 9 * r1.height() <= 10 * mean_height && 9 * r2.height() <= 10 * mean_height && 10 * std::abs( r1.bottom() - r2.bottom() ) <= mean_height ) { val = 0; return ( r1.height() <= r2.height() ) ? 0 : 1; } if( val > 1 && 10 * std::abs( r1.vcenter() - r2.vcenter() ) <= mean_height ) { val = 1; return ( r1.bottom() <= r2.bottom() ) ? 0 : 1; } } if( val > 2 && 10 * std::abs( r1.vcenter() - r2.vcenter() ) <= mean_height ) { val = 2; return ( r1.bottom() <= r2.bottom() ) ? 0 : 1; } } return -1; } int set_l( const std::vector< Rectangle > & rectangle_vector, const int mean_height, const int mean_width ) { const int rectangles = rectangle_vector.size(); const int imax = rectangles / 4; int ibest = -1, val = 3; for( int i1 = 0; i1 < imax && val > 0; ++i1 ) for( int i2 = i1 + 1; i2 <= imax && i2 <= i1 + 2; ++i2 ) { int i = good_reference( rectangle_vector[i1], rectangle_vector[i2], val, mean_height, mean_width ); if( i >= 0 ) { ibest = (i == 0) ? i1 : i2; if( val == 0 ) break; } } return ibest; } int set_r( const std::vector< Rectangle > & rectangle_vector, const int mean_height, const int mean_width ) { const int rectangles = rectangle_vector.size(); const int imin = rectangles - 1 - ( rectangles / 4 ); int ibest = -1, val = 3; for( int i1 = rectangles - 1; i1 > imin && val > 0; --i1 ) for( int i2 = i1 - 1; i2 >= imin && i2 >= i1 - 2; --i2 ) { int i = good_reference( rectangle_vector[i1], rectangle_vector[i2], val, mean_height, mean_width ); if( i >= 0 ) { ibest = (i == 0) ? i1 : i2; if( val == 0 ) break; } } return ibest; } Vrhomboid set_partial_track( const std::vector< Rectangle > & rectangle_vector ) { const int rectangles = rectangle_vector.size(); int mean_vcenter = 0, mean_height = 0, mean_width = 0; for( int i = 0; i < rectangles; ++i ) { mean_vcenter += rectangle_vector[i].vcenter(); mean_height += rectangle_vector[i].height(); mean_width += rectangle_vector[i].width(); } if( rectangles ) { mean_vcenter /= rectangles; mean_height /= rectangles; mean_width /= rectangles; } // short line if( rectangles < 8 ) return Vrhomboid( rectangle_vector.front().left(), mean_vcenter, rectangle_vector.back().right(), mean_vcenter, mean_height ); // look for reference rectangles (characters) int l = set_l( rectangle_vector, mean_height, mean_width ); int r = set_r( rectangle_vector, mean_height, mean_width ); int lcol, lvc, rcol, rvc; if( l >= 0 ) { lcol = rectangle_vector[l].hcenter(); lvc = rectangle_vector[l].bottom() - ( mean_height / 2 ); } else { lcol = rectangle_vector.front().hcenter(); lvc = mean_vcenter; } if( r >= 0 ) { rcol = rectangle_vector[r].hcenter(); rvc = rectangle_vector[r].bottom() - ( mean_height / 2 ); } else { rcol = rectangle_vector.back().hcenter(); rvc = mean_vcenter; } Vrhomboid tmp( lcol, lvc, rcol, rvc, mean_height ); tmp.extend_left( rectangle_vector.front().left() ); tmp.extend_right( rectangle_vector.back().right() ); return tmp; } } // end namespace Vrhomboid::Vrhomboid( const int l, const int lc, const int r, const int rc, const int h ) { if( r < l || h <= 0 ) { if( verbosity >= 0 ) std::fprintf( stderr, "l = %d, lc = %d, r = %d, rc = %d, h = %d\n", l, lc, r, rc, h ); error( "bad parameter building a Vrhomboid" ); } left_ = l; lvcenter_ = lc; right_ = r; rvcenter_ = rc; height_ = h; } void Vrhomboid::left( const int l ) { if( l > right_ ) error( "left, bad parameter resizing a Vrhomboid" ); left_ = l; } void Vrhomboid::right( const int r ) { if( r < left_ ) error( "right, bad parameter resizing a Vrhomboid" ); right_ = r; } void Vrhomboid::height( const int h ) { if( h <= 0 ) error( "height, bad parameter resizing a Vrhomboid" ); height_ = h; } void Vrhomboid::extend_left( const int l ) { if( l > right_ ) error( "extend_left, bad parameter resizing a Vrhomboid" ); lvcenter_ = vcenter( l ); left_ = l; } void Vrhomboid::extend_right( const int r ) { if( r < left_ ) error( "extend_right, bad parameter resizing a Vrhomboid" ); rvcenter_ = vcenter( r ); right_ = r; } int Vrhomboid::vcenter( const int col ) const { const int dx = right_ - left_, dy = rvcenter_ - lvcenter_; int vc = lvcenter_; if( dx && dy ) vc += ( dy * ( col - left_ ) ) / dx; return vc; } bool Vrhomboid::includes( const Rectangle & r ) const { if( r.left() < left_ || r.right() > right_ ) return false; const int tl = top( r.left() ), bl = bottom( r.left() ); const int tr = top( r.right() ), br = bottom( r.left() ); const int t = std::max( tl, tr ), b = std::min( bl, br ); return ( t <= r.top() && b >= r.bottom() ); } bool Vrhomboid::includes( const int row, const int col ) const { if( col < left_ || col > right_ ) return false; const int t = top( col ), b = bottom( col ); return ( t <= row && b >= row ); } // rectangle_vector must be ordered by increasing hcenter(). // void Track::set_track( const std::vector< Rectangle > & rectangle_vector ) { if( data.size() ) data.clear(); if( !rectangle_vector.size() ) return; std::vector< Rectangle > tmp; int max_gap = 0; bool last = false; { int s1 = rectangle_vector[0].width(), s2 = 0; for( unsigned i = 1; i < rectangle_vector.size(); ++i ) { s1 += rectangle_vector[i].width(); s2 += ( rectangle_vector[i].left() - rectangle_vector[i-1].right() ); } max_gap = ( 5 * std::max( s1, s2 ) ) / rectangle_vector.size(); } for( unsigned i = 0; i < rectangle_vector.size(); ++i ) { const Rectangle & r1 = rectangle_vector[i]; tmp.push_back( r1 ); if( i + 1 >= rectangle_vector.size() ) last = true; else { const Rectangle & r2 = rectangle_vector[i+1]; if( r2.left() - r1.right() >= max_gap ) last = true; } if( last ) { last = false; data.push_back( set_partial_track( tmp ) ); tmp.clear(); } } for( unsigned i = 0; i + 1 < data.size(); ++i ) { const Vrhomboid & v1 = data[i]; const Vrhomboid & v2 = data[i+1]; if( v1.right() + 1 < v2.left() ) { Vrhomboid v( v1.right() + 1, v1.rvcenter(), v2.left() - 1, v2.lvcenter(), ( v1.height() + v2.height() ) / 2 ); ++i; data.insert( data.begin() + i, v ); } } } int Track::bottom( const int col ) const { for( unsigned i = 0; i < data.size(); ++i ) { const Vrhomboid & vr = data[i]; if( col <= vr.right() || i >= data.size() - 1 ) return vr.bottom( col ); } return 0; } int Track::top( const int col ) const { for( unsigned i = 0; i < data.size(); ++i ) { const Vrhomboid & vr = data[i]; if( col <= vr.right() || i >= data.size() - 1 ) return vr.top( col ); } return 0; } int Track::vcenter( const int col ) const { for( unsigned i = 0; i < data.size(); ++i ) { const Vrhomboid & vr = data[i]; if( col <= vr.right() || i >= data.size() - 1 ) return vr.vcenter( col ); } return 0; } bool Track::includes( const Rectangle & r ) const { for( unsigned i = 0; i < data.size(); ++i ) if( data[i].includes( r ) ) return true; if( !data.size() ) return false; if( r.right() > data.back().right() ) { Vrhomboid tmp = data.back(); tmp.extend_right( r.right() ); return tmp.includes( r ); } if( r.left() < data.front().left() ) { Vrhomboid tmp = data.front(); tmp.extend_left( r.left() ); return tmp.includes( r ); } return false; } bool Track::includes( const int row, const int col ) const { for( unsigned i = 0; i < data.size(); ++i ) if( data[i].includes( row, col ) ) return true; if( !data.size() ) return false; if( col > data.back().right() ) { Vrhomboid tmp = data.back(); tmp.extend_right( col ); return tmp.includes( row, col ); } if( col < data.front().left() ) { Vrhomboid tmp = data.front(); tmp.extend_left( col ); return tmp.includes( row, col ); } return false; } ocrad-0.22/ucs.cc0000644000076400001440000002457612147127610012217 0ustar yousers/* GNU Ocrad - Optical Character Recognition program Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include "ucs.h" int UCS::base_letter( const int code ) { switch( code ) { case CAGRAVE: case CAACUTE: case CACIRCU: case CATILDE: case CADIAER: case CARING : return 'A'; case CCCEDI : return 'C'; case CEGRAVE: case CEACUTE: case CECIRCU: case CEDIAER: return 'E'; case CGBREVE: return 'G'; case CIGRAVE: case CIACUTE: case CICIRCU: case CIDIAER: case CIDOT : return 'I'; case CNTILDE: return 'N'; case COGRAVE: case COACUTE: case COCIRCU: case COTILDE: case CODIAER: return 'O'; case CSCEDI : return 'S'; case CUGRAVE: case CUACUTE: case CUCIRCU: case CUDIAER: return 'U'; case CYACUTE: return 'Y'; case SAGRAVE: case SAACUTE: case SACIRCU: case SATILDE: case SADIAER: case SARING : return 'a'; case SCCEDI : return 'c'; case SEGRAVE: case SEACUTE: case SECIRCU: case SEDIAER: return 'e'; case SGBREVE: return 'g'; case SIGRAVE: case SIACUTE: case SICIRCU: case SIDIAER: case SINODOT: return 'i'; case SNTILDE: return 'n'; case SOGRAVE: case SOACUTE: case SOCIRCU: case SOTILDE: case SODIAER: return 'o'; case SSCEDI : return 's'; case SUGRAVE: case SUACUTE: case SUCIRCU: case SUDIAER: return 'u'; case SYACUTE: case SYDIAER: return 'y'; default: return 0; } } int UCS::compose( const int letter, const int accent ) { switch( letter ) { case 'A': if( accent == '\'') return CAACUTE; if( accent == '`' ) return CAGRAVE; if( accent == '^' ) return CACIRCU; if( accent == ':' ) return CADIAER; break; case 'E': if( accent == '\'') return CEACUTE; if( accent == '`' ) return CEGRAVE; if( accent == '^' ) return CECIRCU; if( accent == ':' ) return CEDIAER; break; case 'G': return CGBREVE; case '[': case 'I': if( accent == '\'') return CIACUTE; if( accent == '`' ) return CIGRAVE; if( accent == '^' ) return CICIRCU; if( accent == ':' ) return CIDIAER; break; case 'N': if( accent != ':' ) return CNTILDE; break; case 'O': if( accent == '\'') return COACUTE; if( accent == '`' ) return COGRAVE; if( accent == '^' ) return COCIRCU; if( accent == ':' ) return CODIAER; break; case 'S': return CSCARON; case 'U': case 'V': if( accent == '\'') return CUACUTE; if( accent == '`' ) return CUGRAVE; if( accent == '^' ) return CUCIRCU; if( accent == ':' ) return CUDIAER; break; case 'Z': return CZCARON; case 'a': if( accent == '\'') return SAACUTE; if( accent == '`' ) return SAGRAVE; if( accent == '^' ) return SACIRCU; if( accent == ':' ) return SADIAER; break; case 'e': if( accent == '\'') return SEACUTE; if( accent == '`' ) return SEGRAVE; if( accent == '^' ) return SECIRCU; if( accent == ':' ) return SEDIAER; break; case '9': case 'g': return SGBREVE; case '|': case ']': case 'i': case 'l': if( accent == '\'') return SIACUTE; if( accent == '`' ) return SIGRAVE; if( accent == '^' ) return SICIRCU; if( accent == ':' ) return SIDIAER; break; case 'n': if( accent != ':' ) return SNTILDE; break; case 'o': if( accent == '\'') return SOACUTE; if( accent == '`' ) return SOGRAVE; if( accent == '^' ) return SOCIRCU; if( accent == ':' ) return SODIAER; break; case 's': return SSCARON; case 'u': case 'v': if( accent == '\'') return SUACUTE; if( accent == '`' ) return SUGRAVE; if( accent == '^' ) return SUCIRCU; if( accent == ':' ) return SUDIAER; break; case 'y': if( accent == '\'') return SYACUTE; if( accent == ':' ) return SYDIAER; break; case 'z': return SZCARON; } return 0; } bool UCS::isalnum( const int code ) { return ( UCS::isalpha( code ) || UCS::isdigit( code ) ); } bool UCS::isalpha( const int code ) { return ( ( code < 128 && std::isalpha( code ) ) || base_letter( code ) ); } bool UCS::isdigit( const int code ) { return ( code <= '9' && code >= '0' ); } bool UCS::ishigh( const int code ) { if( isupper( code ) || isdigit( code ) ) return true; switch( code ) { case 'b': case 'd': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'p': case 'q': case 't': case 'y': case '|': return true; default : return false; } } bool UCS::islower( const int code ) { if( code < 128 && std::islower( code ) ) return true; const int base = base_letter( code ); return ( base && std::islower( base ) ); } bool UCS::islower_ambiguous( const int code ) { if( islower_small_ambiguous( code ) ) return true; switch( code ) { case 'k': case 'p': case SCCEDI: case SIGRAVE: case SIACUTE: case SICIRCU: case SIDIAER: case SOGRAVE: case SOACUTE: case SOCIRCU: case SOTILDE: case SODIAER: case SUGRAVE: case SUACUTE: case SUCIRCU: case SUDIAER: case SSCEDI: case SSCARON: case SZCARON: return true; default : return false; } } bool UCS::islower_small( const int code ) { if( code >= 128 || !std::islower( code ) ) return false; switch( code ) { case 'a': case 'c': case 'e': case 'm': case 'n': case 'o': case 'r': case 's': case 'u': case 'v': case 'w': case 'x': case 'z': return true; default : return false; } } bool UCS::islower_small_ambiguous( const int code ) { if( code >= 128 || !std::islower( code ) ) return false; switch( code ) { case 'c': case 'o': case 's': case 'u': case 'v': case 'w': case 'x': case 'z': return true; default : return false; } } bool UCS::isspace( const int code ) { return ( code < 128 && std::isspace( code ) ); } bool UCS::isupper( const int code ) { if( code < 128 && std::isupper( code ) ) return true; const int base = base_letter( code ); return ( base && std::isupper( base ) ); } bool UCS::isvowel( int code ) { if( code >= 128 ) code = base_letter( code ); if( !code || !std::isalpha( code ) ) return false; code = std::tolower( code ); return ( code == 'a' || code == 'e' || code == 'i' || code == 'o' || code == 'u' ); } unsigned char UCS::map_to_byte( const int code ) { if( code < 0 ) return 0; if( code < 256 ) return code; switch( code ) { case CGBREVE: return 0xD0; case SGBREVE: return 0xF0; case CIDOT : return 0xDD; case SINODOT: return 0xFD; case CSCEDI : return 0xDE; case SSCEDI : return 0xFE; case CSCARON: return 0xA6; case SSCARON: return 0xA8; case CZCARON: return 0xB4; case SZCARON: return 0xB8; case EURO : return 0xA4; default : return 0; } } const char * UCS::ucs_to_utf8( const int code ) { static char s[7]; if( code < 0 || code > 0x7FFFFFFF ) { s[0] = 0; return s; } // invalid code if( code < 128 ) { s[0] = code; s[1] = 0; return s; } // plain ascii int i, mask; if( code < 0x800 ) { i = 2; mask = 0xC0; } // 110X XXXX else if( code < 0x10000 ) { i = 3; mask = 0xE0; } // 1110 XXXX else if( code < 0x200000 ) { i = 4; mask = 0xF0; } // 1111 0XXX else if( code < 0x4000000 ) { i = 5; mask = 0xF8; } // 1111 10XX else { i = 6; mask = 0xFC; } // 1111 110X s[i] = 0; --i; int d = 0; for( ; i > 0; --i, d+=6 ) s[i] = 0x80 | ( ( code >> d ) & 0x3F ); // 10XX XXXX s[0] = mask | ( code >> d ); return s; } int UCS::to_nearest_digit( const int code ) { switch( code ) { case 'O': case 'Q': case 'o': return '0'; case '|': case 'I': case 'L': case 'l': case SINODOT: return '1'; case 'Z': case 'z': return '2'; case 'A': case 'q': return '4'; case 'S': case 's': return '5'; case 'G': case 'b': case SOACUTE: return '6'; case 'J': case 'T': return '7'; case '&': case 'B': return '8'; case 'g': return '9'; default: return code; } } int UCS::to_nearest_letter( const int code ) { switch( code ) { case '0': return 'O'; case '1': return 'l'; case '2': return 'Z'; case '4': return 'q'; case '5': return 'S'; case '6': return SOACUTE; case '7': return 'I'; case '8': return 'B'; case '9': return 'g'; default: return code; } } int UCS::toupper( const int code ) { if( code < 128 ) return std::toupper( code ); switch( code ) { case SAGRAVE: return CAGRAVE; case SAACUTE: return CAACUTE; case SACIRCU: return CACIRCU; case SATILDE: return CATILDE; case SADIAER: return CADIAER; case SARING : return CARING; case SCCEDI : return CCCEDI; case SEGRAVE: return CEGRAVE; case SEACUTE: return CEACUTE; case SECIRCU: return CECIRCU; case SEDIAER: return CEDIAER; case SGBREVE: return CGBREVE; case SIGRAVE: return CIGRAVE; case SIACUTE: return CIACUTE; case SICIRCU: return CICIRCU; case SIDIAER: return CIDIAER; case SNTILDE: return CNTILDE; case SOGRAVE: return COGRAVE; case SOACUTE: return COACUTE; case SOCIRCU: return COCIRCU; case SOTILDE: return COTILDE; case SODIAER: return CODIAER; case SSCEDI : return CSCEDI; case SUGRAVE: return CUGRAVE; case SUACUTE: return CUACUTE; case SUCIRCU: return CUCIRCU; case SUDIAER: return CUDIAER; case SYACUTE: return CYACUTE; default: return code; } }