bug News & Bugs

  • Switch to the latest C compilers also for Fedora64 (gcc 10.2.1 20201125 (Red Hat 10.2.1-9)).
  • Memory leaks in ReSpell with set parameter REL_REPEAT.
  • Switch to the latest C compilers for Android (Android SDK Platform 30), iOS/OSX (clang version 10.0.0), Ubuntu64 (gcc-9 (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0). Providing Kadmos for the Windows C compiler MSVC19. Programming around some compiler bugs of Android and MSVC19.
  • Inconsistent return of the coordinates of the recognized characters in REL and REP. Examples how to get the original coordinates in the provided image are given in the demo programs RelDemo, RelWin, RepDemo and RepWin in the KADMOS SDK.
  • Improved classifiers norm*.rec.
  • New classifiers jumbo??.rec, hand??.rec and ttf??.rec. They are much smaller and comparable with the former classifiers hand_s_??.rec and ttf_s_??.rec. The latter thus are obsolete.
  • In all classifiers hand??.rec the digits 5 to 8 were missing.
  • Bug in rec_accent() with distinction of (multiple) accented characters and special signs which consist of multiple components (:, ;, ..).
  • Crashes in rep_do() when GENERAL_REPMULTITHREADING had been set. This parameter should not be set in server versions of KADMOS, when several KADMOS instances are started in parallel. For this reason it isn't default any more in server mode.
  • Improved recognition of multiple accented characters (Vietnam).
  • New computation of all classifiers jumbo*.rec, hand*.rec, ttf*.rec and num*.rec.
  • Improved segmentation for proportional fonts in rel_do().
  • New machine print labels Unicode 1EA0, 1EA1, 1EB8, 1EB9, 1ECA, 1ECB, 1ECC, 1ECD, 1EE4, 1EE5, 1EF4, 1EF5, 1EE2, 1EE3, 1EF0, and 1EF1 (Vietnam) in the classifiers jumbo, ttf, ttfvn, ttf_s, and ttf_s_vn.
  • Incorrect reading of TIFF files under LINUX 64 bit.
  • Update of the used TIFF library from 3.9.6 to 4.0.10.
  • Crashes with nonsense images under multithreading in rel_do().
  • Wrong coordinates of the recognized characters with noisy images in rel_do().
  • Improved classifiers ttf??.rec and ttf_s_??.rec, especially for Vietnanmese.
  • Wrong coordinates of the recognized characters with noisy images in rep_do().
  • Missing characters with re_layout() and re_page().
  • Crashes in rel_do() with classifiers containing both machine print characters capital O and zero.
  • KADMOS 6.1a available.
    In the KADMOS classifier programs (which are invisible for KADMOS users) essential improvements could be implemented. To apply those improvements for recognition, all classifiers had to be recomputed. Over several months all our computers in Kreuzlingen had been working day and night. The result is a remarkable improvement of isolated character recognition.
    All other interfaces have remained unchanged from version 6.0.
  • In rare cases endless loop in rel_do() with recognition of nonsense images.
  • In rare cases endless loop with recognition of diacritical characters.
  • Complete recomputation of the classifiers ttf_s.rec with improved algorithms.
  • In rare cases with recognition of diacritical characters some components disappeared.
  • Binarisation of gray images sometimes generated black rectangles.
  • Recognition of Thai sometimes generated invalid character combinations.
  • Very rare, very old bug in alternative segmentation, resulting in an endless loop in RelGraph.
  • New classifiers Jumbo??.rec, Hand??.rec, and Ttf??.rec with punctual imrovements, especially for Hebrew and Thai.
  • In very rare cases double output of characters by re*_textline().
  • Bug in the subroutine chopkern. So RecMaker, Chopper, and Alcfill didn't work correctly.
  • Error in label translation from and to Unicode/UTF_16.
  • Rare crash in the OpenSource Hunspell.dll.
  • The Kadmos 6.0 libraries and dlls now also are available as MSVC17 version.
  • Too long (nonsense) computation of spaces between blocks in almost empty documents by re_layout().
  • Rare crash (protection error) in re_layout().
  • Label-selection got lost with subsequent rel_do()-calls.
  • Rare crash in rel_do() and so also in rep_do() and re_page().
  • With neatly written hand print, the mixed classifiers jumbo*.rec and num*.rec sometimes activated their machine print part only for recognition.
  • The haracter LATIN SMALL LETTER ALPHA (Unicode 0x0215) was missing in the list of accented characters.
  • Rare crash in re_layout(), and so also in re_page() and re_idcard().
  • Reading of PDF files is implemented.
  • Improved recognition of Thai, Cyrillic, and Hebrew.
  • 10% higher recognition speed of rec_do() for new Intel processors.
  • Improved recognition of multiple accented characters (Vietnamese).
  • New classifiers (rec files) jumbo??.rec, ttf??.rec, and hand??.rec.
  • Improved function re_layout().
  • New classifiers (rec files) ttf_s_??.rec and hand_s_??.rec.
  • Error in re?_textline() for Thai.
  • Memoryleak in re_readimage() from TIFF files.
  • Memoryleak in rel_do().
  • Access violation in rec_accent().
  • Error in label selection.
  • Unnecessary high memory allocation with the 64 bit versions of Kadmos for Windows and Linux.
  • Error in the parameter functions re_copyparm(), re_readparm(), and re?_config().
  • Bug in data collection via kadmos.ini under multithreading.
  • Improved Hebrew classifier. Improved BIDI algorithm for the output of texts with bidirectional writing direction, for instance Hebrew+Latin.
  • Improved classifier fot Vietnamese machine print.
  • Extension of the classifier hand_s.rec with the most common accents.
  • Error in re_collect with raster image collection.
  • Implementation of the BIDI algorithm for the output of texts with bidirectional writing direction, for instance hebrew+latin.
  • Improved recognition of accented characters, for instance Vietnamese.
  • Generation of the related Unicode, marked by RESULT_FLAG_REC_COMBINED.
  • In some cases incorrect coordinates of the recognized characters were returned.
  • Rare endless loop in rel_do().
  • Error in rep_do() if lines got empty with noise removal.
  • Error in re_endofimagefile() for TIFF files.
  • Improved function rec_accent().
  • Improved classifier ttf_s.rec.
  • New ligature "LI" to avoid substitutions with 'U'.
  • Now also JPEG compressed TIFF files can be read.
  • Crash in re_page().
  • Incompletely returned results in re_page().
  • Generation of the Kadmos libraries and dlls with MSVC15.
  • Memory problems when rec_accent() had been called with color (RGB) images.
  • Bug in the combination of rec_accent() and rel_do() with set parameter TYPO_KEEPIMG.
  • Parameter TYPO_KEEPIMG now also working for rec_accent().
  • New function rec_freeimages() to release the related memory after the rec_accent() call.
  • Rare protection error with grid removal.
  • Sometimes incorrect coordinates were returned for characters in subimages or deskewed images.
  • With grid detection in rel_do(), the value of rel_grid_len had not been returned correctly.
  • New parameters OPTIONS_FAST_REC and OPTIONS_FAST_GRID. OPTIONS_FAST_REC replaces the old parameter OPTIONS_FAST. OPTIONS_FAST_GRID activates a faster grid detection with almost same results. OPTIONS_FAST_GRID can also set with re_layout() as well as new parameter with re_page().
  • New function rel_rec_accent_set(). It works like rel_recset(), but with results of rec_accent().
Up to now Kadmos supported recognition of single characters, lines, and paragraphs. Now the recognition of almost any documents is supported. For this a new function re_layout() is provided. It looks in documents for text areas and returns their positions as circumscribing rectangles. With the more comprehensive function re_page() the text areas can assigned classifiers, with which automatically recognition of those text areas is performed.
Kadmos is applied extensively for reading the coding lines of ID cards and passports. One common problem here is image preprocessing and finding the coding lines themselves. For this applications a special function rep_idcard() is provided. It delivers the results of recognition the same way as rep_do() if it gets applied directly on the coding lines. rep_idcard() additionally also is available as exe file or binary which can be called directly from the command line: "idcard image_file classifier".
As output an XML file with the name of the image_file is generated.
To improve recognition accuracy on images with noisy background a new technology has been implemented. If the parameter OPTIONS_REL_REC_REPEAT is set, badly recognized single characters are read again directly from the original gray or color image. Then they are binarized again with changed parameters, dependent on their measured stroke width.
Now the output of the results as XML file is implemented. For this only the parameter TEXT_FORMAT_XML has to be set with the functions re?_textline(). This also holds for the new functions rep_text() and page_text() which enable the text output of the results of rep_do() and re_page(). The functions re?_textline(), rep_textline(), and page_text() now return short or long spaces with one blank only. The old solution - to return the estimated number of blanks - was dependent on the blank width of the output font, which is not known at time of recognition.
The estimated number of blanks is still returned in RelGraph.leading_blanks, except of the beginning of the line.
The old define CODE_UNICODE has been replaced by CODE_UTF_16. This avoids misunderstandings between Microsofts Unicode (wchar_t as unsigned short) and Linux (wchar_t as unsigned int). The newly implemented CODE_UTF_32 denotes the 32 bit Unicode.
With MSVC no libraries with the compiler switch /Md (multithreaded dll) are provided any more. In the past they have lead to problems several times, especially when the applications should run under new Windows versions. Concerned are libraries like rec_md.lib or rel_md.lib, those that have the ending _md in their filename.
  • Corrections with scaling (parameter PREP_SCALING).
  • Corrections with the returned line and character positions in REL and REP.
  • New IDCard.exe to recognize coding lines in passports and ID cards as Command Line Program.
  • New function re_page() for full-text recognition of documents and forms.
  • Recognition of underlining in rel_do() and higher level functions. This is marked by RESULT_FLAG_UNDERLINED in rel_result->result_flags.
  • Sometimes lines with leading noise were not recognized at all.
  • Improved discrimination of uppercase/lowercase when for words preceded by special signs.
  • Crash with lines removal.
  • Result output with the functions re?_textine() also in XML format.
  • New function rep_text() for output of the rep_do() results, also in XML format.
  • New function re_layout() for layout analysis of documents or full page text.
  • Rare infinit loop in rel_do().
  • Memory leak in processing gray images.
  • Improved recognition of numeric words in alpha texts.
  • Improved discrimination of lowercase and uppercase in mixed texts.
  • New, heavily shrunk classifiers Jumbo.rec and new classifiers Ttf_s.rec. The classifiers Ttf??.rec and Ttf_s??.rec now have the same structure.
  • The labels "g " and "g2" have been swapped according to the Unicode standard.
  • New function re_layout() in REP. In a first stage of implementation texts (for instance pages of books) are extracted from the rest of the image (for instance book borders with background).
  • New function re_subimage().
  • Error in re?_textline with the output of ligatures under Unicode.
  • Error "loop" in rel_do() processing horozontal lines without lines removal.
  • Error reading multicolor TIFF.
  • Correction in respell_do() with parameters rel_repeat and rep_repeat.
  • Error reading TIFF with missing specification of bitspersample.
  • Rare error "loop" in rel_do().
  • Error reading TIF images with minisblack=1 and bitspersample=8.
  • Error with parameter OPTIONS_STRICTSELECT. Not all deselected character classes were excluded during classification.
  • Error in Respell with the connection of a private spellchecker.
  • Error reading more than one image of multi TIFF files.
  • Considerably improved segmentation of connected characters with machine print.
  • Very rare endless loop in rel_do().
  • Rare error "Inconsistent component position" in recognition without noise removal.
  • Error with selection of label 1_ (parameter ReParm.labels and ReParm.labels2) when the basic label 1_ (one with upstroke) not was contained in the classifier. This especially concerns the clasifiers Handus.rec and Numplusus.rec.
  • Allocation problem in rel_lineshadow().
  • Error in the combination of Kadmos dll version and server version.
  • Integration of the full Open Source Tiff library.
  • Label '_ as basic label was missing in the classifiers hand??.rec and hand_s_??.rec.
  • he functions re_(w)writeparm?() didn't terminate the list of RelGridParm parameters with GRID_END.
  • Error with processing Unicode file names in re?_winit().
  • Extremly rare "Access Violation" with character segmentation in rel_do().
  • The program HashMaker.exe (download) didn't work correctly any more.
  • Improvements with the Norm.rec classifier E13b (MICR), especially for incomplete characters 4e ↔ 9e.
  • New parameter TYPO_EXTENDED_SEGMENTATION. If set with ReParm.typograph, segmentation errors especially with machine print are reduced by about 10%. Of cause this takes CPU time.
  • Now also BMP files with 32 bits per pixel can be processed.
  • Further improved box detection. In rel_do() all noise above and below boxes gets removed. If the parameter OPTIONS_REL_CLEAN is set, additionally all characters and all noise outside the boxes gets removed.
  • Remarkably improved blank recognition, especially with machine print.
  • Corrected and improved implementation of the parameters TYPO_NOLIGATURES and TYPO_NOTOUCHINGCHARS.
  • The parameter typograph had not been passed from rep_do() to rel_do().
  • Rare floating point exception. Several inconsistencies in accent recognition.
  • Bug in the new program part for accellerated recognition of good text images.
  • Several duplicated file handles didn't get closed.
  • New classifiers Ttf_s2_de.rec and Ttf_s2_us.rec. The classifiers are only 30% the size of Ttfde.rec or Ttfus.rec, but 20% faster. They are prototypes for the next classifier generation in Kadmos 5.1.
  • Code optimization in rel_do() and rep_do(). Now "normal" text images are recognized with double speed. The optimization was a cooperation of re Recognition Switzerland and Orbograph Israel.
  • After long time - correction of the sample programs for Visual Basic and C#.
  • New parameter OPTIONS_REL_REC_REPEAT for color and gray images. After a first recognition cycle in rel_do() or rep_do() the recognized single characters get binarised and recognized anew directly from the color or gray image. The result is improved recognition accuracy.
  • Bug in re_parmcopy(). In some cases the content of parm->labels did not get copied.
  • Improved line tracking in rel_do()(base line, ...).
  • New parameter OPTIONS_REL_CLEAR. It supports recognition of norm fonts like CMC7 or E13b. In those cases, line images often contain noise in the beginning or in the end part. This noise will be recognized as everything else. But if it is recognized as noise, it will be ommited in the resulting RelGraph and RelResult.
  • Selective improvement of the classifiers Norm.rec (E13b) and Jumbo.rec ($ sign machine print).
  • Error in processing low resolution images with the parameter PREP_SCALING.
  • Corrected and improved version of Rec_Linker.exe. Some classifiers were written incompletely into the generated REC file. Formerly splitted basic classifiers now are combined again.
  • If the parameter "deskew_min" had been specified and the given image had been deskewed, then incorrect coordinates of the results RelResult and RelGrid had been returned.
  • New parameters "options" in ReInit and "rejects" in ReParm. Attention: The structure ReParm has changed! Now it is possible to read only parts of big classifiers (REC files). This has the same effect as the restriction of classifiers by Chopper.exe and can yield huge reductions of computing time. How to apply: Before the call of re?_init() you have to set ReInit.options to OPTIONS_RESTRICT_LABELS and you have to set the parameters ReParm.labels_size, ReParm.labels, and ReParm.rejects, the latter to the required labels and rejects. Now the subsequent call of re?_init() only reads the specified part of the classifier into memory, which is needed to recognize these labels and rejects.
  • The parameters of the program Chopper.exe have been extended by one line. Here the name of a parameter file (INI file) can be specified, in which the labels and rejects of the given or generated classifier are written. Those labels can be read with re_readparm() before the call of re?_do() in case of OPTIONS_RESTRICT_LABELS.
  • New program Multi.exe in the Chopper family. This program enables batch processing with wildcard specification of programs like Alcstrip.exe, Alcfill.exe, or Chopper.exe.
  • KADMOS available for OSX on Apple computers (32 Bit und 64 Bit).
  • KADMOS now also directly reads classifiers which were compressed with gzip. Other compression/decompression functions can be used, if related decompression functions are provided. Gzip compressed classifiers are about half size, but loading time is double as long.
  • New application rec_linker.exe in the Chopper family. This program can be used to link several rec files into one, for instance ttfus.rec, ttfru.rec, and ttfgr.rec. The resulting rec file is much smaller than a rec file with the same labels generated by Chopper.exe.
  • Further size reduced classifier family ttf_s.rec.
  • KADMOS available for iOS on Apple computers (Mac, iPhone, iPod, ...).
  • KADMOS available for Android with the processors ARM, ARMv7a, and X86.
  • Rare memory allocation error in the 64 bit versions of REP (rep_do()) in function SplitComponentHori().
  • Improved segmentation with small texts.
  • Improved line tracking.
  • Rare errors when rel.init.rel_graph_maxlen and rel.init.rel_result_maxlen where set to different values.
  • Improved classifiers by completed recomputation for newly integrated characters and labels.
  • Extension of the classifier Thai machine print by several ligatures: 0E2A+0E31 - Aw, 0E2A+0E47 - Bw, 0E2A+0E49 - Cw, 0E2A+0E4A - Ew, 0E28+0E48 - qw.
  • Extended character set for the Norwegian classifiers.
  • New classifiers for Welsh, Serbian, Macedonian, Tagalog.
  • New classifier family ttf_l_??.rec and ttf_s_??.rec for machine print. These classifiers are about 50% smaller (ttf_l) or 75% smaller (ttf_s) and 15% faster without essential loss in accuracy.
  • Significantly improved lines and box removal.
  • Improved function rel_find().
  • The labels "a ", "a2", "a_", "a1", (a normal or as o with vertical stroke right), "g2" and "g1" (g like number 9), "Zw", "zW", "ZW", and "zW" (Z, z with horizontal stroke in the middle) were synchronized with Unicode. For this reason the labels "a " and "a2" as well as "a_" and "a1" had to be exchanged. In the other cases only the Unicode has changed:
    Unicode für 'a2' neu: 0x0251 0x0020  Unicode für 'a1' neu: 0x0251 0x005F
    Unicode für 'a1' neu: 0x0251 0x005F  Unicode für 'g1' neu: 0x0261 0x005F
    Unicode für 'Zw' neu: 0x01B5 0x0020  Unicode für 'zw' neu: 0x01B6 0x0020
    Unicode für 'ZW' neu: 0x01B5 0x005F  Unicode für 'zW' neu: 0x01B6 0x005F
    This change is important only for KADMOS users who explicitly work with basic labels or Unicode.
  • In rare cases only the beginning of a text line has been read.
  • re_collect() didn't work correctly under Windows64 and Linux64.
  • Incorrect error handling in rep_do() under multi-threading.
  • With lines removal in some cases some lines didn't get removed.
  • The function rel_recdo() sometimes placed characters at a wrong position in the line.
  • Subsequent rep_do() calls with different subimages and labels in some cases used the parameters (labels) of previous calls.
  • Error in line separation (rep_do()) with nonsense images.
  • KADMOS available for für Android.
  • Significant improvement of machine print recognition through integration of several hundred thousand up to now badly recognized characters.
  • Extended Fraktur (Old German) classifier - Czech accented characters added:
    0x0106 ⇒ ;'   0x0107 ⇒ :'   0x010C ⇒ ;v   0x010D ⇒ :v
    0x011A ⇒ >v   0x011B ⇒ <v   0x0158 ⇒ ?v   0x0159 !v
    0x0160 ⇒ &v   0x0161 ⇒ +v   0x0165 ⇒ @v   0x016E ⇒ }.
    0x016F ⇒ {.   0x01CF ⇒ $v   0x01EE ⇒ ~v   0x01EF ⇒ _v
  • Improved Thai classifiers.
  • Extension of the classifier Thai machine print by several ligatures:
    0E1B+0E31 ⇒ aw   0E1B+0E34 ⇒ cw   0E1B+0E35 ⇒ ew   0E1B+0E47 ⇒ fw
    0E1B+0E49 ⇒ gw   0E1B+0E4B ⇒ iw   0E1B+0E4C ⇒ jw   0E1D+0E31 ⇒ kw
    0E1D+0E35 ⇒ mw   0E1D+0E36 ⇒ nw   0E1F+0E31 ⇒ sw   0E1F+0E34 ⇒ vw
    0E1F+0E4C ⇒ ww   0E35+0E48 ⇒ xw
  • Improved lines removal.
  • In case of lacking access permission for CSIDL_COMMON_APPDATA it is not any more posted "KADMOS is already running on this computer", instead a request to contact the administrator.
  • With multithreading, the re?_do() calls have not any more to come out of the same thread as the preceeding re?_init() calls. But it has to be ensured that simultaneuos calls have separate initialisation by different re?_init() calls.
  • Improved function rel_find().
  • Error in respell_do() with set parameter rel_repeat or rep_repeat. The error message was "Unknown UNICODE ...".
  • Error in the Linux versions with the functions re_openimagefile() and re_wopenimagefile(). The file names were not handled correctly.
  • Bug in error handling in rep_do() under multi threading. One consequence (among others) was a wrong error message "KADMOS is already running on this computer".
  • Sporadic error in spot removal (seg->xpos fehlerhaft or seg->ypos fehlerhaft).
  • In the classifier numpluseu.rec the label 1a was missing (OCR-A one).
  • The OCR-A numbers where incorrectly integrated in the classifiers Jumbo, Ttf, and Numplus - partly as basic labels as part of group labels only.
  • Very rare crash in segmentation of nonsense images.
  • Wrong position of the output values of rel_lineshadow() in case of empty columns at the beginning or end of the image.
  • The labels 0x2609 until 0x2612 (marks) have been added to the classifiers Jumbo.rec, Hand.rec, and Ttf.rec. The second characters of the related Unicode labels have been changed from 'd' to ' '. The second characters of the ersatz representation stayed unchanged ("@d", "_d", and "*d").
  • KADMOS-CL is not maintained any more.
  • Sporadically wrong error message "KADMOS is already running on this computer" by missing thread syncronisation under Windows.
  • Wrong storage of Unicode labels in ANSI parameter files. With parm.code==CODE_UNICODE the labels are stored in UTF-8 in the parameter file and for reading they are also expected in UTF-8 instead of Unicode.
  • Essential improvement of the classifiers by a new "turbo" technology. The improved classification has partly led to an over adaption. So we now have to concentrate on new data collection and integration. For this we need active help from our customers and partners. An essential improvement has been reached with alphanumerical hand print.
  • The function rel_do() didn't return the leading spaces for the first character of the line.
  • The function re_readimage() didn't return the image resolution.
  • First usage of a new classifier computation technology. The new 'turbo' classifiers produce significantly less substitutions. In the next months this technology will be applied to all KADMOS classifiers.
  • rep_do() under multithreading didn't return the RepResult values top and left.
The biggest, but least visible change is the use of 64 bit variables in KADMOS as well as in all programs which are needed for data collection and classifier computation.

The biggest visible changes are:

The use of multi threading by the module REP (rep_do()). The standard version of KADMOS now supports parallel processing with two threads. The new server version of KADMOS supports parallel processing with all available threads. This results in a measurable gain in speed. The server version is sold at a fourfold price compared to the standard version. Both variations can be run with the program Famulus from the developer kit. In the result window the related recognition speed can be retrieved. New parameters GENERAL_REPMULTITHREADING and GENERAL_MULTITHREADING are introduced to activate or deactivate multithreading. This improvement requires the MSVC library wsock32.lib, which now has to be linked to all related applications.

If you, after switching to KADMOS 5.0, get an error message like the following:
"KADMOS is already running on your computer" then you probably haven't ordered enough KADMOS licenses. You should either order an additional licence, or - in case of genuine server mode - switch to a KADMOS server license.

New algorithms for classifier computation and discrimination result in a clear improvement of recognition accuracy.
rec_value, the confidence value of recognition, now has a clear meaning. Basic classifiers (for instance 'A' - 'B') recognize 99% of all related characters from our huge data base with a rec_value below 32. 99.9% have a rec_value below 64, 99.99% a rec_value below 96, and so on. For classifiers with 100 or 150 character classes this relationship holds up in an analog way:
90% have a rec_value below 32, 99% a rec_value below 64, 99.9% a rec_value below 96.
If the reject level is changed by 32 (up or down), then the number of rejects gets lower or higher by a factor of 10. This of course holds only true for the single character recognition REC. With the line recognition REL the rec_values changes due to evaluation of the position of the character in the line, evaluations of the character font in relation to the font of the other characters in the line, and other evaluations. From this relationship of the reject level as the percentage of rejected characters a simple rule can be given: If the percentage of rejected characters at reject_level 64 exceeds 5% or 10%, then a data collection and a retraining of the used classifier is strongly recommended. The program Famulus in the developer kit now contains an additional menu item "Reject rates". After every recognition the related reject rates for the reject levels 32, 64, and 96 can be retrieved. In connection with this change the default value for the parameter parm.reject_limit has been set to 128. Even despite this reduction KADMOS 5.0 generates more alternatives than KADMOS 4.4 with the former value 150. If a comparable behavior of both KADMOS versions is required, reject_limit in KADMOS 5.0 should be set to a value of about 110.

IThe result window from Famulus.exe has ben expanded with the point reject rate.

KADMOS was prepared for a switch to the internal use of Unicode, including our service and classifier computation programs. We want to complete this within the next year to be able to recognize fonts like Tamil, Korean, and others. The value of REC_CHAR_SIZE in kadmos.h has been extended from 8 to 16 bytes to prepare the future use of Unicode 32-bit codes.

Two new functions rel_find() and rel_findg() were provided. rel_find() tries to find a readable text line in a given image. rel_findg() is doing the same, but specialized for gray images, which often are difficult for binarization - like serial numbers on money bills.

For the functions re_(w)readparm(), re_(w)writeparm(), and GetPrivateFileName() the default directory under Windows had to be changed in the case of a missing directory specification. We were forced to do this, as Windows Vista and Windows 7 do not work correctly any more with the former default (Windows directory). The new default now is - as already has been under Linux - the working directory (WorkDir). This default can be changed by setting the new environment variable "kadmos_inifiles" to a different default directory.

In kadmos.h REC_CHAR_SIZE has been expanded from 8 to 16 byte to prepare later use of Unicode 32 bit.

All machine print classifiers (jumbo??.rec, ttf??.rec) have been extended by the double accents Unicode 0x201c and 0x201d with the replacement (ersatz) representations '"[' and '"]' respectively. The Thai machine print classifier was extended by the labels 'T2' and 'U2' (replacement representation). These are special forms of the characters Unicode 0x0e14 and 0x0e15.
  • Implementation of some bugfixes of KADMOS 5.0 in the last version of KADMOS 4.4

  • The function rel_do() didn't return the leading spaces for the first character of the line.
  • Error in rel_do(). The horizontal position of the recognized characters has not been returned correctly from images with white space on the left.
  • Error in respell_do() if rep_repeat and parameters for noise reduction in rep_do() had been set.
  • Sporadic wrong error messages with spot removal in images which are higher than wide.
  • Error in binarization of color images which do not contain any colors.
  • Incorrect saved images with set parameter TYPO_KEEPIMG.
  • Error in respell_do() with set parameters rel_repeat and rep_repeat.
  • In rare cases parts of lines dissapeared with set parameter TYPO_NOLIGATURES.
  • Error in memory allocation/deallocation with set parameter TYPO_KEEPIMG.
  • Rare protection error in rep_do() and with lines removal.
  • Several rare protection errors in rel_do().
  • Uninterrupted one week mass test without any error.
  • Wrong plausibility check in rel_do() with images, that internally got enlarged by PREP_SCALING.
  • Improved treatment of small i without i-dot.
  • Error in respell_do() in case of set parameters rel_repeat or rep_repeat.
  • Addition of the characters lowercase i without dot as basic labels for i in all respective classifiers: i. j. ix for machine print and i* j* for hand print.
  • Improved quality of respell_do().
  • Rare protection errors in rep_do(), rel_do(), and respell_do().
  • Kadmos has run several days on several million images without any error.
  • Rare protection error in rep_do(), in case of vertical lines in the images or in case of components that extent over several lines.
  • Rare protection error in respell_do().
  • Rare protection error in preprocessing.
  • Error in code_expand_lig() with CODE_UNICODE.
  • Memory-Leak in rel_do().
  • Improved recognition of screen shots (for instance browser output).
  • Improved classifier for Old German (Gothic).
  • Kadmos available for 64-bit-Linux.
  • Wrong ersatz-label and wrong height information in the Fraktur Alc files for the character LATIN CAPITAL LETTER N WITH TILDE Fraktur (Unicode 0x00d1, second label byte "f"). Wrong: "*s". Correct: "=s". The translation from the wrong into the correct ersatz label is performed by KADMOS automatically, if necessary.
  • Error in font selection in the functions re?_config?() from reConfig.dll.
  • Error in multithreading support. KADMOS didn't work any more under Windows 2000 or under Windows XP without SP1.
  • New labels ´ , ´_, ` , and `_ in all machine print and hand print classifiers (jumbo*.rec, ttf*.rec, hand*.rec).
  • New characters and basic labels for Greek and Cyrillic:
    F2 ⇒ Unicode 0x03A6 ⇒ wie Fg aber ohne Serifen.
    F4 ⇒ Unicode 0x0424 ⇒ wie Fk aber ohne Serifen.
    f4 ⇒ Unicode 0x0444 ⇒ wie fk aber mit Serifen.
    f6 ⇒ Unicode 0x03C6 ⇒ wie fg aber mit Serifen.
  • Extended support for the work with two dictionaries. New functions rel_config3(), rep_config3(), re_readparm3(), re_wreadparm3(), re_writeparm3(), re_wwriteparm3(). New parameter respell_font for ReSpell. It enables restriction of the dictionary use to text that is printed or written in the specified font.
  • Improved evaluation of the dictionary content in connection with rel_repeat and rep_repeat.
  • Error in Unicode translation.
  • Bug in the new space detection for proportional spacing.
  • Error with expanding ligatures (code_expand_lig()) with CODE_UNICODE.
  • Error in the default values of re_GetErrorConfig().
  • Inproved Thai machine print classifier.
  • Wrong height information with the Arabic characters for zero (0I, 0i, 0M, 0m, 03) in the related classifiers Jumbo*, Hand*, Ttf* und Numplus*.
  • Wrong height information with the character .d in the related classifiers Norm*.
  • Error in the functions re*_(w)textline() with CODE_UNICODE and TEXT_FORMAT_KADMOS_MULTIBYTE.
  • Sporadic destroyed memory heap in rel_do().
  • Improved blank detection with proportional spacing.
  • Improved dictionary search for alternative recognition results.
  • Considerably enlarged number of dictionaries for download from our website.
  • Thai machine print classifier (Thai OCR) ready.
  • Improved discrimination of uppercase/lowercase characters in rel_do().
  • Empty files were not closed correctly by re_?readparm?().
  • One more very rare and very old protection error in rel_do().
  • Inside the functions for multithreading support still some handles were not closed correctly.
  • First classifier for Thai machine print available.
  • Two or more dictionaries can be applied sequentially.
  • Rare protection error in rel_do() and rep_do().
  • Sometimes incomplete image copying in re_image2bmp(), if image.subimage had been set.
  • Inside the functions for multithreading support some handles were not closed correctly.
  • KADMOS supports multithreading. Therefore a new function is provided: extern KADMOS_ERROR KADMOS_API re_ClearThreadData(void); This function has to be called just before terminating a thread.
  • Famulus supports text output in Unicode.
  • Memory-leak in rep_do() with (almost) empty, but noisy images.
  • Rare memory problems with images with graphic parts.
  • Stable crash of rec_init() under Windows Vista.
  • Sporadic ommision of last text line in rep_do().
  • New character classes double zero machine print (label 08) and hand print (label 09) in the related classifiers.
    Attention: If the recognition results are directly retrieved from rec_char[], then they have to be expanded into the correct number of characters. This can be done for instance with the function code_expand_lig().
  • Complete redesign of line segmentation in REP.
  • Improved lines removal in preprocessing.
  • Rare protection error in the call of an SSE4 routine.
  • Error in the call of a SSE4 routine in feature extraction.
  • Completly new provided classifiers Jumbo*.rec, Hand*.rec, Ttf*.rec, Numplus*.rec, Numbers*.rec, and Fraktur*.rec with considerably improved recognition quality.
  • Extension of the French machine print classifiers for France, Belgium, and Switzerland by the characters OE and oe (Unicode 0152, 0153).
  • Switzerland by the characters OE and oe (Unicode 0152, 0153). + Extension of all Latin machine print classifiers by the ligatures fi and fl (Kadmos labels "<w" and ">w").
  • Extension of the Greek machine print classifier by the Beta symbol (Unicode 03D0).
  • Extension of the classifiers Jumbo.rec and Ttf.rec by the Cyrillic machine print characters Unicode 0402, 040B, 040F, 0459, and 045A (Serbian).
  • Improved pixel editor in the program Sichten.exe.
  • Error in respell_do(), if rel_graph_out_maxlen or rel_result_out_maxlen haven't been chosen big enough.
  • Incorrect font description of the Thai numbers in the related classifiers.
  • Ispell didn't accept words of length 1.
  • Error in HashMaker with addition of words to a hash file.
  • With HashMaker the character '/' now also can be used as regular word character in word lists as far as no affix file is used.
  • Rare protection error during recognition with US numbers classifiers.
  • Rare protection error during recognition with US numbers classifiers.
  • Endless loop under Windows with some error messages.
  • Sample program for Visual Basic 8.0 provided.
  • Rare crashes in rel_do() if TYPO_NOTOUCHINGCHARS had been set.
  • Rare nonsense error messages in spot removal.
A huge amount of new character samples, especially accented characters, were collected and used for a new computation of the classifiers Jumbo*.rec, Hand*.rec, Ttf*.rec and Fraktur*.rec. The classifiers Ttf*.rec have new the characters « and » and the ligature ffl. The classifiers Fraktur*.rec were extended by the ligatures sch and ffl. In preparation of a Thai classifier, the Thai digits were implemented for hand print and machine print. The letters D and M were removed from the classifiers Numplus*.rec, in hand print and in machine print. The speed of recognition got considerably accelerated with CPUs that support SSE3 or SSE4.1. The other Kadmos interfaces have not been changed from version 4.3.
  • Integration of RESPELL in the sample program Repdemo.c.
  • Wrong return of labels in parm.labels2 after calls to re?_info() with parm.code==CODE_UNICODE.
  • Error in the Java console sample for the integration of RESPELL.
  • Wrong return of the coordinates of the result characters (RelResult) when rel_repeat or rep_repeat where performed by RESPELL.
  • Protection error in respell_do() on documents with graphic parts/images.
  • For iSpell dictionaries the option ALLOW_COMPOUND_WORDS is set as default. So the initialization parameter ISPELL_ALLOW_COMPOUND_WORDS could be deleted. Now with a new parameter RESPELL_ALLOW_COMPOUND_WORDS the setting can be changed in the data structure ReSpellParm under 'respell_config'.
  • The Kadmos library version now is also available for Windows 64 bit.
  • Change to Microsoft compiler MSVC 8.0. As this compiler doesn't support single threaded compilation any more, the libraries *_st.lib aren't provided any more. Strict use of the new, save string functions str???_s() and wcs???_s(). For downward compatibility a source strxxx_s.c is provided, which emulates the used new functions as well as ftol2().
  • Therefore an additional dll Hunspell.dll is provided. The parameter ispell_maxlen in kadmos.h has been renamed in respell_maxlen, the parameter ispell_minlen has been deleted.
  • RESPELL now also checks words between well recognized special signs.
  • Wrong display of the selected classifier labels in reConfig.dll.
  • Error in function code_expand_lig() and thus also in the functions re*_textline() for CODE_UTF_8.
  • Error with output of list files in HashMaker (sorting, flags).
  • Rare ignoring of wide characters when the parameters TYPO_NOLIGATURES or TYPO_NOTOUCHINGCHARS were set.
  • Rare error in recognition of numeric words.
  • Error in re_writeimagefile() with raster image files (*.ras).
  • Error in processing code page UTF-8 (CODE_UTF_8).
  • iSpell dictionaries can be downloaded.
  • Font Farsi hadn't been marked correctly in the classifiers jumbo.rec, hand.rec, ttf.rec and numplus??.rec.
  • The functions re_readparm(2) din't read 'labels' correctly.
  • Error in using the big classifier jumbo.rec.
  • Error in raster image collection with TYPO_KEEPIMG when a dictionary was activated ans rel_repeat or rep_repeat had been set.
The Greek-, Cyrillic-, and Fraktur classifiers are extended by the Latin character set. The classifier Numplus.rec is extended by the Arabic and Farsi numbers (formerly called Arabic Indian numbers). To control recognition of such mixed cases (Latin+Arabic for instance), a new parameter font has been introduced. The macros from ALC_HAND to ALC_MACHINE have been removed and replaced by macros FONT_HAND, FONT_MACHINE, FONT_LATIN to FONT_THAI, and FONT_OCRA to FONT_BRAILLE as values for the new parameter font . This means a splitting of the old parameter alc in two parameters alc and font and the introduction of new fonts FONT_LATIN to FONT_THAI. The name ARABIC_INDIAN has been changed into the more usual name FARSI. The classifier numplusa.rec is renamed into numpluseu.rec and numplusa.rec is renamed into numplusus.rec. For Unicode support to all KADMOS functions with file name parameters new functions with wide character file name parameters are introduced. This new functions are rec_winit(), rel_winit(), rep_winit(), respell_winit(), re_wreadparm2(), re_wwriteparm2(), re_wopenimagefile(), re_wreadimage(), re_wwriteimage() and re_collect_winit(). The functions rec_filetitle(), rel_filetitle(), rep_filetitle() and respell_filetitle() return the file name as wide characters wchar_t when the initialisation had been is made with one of the functions re*_winit(). To support programms under Unicode, the KADMOS error handling also has been extended to handle Unicode. Beside the structure re_ErrorText a new structure re_wErrorText has been introduced, which handles error texts as Unicode strings. The related new functions to handle this are re_wGetErrorText(), re_wSetErrorText(), re_wDisplayErrorText(), re_wSetErrorHandler(), and re_wGetErrorHandler(). Accordingly, there is an additional definition of re_wErrorHandler. Under Windows, with missing drive and directory specification, the functions re_?readparm?() and re_?writeparm?() not longer read or write from or into the Windows directory, but instead they work in the current working directory (as they already do under Linux). So, when functions like GetPrivateProfileString() or WritePrivateProfileString() are used simultaneously, the name of the arameter file has first to be completed by a call to _fullpath(). The data structure ReSpellData has been extended by new elements rel_repeat, rep_repeat, and repr_rect. rel_repeat can be set to the address of the initialized data structure RelData which had been used for recognition of the text line before the call to respell_do(). In this case for all words that were not found in the dictionary respell_do() tries a new recognition with slightly different parameters. The same holds for rep_repeat, when rep_do() had been called called before the calls to respell_do(). In this case before every respell_do() call additionally repr has to be set to the address of the RepResult data structure which holds the recognition result of the related text line. Generally the performance of ReSpell has been considerably improved. Beyond that, a new interface has been provided to use private or OEM spellcheckers directly with KADMOS. Therfore the data structure ReSpellData has been extended by the new elements oem_spell_lookup, oem_codepage, oem_wordchars, and oem_reject_char. How to do this is demonstrated in the new sample program OEMSpellDemo. With a new interface ReSpell has the possibility to connect a private spellchecker to KADMOS. For it in the structure ReSpellData are the new elements oem_spell_lookup, oem_codepage, oem_wordchars and oem_reject_char. The new program HashMaker provides the possibility to extract word lists and affix files from iSpell dictionaries, to extend word lists, to combine word lists, and to integrate them into iSpell dictionaries. It is now quite easy to create iSpell dictionaries from private word lists, given as simple text files.
  • Rare Protection Error in rec_do() with images of 128 horizontal or vertical pixels.
  • In the classifiers norm.rec and normocrb.rec the number 0b and the uppercase alpha Ob are now recognized separately.
  • Error in rep_group_labels().
  • Sporadic wrong evaluation of the dictionary entries.
  • Rare error (division by 0) with nonsense images in rel_do().
  • Error in re_readimagefile() with multiple reading the first image (image number 0) in Tiff-files which contain one single image only.
  • New function respell_lookup() for direct dictionary search.
  • Direct dictionary search implemented in Famulus.exe (double click on a word in the result window or function key F1 for the word under the text cursor).
  • Extension of the French and Belgian classifiers with the characters LATIN CAPITAL LETTER AE and LATIN SMALL LETTER ae.
  • Extension of the Java interface (kadmosjava.dll) and additional sample program for Sun's NetBeans IDE 5.0
  • Wrong allocation in respell_init().
  • Improved classifiers Cyrillic machine print.
  • New function re_rotateimage() to rotate images.
  • Integration of this function in Famulus in the menu 'edit'. The menu item 'Invert' has been moved from 'Representation' to 'Edit'.
  • Rare error in segmentation in REL - lines were not recognized completely.
  • The functions re_readimagefile() and re_readimage() dont throw an error any more in cases of empty image files or empty images (height*width==0). Instead, they now return with NULL.
  • ReSpell implemented in the Delphi sample program.
  • New function re_imagehandle2image() to fill a ReImage data structure with the image data given by a ReImageHandle.
  • Support of the UTF-8 code.
  • Extented and slightly changed interface to Java.
  • Considerably smaller and slightly better classifiers norm*.rec.
  • Slightly better classifiers mark*.rec and corner.rec.
  • Integration of libpng version 1.2.10 and extension to color PNG images.
  • Error in segmentation control of mixed lines (hand, machine). In the first step of segmentation of a line, the font values of the preceeding line were taken.
  • The macro REP_RESULT had been written lowercase in kadmos.bas (Visual Basic).
  • Minor errors in the return value of rel_word_value().
  • Memory-leak for set paramater deskew_min with special images.
  • Correction of a nonsense error message in the software copy protection module (dll version).
  • Error in the function code_expand_lig() in the case of UNICODE.
  • The parameter reject_limit in ReSpellParm has been deleted.
  • New item result_flags in the data structure RelResult. This way results, which are approved by a dictionary (RESPELL), can be marked with a flag RESULT_FLAG_RESPELL. Related change in the data structure RecData.
  • RESPELL now also accepts dictionaries (*.hash) from Ispell version 3.3.
  • RESPELL now also handles segmentation alternatives. This needs a lot of computing time. To controll dictionary-lookup, a new item respell_config is added to the data structure ReSpellData. It can be set to the values RESPELL_FAST_LOOKUP,, RESPELL_NORMAL_LOOKUP, and RESPELL_EXTENSIVE_LOOKUP for extensive dictionary search. Further optimization is under work (computing time, performance).
  • New classifiers jumbo.rec and fraktur.rec. They are smaller by 20% to 25% and deliver less substituions.
  • For better readability, the parameter code is written as decimal instead of hexadecimal from re_writeparm?(). For re_readparm?() both representations are supported.
  • Small memory leak in rec_init(), thus also in rel_init() and rep_init().
  • Error corrections in the software copy protection module.
  • Correction of wrong messages of Uninstall.exe.
  • Error in processing empty images with GENERAL_PREP_ONLY.
  • Rare error in binarization of gray images with parameter setting different from PREP_GRAYTOBIN_MEDIUM.
  • Improved algorithms for image enhancement and enlargement Improved algorithms for image zooming.
  • Additional parameter value PREP_GRAYTOBIN_UNIFORM to binarize gray images with one threshold only.
  • respell now supported for Visual Basic.
  • The Ispell parameters ispell_config, ispell_minlen, and ispell_maxlen were moved from the structure ReSpellParm into the structure ReSpellInit, as they have to be set before Ispell initialisation. The int data types in the ReSpell data structures have been declared as short, to ensure correct 8-byte-alignment on different platforms.
  • To support respell for Visual Basic, the integration of respell.h in kadmos.h was necessary.
  • re_closeimagefile() didn't close *.ras files correctly.
  • respell now supported for Visual Basic.
  • To support respell for Visual Basic, the integration of respell.h in kadmos.h was necessary.
  • Full support of all KADMOS code pages in respell.
New classifiers for Fraktur (Old German) are provided. Because ligatures are an important part of Fraktur, a corresponding concept has been developed and implemented. For general machine print two ligatures have been added, "fi" and "fl". The related labels are "<w" (fi) and ">w" (fl). These labels are returned by rec_do() . To convert this into regular text, we have provided a new function code_expand_lig() . The functions re?_textline() call code_expand_lig() internally, in this case no explicit expansion needs to be performed. In addition, all machine- and hand-print classifiers (jumbo*.rec, ttf*.rec, hand*.rec) were extended with the new labels “ and " (0x84 and 0x94 in code page 1252). In the classifier mark.rec the label ".d" (unmarked box with digit inside) has been renamed to "@d". The label ".d" now denotes the dot in the font SEMI (classifiers norm*.rec). New strategies for classifier computations have been developed. All classifiers have now been provided with the corresponding algorithms.
Dictionaries are now connected. Therefore a new include-file respell.h has been provided, as well as the libraries respell_*.lib. With the KADMOS DLL version, the new dictionary functions are included in kadmos.dll. Respell is based on the Open Source implementation Ispell. This way the full universe of ready made Ispell dictionaries can directly be used with KADMOS. The same holds true for the Ispell tools to create customized dictionaries (http://www.gnu.org/software/ispell/ispell.html).

As the use of dictionaries can be configured with parameters, extended functions for parameter settings, writing and reading have been provided:
rel_config2(), rep_config2(), re_writeparm2(), and re_readparm2().
The old functions rel_config(), rep_config(), re_writeparm() and re_readparm() can be used as before. With the universal dictionary support, the use of trigrams makes no sense any more and has completely been cancelled. All related items and parameters have been deleted. The new dictionary functions enable a better selection of the alternative results. Therefore the maximum number of segmentation alternatives can be enlarged, from SEG_ALT=4 (old) to SEG_ALT=8 (new). The two new macros TYPO_4_SEGALTERNATIV and TYPO_8_SEGALTERNATIV ensure compatibility with older KADMOS versions. By setting of TYPO_4_SEGALTERNATIV only a maximum of 4 segmentation alternatives is computed. The default value is TYPO_8_SEGALTERNATIV with a maximum of 8 segmentation alternatives. The data structure RelSpot and all related items have been discontinued.
A new parameter deskew_min controls de-skewing of (the) images into horizontal position before recognition.
The blank-detection with numbers and amounts has been improved.
  • Access violation in blank detection in rel_do() with noise-only lines.
  • Infinite loop in blank detection in rel_do().
  • Access violation in kadmosj.dll, functions RelGetResult() and RepGetResult().
  • 6 dot Braille classifier available on request.
  • Error in the evaluation of the parameters alc and labels, if from a mixed setting (hand+machine) had been switched to a singular setting (hand only or machine only).
  • Correction of the Windows-CE-version for the processor ARMV4.
  • Endless loop in preprocessing (morphing) in rel_do() from version 4.1f.
  • Remarkable improvement with the binarization of gray images.
  • A Floating Point Error from version 4.1f has been fixed.
  • Slightly improved alternative segmentation.
  • rel_info() delivers wrong results after a call to rel_do().
  • Corrections in line finding of rep_do(). In rare cases noise was generated in some lines.
  • Slightly improved segmentation of connected characters (morphing).
  • Essential improvement of line finding in rep_do() with dot matrix print.
  • Essential improved blank recognition with hand- and machine print. The errors in blank detection could be decreased by 90%.
  • rel_word_value() returned nonsense results.
  • Nonsense error message in rep_do() if the given image consisted of few nonsense components only.
  • Error in recognition of machine-printed S and s in the huge classifiers Jumbo.rec and Ttf.rec.
  • In rare cases rel_do() removed small leading characters as noise.
  • By calling the context dialog in reconfig.dll all classifier labels got activated.
  • Extended Java sample program (error handling).
  • For the following platforms time restricted mini developer kits can directly be downloaded from our website: Windows NT-XP, Windows CE, Delphi, Visual Basic, and Java.
  • Black/white BMP files with RGB tab were read inverted by re_readimage() and re_readimagefile().
  • Rare memory error in rep_do() with noisy but else empty images.
  • KADMOS available for WindowsCE/PocketPC.
  • set and get parm.labels under Delphi, two new functions are provided:
    void KADMOS_API re_CharArrayToPointer(const char *array, long pointer, long len); void KADMOS_API re_PointerToCharArray(long pointer, char *array, long len);
  • Improved memory handling in rep_do(), especially for large images.
  • Nonsense error message in Chopper under code pages different from 1252.
  • Incorrect raster image collection with rel_collect_kernel() and kadmos.ini in mode REL.
  • The labels Å and å were missing in the Finnish classifiers.
  • In rep_do() parts of characters randomly got lost.
  • Rare nonsense error message in rel_do() "Inconsistent component position".
  • The characters 5a and 6a (OCRA 5 and 6) are now seperately treated in the classifiers jumbo*.rec, ttf*.rec, and numplus*.rec to get better discrimination of 5 and 6 (machine print).
  • Improved memory handling in rep_do() and rel_do().
  • Local improvements in line segmentation, especially for bold, connected machine print.
  • Improved memory handling for huge images.
  • Changed (simplified) function rel_lineshadow(). The returned area now has the data type "unsigned char", the related shadow positions refer directly to the colums of the given image. Thus the macro SHADOW_OFFSET has lost its meaning and has been canceled.
  • Protection Error in rec_init() when the application is started with a command line longer that _MAX_PATH characters.
  • Protection Error in rel_corr().
  • For the specification of labels now always also the ersatz representation is usable.
  • Together with the program chopper.exe now additionally the programs Alcstrip.exe and Alcfill.exe are shipped.
  • Local improvements in Jumbo*.rec, Hand*.rec, and Ttf*.rec.
  • Error (RE_PARAMETERERROR) in preprocessing empty images with rep_do().
  • For file name input with console applications (Chopper, Info, Alcstrip, Alcfill, ...) under Windows the File Open Dialog Box can be used. Therefore either the F1 key has to be pressed in the related menu line, or a mouse click on the prompt text of this line has to be performed. To activate this functionality, the file filename.dll from the KADMOS developer kit has to be copied into the directory of the related exe file.
  • All hand print classifiers have been improved by integration of new samples. The hand print number '4_' has got an additional basic class '41'. This class contains those numbers 4 that are written like a lightning. An analog extension has been made for the hand print characters 'S_' and 's_' with the new basic classes 'S5' and 's5'.
  • Three new code pages are added:
    - CODE_ASCII, containing 7 bit coding only (thus all ersatz representations).
    - CODE_PAGE_1255 and CODE_ISO_8859_8 in preparation of a Hebrew classifier.
    The special handling of a detected code page 1252 (redirection to ISO-8859-1) has been cancelled.
  • To prepare multi byte representations of characters in Unicode, the size of 'rec_char' for result strings has been enlarged from 4 byte to 8 bytes (REC_CHAR_SIZE). Accordingly, TEXT_FORMAT_KADMOS_2BYTE has been renamed in TEXT_FORMAT_KADMOS_MULTIBYTE.
  • he code pages in kadmos.h are enumerated differently.
  • The item 'labels' in reParm is now defined as pointer and allocated accordingly by re?_init(). Its size is returned in the new item 'labels_size'. 'labels' is freed by re?_end(). REC_LSIZE has been deleted. As parameters now can't be simply copied (overwriting of the pointer 'labels'!), a related copy function has been provided:
      KADMOS_ERROR KADMOS_API re_copyparm(ReParm *source, ReParm *destination);
  • An improved Java sample has been provided for the KADMOS DLL version.
  • o avoid confusions, the parameter 'bufflen' in the functions re?_textline() has been renamed in 'buffsize'. It now describes the size of 'buffer' in bytes (instead of characters formerly).
  • Nonsense error message in chopper.exe: 'No classifiers available for the selected labels ...', though the reported labels weren't selected.
  • Sporadic Protection Error with grid detection in empty images.
  • Wrong treatment of nonsense resolution values in rel_do().
  • Error in re_readimagefile() with reading files *.ras.
  • Memory problems with frequent (10000 ++) call of re_hbitmap2image().
  • The effect of the parameter PREP_SCALING has been extended to images with no specified resolution. If the parameter is set and no resolution is specified (xresolution==0 or yresolution==0), then the provided images are scaled in rel_do() or rec_do() as follows:
    - For pure hand print classifiers to a line number of 64 pixels,
    - for mixed classifiers hand- and machine print to a line number of 48 pixels,
    - for pure machine print classifiers to a line number of 32 pixels.
  • Error in rel_do() in the result graph structuring with nonsense images. (from 4.0g, message "Sort Error").
  • Error in rep_do() if called with the parameter setting GENERAL_LINEPOSITION_ONLY and a former call of re_collect_init().
  • Error in rep_do() - the y-coordinates of the isolated characters of the lines were mostly too small by the value of 1.
  • Error in determination of the coordinates of the isolated characters if the parameter PREP_SCALING had been set and a scaling had been performed. In this case also rel_collect_kernel() didn't work correctly.
  • Error in reading gray TIFF images.
  • Double allocation in re_clipboard2image(), resulting in inclomplete free memory with re_freeimage().
  • Incorrect coordinates and projections with spot removal.
  • Rare error 'component number not found' in rel_do().
  • Error in line tracking of rel_do().
  • Error in allocation of images of the type IMGTYPE_POINTERARRAY in the function re_cloneimage(). As result those images were not freed correctly by re_freeimage().
  • Corrections in blank detection with proportional spacing.
  • Corrections in alternative segmentation in rel_do().
  • New computation of the classifier mark.rec. The label '.d' (box with imprinted number or dot) is left separated, i.e. it is not anymore considered automatically as 'unmarked'. A reduced classifier mark2.rec is provided for the simpler case of empty unmarked versus marked boxes.
  • Approximately 10% faster recognition due to optimized internal routines.
  • Improved machine print classifiers ttf*.rec, especially for bold print.
  • Fast classifiers *_s.rec available. The need only about 60% of the regular computing time of KADMOS Version 4.0e with only a small loss in recognition accuracy. The macro OPTIONS_FASTCHECK in kadmos.h has been renamed to OPTIONS_FAST, its meaning has been generalized.
  • The *.alc-files and chopper.exe have been extended for the use with customer specific feature classifiers. Therefore new in *.alc-files is the section '[content]' with the entry 'labels'.
  • New function rec_get_features() to get the KADMOS features used for recognition.
  • Improved classifier norm.rec, especially for OCR-A (normocra.rec).
  • Error in raster image collection with Kadmos.ini
  • Improved classifier mark.rec.
  • Extended classifier corner.rec. Additional label BLACK SQUARE (Unicode 0x25a0) in this classifier.
  • Rare protection error in line tracking of rel_do().
  • After grid detection in rep_do() a set hook function rel_hook has not been called.
  • Extremly long computation times in rep_do() with line detection in large images.
  • TIFF files with one image only were not released correctly after reading.
  • Error in binarisation von RGB images in case of images with large white areas.
  • The Famulus has been extended to recognize norm print documents with up to three lines with KADMOS-CL.
  • The parameter 'general' in ReParm has got an additional value GENERAL_LINEPOSITION_ONLY. It effects rep_do() only. If it is set, preprocessing only is performed, no character recognition. The results of rep_do() are delivered as usual, the result structures contain the position of the (else to be recognized) lines only. The same holds for the message rep->hWND_line_message and the hook function rep->rel_hook if provided.
  • he parameter 'prep' in ReParm has got two additional values PREP_RGBTOGRAY_COLORMIN and PREP_RGBTOGRAY_COLORMAX. If PREP_RGBTOGRAY_COLORMIN is set, then with processing of color images the colors are eliminated, only the contained gray part is preserved. If PREP_RGBTOGRAY_COLORMAX is set, then with processing of color images the colors are transformed into gray values, according to the maximum value of the red, green, or blue component of the color.
  • For binarisation (conversion of gray- into black/white images) an adaptive thresholding has been implemented. This ensures that images with varying brightness and normal contrast can be transformed with reasonable results.
  • Famulus got a new window to show the result of preprocessing. Thus the menu item 'Filter' could be removed.
  • The option OPTION_BASICLABELS has been split into the specification with ReParm (labels) OPTION_BASICLABELS_PARM and in the specification with the results (RecResult, RelResult) OPTION_BASICLABELS_RESULT. As before, setting of OPTION_BASICLABELS specifies both.
  • The Kadmos engine now also supports recognition of any objects which are passed as customer defined features. Therefore labeled feature files have to be provided, from with re Recognition will generate a related Rec file. For recognition with rec_do() the feature vectors have to be provided under RecData.image.data. Therefore related values of image.imgtype have been added in kadmos.h:
    #define IMGTYPE_FEATURE 4
  • Improved algorithms for line extraction in rep_do().
  • New and improved algorithms for line tracking, especially for short words.
  • Update/redesign of the Visual Basic interface. The error handling has adapted to Visual Basic, and the usage of the Visual Basic data type 'String' is supported now. For this the following new functions are provided:
    re_ArrayToString(), re_StringToArray(), ARRAY_TYPE_BYTE, ARRAY_TYPE_WCHAR, re_GetErrorText_bas(), re_SetErrorText_bas(), re_DisplayErrorText_bas(), GetPointer(), FunctionAddress().
  • The evaluation of the slant of characters (recognition of \, |, /) in a rec_do() call was dependend of the mean slant of the characters that were recognized in a preceeding rel_do() call.
  • With Chopper in the menu "Selection of [reject] avoid substitutions" sometimes labels were (wrongly) offered for selection, which (correctly) could not be selected.
  • Error with noise removal. Despite properly set parameters, noise wasn't removed in some cases.
  • The parameter PREP_SCALING had not been evaluated properly in rec_do().
  • Rare Protection Error in rel_do() with noisy images.
  • he menue "Segmentation" in reconfig.dll has been extended to enable parameter setting for parm.line_space.
  • With a new algorithm, computation of slant and italic could be improved. This especially concerns the characters backslash, vertical mark, and slash.
  • The slant information of the backslash ("\_", "\ ") was missing in all classifiers.
  • In rep_do() the WM_USER message REP_LINE_CNT had not been sent any more.
  • In some cases the function re_createimage() didn't provide enough memory.
  • In the 'wintools' directory of the Linux version the files *.al0 and *.al1 were provided without the 'carriage return' character at the line ends.
  • Protection Error in rare cases, if rel_result_maxlen had been set not big enough.
  • Endless loop in sichten.exe, if the last screen was filled completely and 'next page' was activated.
  • New C++ sample program reldemopp.cpp.
  • In the following functions the unchanged parameters got the attribute 'const': re_SetErrorText(), rec_init(), rec_filetitle(), rel_init(), rel_filetitle(), rel_recset(), rep_init(), rep_filetitle(), re_writeparm(), re_writeimagefile(), re_writeimage(), re_image2clipboard(), re_cloneimage(), re_getpixel(), rel_textline(), repr_textline(), rep_textline(), rec_collect_kernel(), rel_collect_kernel(), GetRelGridParm(), SetRelGridParm(), GetRelGrid(), SetRelGrid(), GetRelGraph(), SetRelGraph(), GetRelResult(), SetRelResult(), GetRelSpot(), SetRelSpot(), GetRepResult(), and SetRepResult().
  • The reject label '#~' has been moved to the special signs with Unicode 0x224B,0x0020 (TRIPPLE TILDE machine print) and the ersatz representation '~4'. This concerns the classifiers jumbo.rec, ttf.rec, and numplus*.rec.
  • The linking of the Kadmos libraries with Microsoft VC6 was impossible, as the VC7 compiler generated a call to a unknown function ftol2(). Such a function is now provided (as a call to ftol()).
  • To avoid collisions using open-source-software to read and write images, the related KADMOS functions have been placed into a separate library reimageio.lib. This concerns the KADMOS library versions only, and here the functions re_openimagefile(), re_readimagefile(), re_writeimagefile(), re_closeimagefile(), re_readimage(), and re_writeimage(). The function re_freeimage() is contained in reimageio.lib as well as in the libraries rec*.lb, rel*.lib, and rep*.lib.
  • Gray value TIFF images with the specification PHOTOMETRIC_MINISBLACK instead of PHOTOMETRIC_GRAYMINISBLACK were invertedly represented.
  • Rare error "out_img→img_height<=0" with noisy images in rel_do() and rep_do().
  • In some cases memory leak in re_writeimage().
  • Swapped coordinates with detected vertical lines (GRID_LINE_V): left⇒top, width⇒height.
  • Sporadic protection error with mixed font (Jumbo*.rec, Numplus*.rec).
  • Additional function re_image2hbitmap() provided.
  • KADMOS developer kit for Windows now generated with Microsoft .NET. Several compiler errors were found (optimization/string handling) and programmed around. So we recommend profound tests with this version.
  • New feature extraction with improved recognition accuracy. It combines the angle-intersect-analysis with the proven 'mesh'-method (former AEG engine). Despite the much higher computational burden it is only 10% to 30% slower than Kadmos 3.5.
  • Additional fast and small classifiers (Jumbos_s_*.rec, Ttf_s_*.rec, Hand_s_*.rec, ...) for time- or memory critical recognition tasks (pen computing). Speed and accuracy of these classifiers are comparable to Kadmos 3.5. Additional accelleration and classifier reduction is under work.
  • Additional labels (Cyrillic, Arabic-Indian numbers).
    Additional special characters (^ ¡ ¢ ¥ § © ® ¿) for hand and machine print.
  • The hand print character E_ has been split into three form classes:
    - E_ (rectangular form)
    - E1 (like C with dash)
    - E7 (like number 3 inverted)
  • The hand print character b_ has been split into two form classes:
    - b_ (straight, simple form)
    - b3 (looped form)
  • The method of KADMOS's heap allocation (parameter GENERAL_HEAP_ALLOC) has proven superior. This method is now hard implemented, the parameter GENERAL_HEAP_ALLOC has been removed.
  • Additional reject labels for critical applications (#-#/#<#=#>#?#S#[#\#]#y#~). A description of the related character shapes is provided in our website.
  • Rare error with spot removal (SPOTREMOVAL) in noisy images.
  • Rare error in segmentation - subsequent rel_do() calls with equal images and parameters delivered different results.
  • Error in binary filtering of images with 1 byte per pixel. This also led to errors in rel_do() for images with 1 bit per pixel.
  • Already from version 3.5s the name 'slope' has been replaced by 'slant', including all derived names. ('slant' has become a general name for the degree of 'italic' or 'tilt' of a character in the past years.)
  • JPEG/PNG image IO routines now handle image resolution.
  • Up to 128 simultaneous calls of re?_init() can be handled (up to now only 32).
  • Error in combined application of heap allocation and hook functions.
  • Error in grid detection in rep_do(). Corrected formula to determine 'rep_memory_size' in the data structure ReInit:
    rep.init.rep_memory_size = MAX_LINE*sizeof(RepResult) + MAX_GRID*sizeof(RelGrid) + MAX_LINE*MAX_CHAR*sizeof(RelGraph) + MAX_LINE*MAX_CHAR*sizeof(RelResult) + MAX_LINE*MAX_SPOT*sizeof(RelSpot);
  • Label '.2' (fat dot machine print) added in classifiers jumbo*.rec, ttf*.rec, and numplus*.rec.
  • Nonsense error message in Unicode translation.
  • Error in evaluating segmentation alternatives.
  • Error in recognition of slash and backslash.
  • Visual Basic and Delphi interface bug fixes (missing parameter, missing function, structure change).
  • Several minor bugs fixed (multiple images) and improved error handling in the image I/O module.
  • Slightly improved classifiers jumbo*.rec, hand*.rec, ttf*.rec, and numplus*.rec. The character '1a' (OCRA one) has been added to the classifiers jumbo*.rec, ttf*.rec, and numplus*.rec.
  • [Linux]: Anonymous union members are used in kadmos.h. So GNU extensions should be enabled by passing the option "-std='gnu9x'" to the compiler (GCC v3.x).
  • The date entry of all Kadmos sources (*.h, *.c, ...) is handled now by the CVS (Concurrent Versions System). If developer store the Kadmos developer kit also under the CVS, then they should set the CVS option '-ko' during the update of a new Kadmos version. Without the option '-ko', the date of the updating is filled into the sources.
  • Support of recognition of vector images (Pen Computing) with rec_do(), rel_do(), and rep_do(). Therefore introduction of the new data type ReStroke in Kadmos.h. The function re_drawline() is thus not needed any longer and removed from the developer kit.
  • The developer kit contains an example (cppdemo.cpp) how to integrate Kadmos in C++ programs.
  • Changes in kadmos.ini ("savebmp"->"saveimg") because of Pen Computing support.
  • mplementation of a parameter/macro GENERAL_HEAP_ALLOC for parm.general. Memory allocation requires approximately 15% of a typical rep_do() call. This can be reduced to approximately 11% under Windows 2000/XP, but to less than 1% under Linux. GENERAL_HEAP_ALLOC is set as default.
  • Slightly improved classifiers jumbo*.rec, hand*.rec, ttf*.rec, and numplus*.rec.
  • New function KADMOS_ERROR KADMOS_API re_writeimagefile(ReFileHandle, ReImage *image) for the output of images in Bmp-, Tiff-, or Ras-files. The function re_openimagefile() therefore had to be extended by one parameter char *mode ("r" for read, "w" for write, "a" for append).
  • The developer kit contains an example (imgconvert.c) how to use the functions re_readimagefile() and re_writeimagefile() to convert image data to different formats. The programs ras2tif.exe and tif2ras.exe were removed from the developer kit.
  • The function re_SetErrorText() has been added to the developer kit, to enable a correct transmission of error messages. A sample usage is shown in imgconvert.c. For unification, the return value of re_ClearError() is redefined to 'void'.
  • Error in special case of rel_corr() with code pages different from 1252.
  • Error in the re_collect_*() routines with multiple calls.
  • Completion of re_hbitmap2image() and re_clipboard2image() with further HBITMAP types.
  • Completion of re_readimage() and re_readimagefile() with further TIFF types (gray images).
  • Providing of an additional function re_image2clipboard().
  • New ReImage manipulation functions available.
  • Extension of Famulus with direct subimage specification and copy function.
  • New classifier corner.rec to detect corner marks on documents.
  • Error in re_readimagefile() reading subsequent images of a TIFF file.
  • Nonsense error message after (successfull) call of re_image2bmp().
  • Extention of re_bmp2image() for images with separately stored bitmap bits.
  • Error in rel_do() with code pages different from 1252.
  • Kadmos available for Windows-CE / Pocket-PC (Pen-Computing).
  • The MFC sample Scribble is now part of the developer kit REP.
  • Adaption of the second Unicode label of the characters LATIN SMALL D WITH CARON ( "d,") and LATIN SMALL T WITH CARON ("t,") to the usual coding:
    0x010F,0x002C⇒0x010F,0x0032  0x0165,0x002C⇒0x0165,0x0032
  • Functions rep_group_labels() and repr_group_labels() were added. They convert the results of rep_do() from basic labels to group labels.
  • Accidencial crashes during text output when obsolete files Kadmos.de, Kadmos.hu, or Kadmos.uk where used.
  • Automatic detection, default setting and evaluation of the code pages CODE_PAGE_858, CODE_PAGE_1251, CODE_PAGE_1253 was not yet fully implemented. For the non-Windows-systems this also concerns the code pages CODE_ISO_8859_7 and CODE_ISO_8859_9.
  • Adaption of the second Unicode label of the characters LATIN CAPITAL L WITH CARON ("L,") and LATIN SMALL L WITH CARON ("l,") to the usual coding:
    0x013D,0x002C⇒0x013D,0x0032  0x013E,0x002C⇒0x013E,0x0032
  • New function declarations for the Delphi interface.
  • Kadmos ported to the AIX operating system.
  • Function re_hbitmap2image() added (Windows only).
  • Functions rec_group_labels() and rel_group_labels() were added. They convert the results of rec_do() and rel_do() from basic labels to group labels.
  • Protection error in rel_corr().
  • rec_info(), rel_info() and rep_info() changed the value of parm.code, what was not documented. parm.code now remains unchanged.
  • Missing labels in the Greek classifiers (Jumbogr.*, Ttfgr.*, Handgr.*).
  • Error correction in the Visual Basic interface.
  • rel_do() and rep_do() delivered partly wrong results for Codepages different from ISO 8859-1.
  • Vrel_do() and rep_do() returned basic labels only.
  • Protection error in rep_do() with very noisy images.
  • Protection Error in rep_do() if in a subimage lines containing only noise were detected and passed to rel_do().
  • OPTIONS_STRICTSELECT is now preset for parm.options.
  • The declaration of GetPrivateFileName() is now included in Kadmos.h.
  • Correction of the hand print basic classifiers for 0_-D_, U_-V_, C_-L_, and @_.
  • Protection error in rep_do() with very noisy images.
  • Noise removal didn't work correctly in rec_do().
  • Internal error (gage<2) with recognition/noise removal of dots.
  • Line- and box-removal now is also integrated in rec_do().
  • New functions rel_clear(), rel_recset(), and rel_corr() to correct results of rec_do() according to the character positions in a line. This is needed among others for pen-computing. An example is provided in RelDemo.c.
  • rel_char_space is also returned with proportional spacing.
  • From the clipboard not only bitmaps with 16 bit per pixel are accepted.
  • Support of large files (>2G byte) for all plattforms.
  • ec_do() returns rec_value[0]==0 for empty images, else rec_value[0]!=0. So RE_EMPTYIMAGEERROR is not needed any more.
  • Improved lines- and box-detection.
  • Error in separating diacritics from the rest of the line in rep_do().
  • Error in processing bitmaps with up to 16 bit per pixel and missing color table.
  • Wrong return values/results of grid detection in rel_grid.
  • With empty images rel_do() returned the results of the last call.
  • Protection error in rep_do() with extremly noisy images.
  • Error in rel_do() caused different (wrong) results under data collection.
  • PREP_SCALING is no more default, to avoid errors from wrong set resolution values.
  • Error in reading the the image resolution with Tiff-files.
  • Error passing the image resolution from rep_do() to rel_do().
  • Error in recognition of slash.
  • Rare error in rel_do() - division by 0.
  • Error in delivering the boundaries of the proccessed rectangle to rep⇒rel_hook.
  • Error in processing of very rare characters with context files.
  • Error in segmentation of broken characters.
  • Kadmos is now distributed by re Recognition AG, Hafenstrasse 50b, CH-8280 Kreuzlingen, Switzerland.Tel.: +41 71 67800 00
  • Completion of some up to now not yet implemented cases for writing back the preprocessed images through PREP_INPLACE.
  • Error in rel_do() with word context if several classifiers are used simultaneously.
  • Error in rel_do() for images with a resolution different from 300 dpi and activated grid detection without using GRID_END.
  • Error in preprocessing of gray images in rel_do() .
  • The Delphi example for the Kadmos integration is now part of the DLL-version of the Kadmos developer kit.
  • Error in reConfig.dll in the evaluation of parm.alc and parm.labels.
  • Error in rec_do() with images larger than 128*128.
  • Incorrect removal of empty surrounding lines and columns in rec_do().
  • With BMP- and single-TIFF-files, re_readimagefile() non-zero results in case of BMP and single page TIFF-files.
  • Error in parameter PREP_SCALING - scaling was almost every time performed.
  • Error in reConfig.dll and re?_info() in the evaluation of parm.alc.
  • Error in returned top-values of rel_do() for images with upper white pixel lines and a resolution of 300 dpi (no scaling).
  • Providing of functions to access arrays of structures, given by pointers, under Visual Basic: GetRelGraph(RelGraph*, int n, RelGraph); SetRelGraph(RelGraph, RelGraph*, int n);
  • Definition of KADMOS_MAJOR, KADMOS_MINOR, KADMOS_MKVER(), and KADMOS_VERSION in Kadmos.h for version-control with the C/C++ preprocessor.
  • Sporadic disappearing characters in rel_do() after leading small dots.
  • Protection error in re_collect() with big images.
  • Protection error in rel_do() at segmentation of very complex images.
  • Partly wrong values of rec_value was not reliable due to an error in rel_do() from error in evaluating the character width.
  • Error in the evaluation of combined specifications for parameter alc.
  • Memory-Leak reading BMP-files.
  • If subimage has been specified for images, then a bmp-file was written to C:\.
  • The functions re_closeimagefile() and re_freeimage() now return KADMOS_ERROR (formerly void).
  • chopper.exe now also works in console windows with more than 80 characters per line.
  • rep_do() in some cases returned lines with a height less than 5 times the stroke width.
  • Memory-leak in rep_do() with recognition of empty images.
  • Grid removal worked incorrectly under rel_do().
  • Error reading Tiff-files in MM-format.
  • Error with binarisation of gray and colour images in Rec, Rel, and Rep.
  • Wrong slope evaluation for classifiers without slope information (norm*.rec, mark.rec).
  • The single threaded libraries rec.lib, rel.lib, rep.lib, and kcl.lib were renamed in rec_st.lib, rel_st.lib, rep_st.lib, and kcl_st.lib.
  • With kadmos.hu now Hungarian is supported for Famulus and the error messages.
  • Slightly changed evaluation of character width for rec_value (Rel, Rep).
  • Memory leak after reading TIFF files.
  • Recognition for slash and backslash was improved for hand print in version 3.5d, but became worse for machine print. The error has been fixed.
  • Error in re_readparm() reading the GRID-settings.
  • Protection error and memory leaks with GRID-detection.
  • The console applications (Chopper, Info, Oem) could be run under code pages 1251-1253 only.
  • The module REP ignored single lines with few, untypical characters.
  • The reConfig-dialog has been extended (save and restore parameter settings).
  • Memory leaks with rep_do() if TYPO_KEEPIMG has been set.
  • The parameters trig_factor and trig_maximum were not evaluated.
  • In rel_do() - if not called from rep_do() - the top position of the recognized single characters was still not filled in correctly.
  • For the return error values of the Kadmos functions the following declaration has been added in kadmos.h: #define KADMOS_ERROR long.
  • The Visual Basic example for the Kadmos integration is now part of the DLL-version of the Kadmos developer kit.
  • The Dll-developer kit now contains a program uninstall.exe, to delete with the removal of all Kadmos files also all Kadmos entries in the registry and in the environment variables.
  • The hand/machine preclassifier is now activated only if really mixed classification of hand and machine print is switched on. Gain in speed for pure hand or pure machine print approximately 5%.
  • The structure definitions in kadmos.h were filled with additional data items (filler), so that all data items are always in the same place under all different compiler settings for the data alignment.
  • The routine to set the trigger code with the Kadmos Dll-version has been revised.
  • The functions re*_textline() were extended with the new macro TEXT_FORMAT_KADMOS_2BYTE.
  • In rel_do() - if not called from rep_do() - the top position of the recognized single characters was not filled in correctly.
  • The parameter alc had been processed incorrectly.
  • Memory-Leak in rel_do() for images with empty pixel lines above or below.
  • Interface for a second engine in REC, REL, and REP via an external structure HookEngineData. Additional parameter 'general' in ReParm to control REC, REL, and REP. Additional macros GENERAL_HOOKENGINE_LOADED and GENERAL_HOOKENGINE_ON.
  • New function rel_lineshadow() to provide the results of pre-classification in hand and machine print. Additional macros GENERAL_PREP_ONLY, GENERAL_LINESHADOW_ONLY, SHADOW_OFFSET, SHADOW_FONT_HAND und SHADOW_FONT_MACHINE. An example how to use rel_lineshadow() can be found in the demo program reldemo.c.
  • Error in parameter setting for comb removal in reconfig.dll.
  • Error in raster image collection via kadmos.ini.
  • The default scaling of images under Kadmos 3.5a to 300 dpi is now optional (PREP_SCALING) and no more default.
  • With Famulus the value of image resolution of the connected image can be changed and be rewritten into the image file.
  • Additional characters in the related classifiers:
    @_ (0x0040 0x005F)  ~_ (0x007E 0x005F)  AU (0x0102 0x005F)
    aU (0x0103 0x005F)  Au (0x0102 0x0020)  au (0x0103 0x0020)
    Ð_ (0x00D0 0x005F)  ð_ (0x00F0 0x005F)   Р(0x00D0 0x0020)
    ð  (0x00F0 0x0020)  Þ_ (0x00DE 0x005F)  þ_ (0x00FE 0x005F)
    Þ  (0x00DE 0x0020)  þ  (0x00FE 0x0020)  TC (0x0162 0x005F)
    tC (0x0163 0x005F)  Tc (0x0162 0x0020)  tc (0x0163 0x0020)
  • Classifiers for Croatia, Iceland, and Romania are provided.
  • The KADMOS developer kit now also contains the mixed classifiers (jumbo*.rec) as default.
  • Instead of the console application Info the developer kit now contains the Windows application ImageInfo.
  • In Famulus the KADMOS-CL classifiers didn't work correctly for images with a resolution different from 300 dpi. The images were transformed to 300 dpi, but this new resolution was not written into the result image data structure.
  • he new function re_clipboard2image() didn't work correctly, and thus the function "edit,paste" in the famulus.
  • The parameter supply for the removal of vertical lines was incorrect (minimal and maximal width and height were exchanged).
  • If the module rel_do() was called with empty images, then memory was allocated internally, but not released correctly.
  • Incorrect preprocessing of images higher than 128 pixels in rel_do() and rec_do().
  • Incorrect supply of resolution in module rel_do() from Tif files.
  • Error in evaluation of OPTIONS_EXCLUDE in rec_do().
As with (almost) all new releases, our new Kadmos 3.5a release too has a several errors inside. We found a lot during CeBIT, especially the mainly new designed module REL. We will work on correction of all of them until mid of May. Simply order an update!

  • Extension of the classifier files Jumbo*.rec, Ttf*.rec, and Numplus*.rec with the OCRA comma.
  • The programs chopper.exe and RecMaker.exe generated some wrong group labels, when executed with a system code page different from code page 850. To check for correctness, check the first label in every group under '[equivalence] rename' in the generated Alc files.
  • Sporadic Error "can not execute MACHNM1.EXE" in the DLL-Version corrected.
  • The classifier Mark.rec has been extended for blind color boxes. Therefore the character classes (labels) '.', '-', '|', 'V', and 'X' have been added (hand and machine print, 'V' handprint only).
  • Classifier Mark.rec prepared for usage with modules REL and REP (up to now usable with REC only).
  • Infinite loop in rep_do() with very big and very noisy images.
  • Error in rel_do() if noise and line removal are set both.
  • Wrong image compression in rel_do() fixed, concerning pixel images with heights of 257 or 513 to 515 pixels.
  • Wrong recognition of the characters -a and -b fixed (Norm.rec, NormOCRA.rec, and NormOCRB.rec).
  • Binarization of gray images and binary filtering in Famulus.exe corrected.
  • Adaptive noise removal. The parameters noise_diameter_percent, noise_width_percent, and noise_length_percent are now 0 by default.
  • Segmentation of touching characters improved.
  • Error fixed in sorting of the result graph (RelGraph).
  • Error in multiple calls of rel_do() with images of more than 128 pixel lines and memory allocation between the rel_do() call without freeing the memory before the next rel_do().
  • Error in re_subimage() if called after re*image() or without biClrUsed filled in correctly in BITMAPINFOHEADER.
  • Character *4 introduced (machine print '*' with full line height).
  • Error, memory leak with gray image processing or filtering in rel_do().
  • Error with spot removal (if result is empty image).
  • New classifiers Norm*.rec (improved E13B and CMC7).
  • Memory leak in case of error (Loop-Error in rel_graph_sort) deleted.
  • Memory leak deleted.
  • Processing of gray images.
  • Binary filtering for image enhancement.
  • Greek classifier for hand and machine print (including combination of both).
  • New function re_bmpfile() to save images out of RecData, RelData, and RepData into a BMP file.
  • Improved recognition of dot matrix print characters '.' and ','.
  • Improved recognition of norm fonts CMC7 and E13B
  • Splitting of machine print digit 1 into form classes 1 and 12 (=lower case l).
  • Improved recognition of numbers in alpha text.
  • Uncompressed tiff files were not read any more under Windows.
  • Wrong (no) evaluation of OPTIONS_EXCLUDE with rec_do(), whenever the same classifier has been initialised simultaneously with rel_init() or rep_init.
  • re_image() now also reads records of multi tiff files with the specification of the record number (up to now only NEXT_IMAGE was implemented).
  • Protection error fixed from setting an invalid context (for instance CONTEXT_ENGLISH for Numplus.rec).
  • Sichten.exe has been implemented for Windows.
  • Error corrected in evaluation of OPTIONS_EXCLUDE.
  • Error corrected in segmentation of wide characters.
  • As the 16-bit Windows 3.11 is no longer supported, some Windows libraries could be renamed:
    rec_wnt.lib, rel_wnt.lib, rep_wnt.lib ⇒ rec.lib, rel.lib, rep.lib
    rec_wntm.lib, rel_wntm.lib, rep_wntm.lib ⇒ rec_mt.lib, rel_mt.lib, rep_mt.lib
    rec_wntd.lib, rel_wntd.lib, rep_wntd.lib ⇒ rec_md.lib, rel_md.lib, rep_md.lib
    rec_wntc.lib, rel_wntc.lib, rep_wntc.lib ⇒ rec_cs.lib, rel_cs.lib, rep_cs.lib
  • Infinit loop in segmentation corrected.
  • The function re_SubImage() has been improved. Now the sub images are provided exactly as requested, without the former alignment to byte boundaries left and right.
  • OPTIONS_FAST added in kadmos.h If set, this option forces faster recognition for handprint classifiers (hand*.rec from 100% to 60%, Jumbo*.rec from 100% to 50%). Quality is a bit lower, as some rec_values are unjustified lower than without this option, But all alternative results are maintained, noise will more often be recognized as a character.
  • Access violation in segmentation corrected.
  • Access violation in GetPrivateFilename() corrected.
  • Access violation in module for reading multi tiff files corrected.
  • Error in segmentation (dissapering characters) corrected.
  • Improved spot removal.
  • Protection error at nonsense context settings (i.e. CONTEXT_GERMAN for Numplus.rec) fixed
  • Segmentation error (missing result) with CMC7 classifiers Norm.rec and NormCMC7.rec fixed.
  • Segmentation error (sporadic missing characters) fixed.
  • re_readparm() now overwrites the explicitly specified parameters only.
  • Changed description of height (size) for '-' and '·' in the classifiers.
  • Improved evaluation of character width and slope, especially for segmentation.
  • Sporadic segmentation error (empty result) with noisy, equidistant lines corrected.
  • The the software copy protection now also works after setting back the computer system date. Of cause this does not hold for time restricted test versions.
  • MMX support reactivated (had been deactivated unintentionally).
  • Improved evaluation of height information of the characters.
  • Computation of more segmentation alternatives.
  • Sporadic GPF fixed in REL with unrecognizable images (for instance if NUMPLUS.REC was applied to alpha lines).
  • Error fixed in REL at images of image_type 'c' and with more than 128 pixel lines (up to now no recognition results in these cases).
  • Error in RecMaker.exe - the generated ALC files contain no resp. wrong size information (f:f).
  • The improved segmentation (from version 3.4h) has led to heavily enlarged computation time in several cases. With this improvement also the macros TYPO_SEGALTERNATIV1 and TYPO_SEGALTERNATIV2 could be removed.
  • Correction of monogram/trigram evaluation. But we are not yet satisfied with the result and working further on the problem.
  • Extension of the classifier label sets (Lattvia).
  • OPTIONS_STRICTSELECT had not been evaluated.
  • Sporadic protection error in segmentation corrected.
  • The Windows program RecMaker.exe is ready and replaces now the batch RECMAKER.BAT. The program should be self describing, but we will deliver a description as soon as possible.
  • The modules re?_textline have been adapted for Unicode.
  • Memory leak with KADMOS integration in MFC applications.
  • Wrong label selection with Unicode.
  • Setting of OPTIONS_EXCLUDE hasn't been processed correctly.
  • kadmos.de and kadmos.uk have been redesigned. They needn't necessarily to be placed in the directory of the calling application. If they are missing, all texts and messages are displayed in English.
  • Improvements / corrections at segmentation.
  • Only few classifiers are delivered directly with the KADMOS software (TTF, HAND, NUMPLUS, NORM, MARK resp. JUMBO with CHOPPER). All national classifiers can be generated with RECMAKER.BAT. For every national classifier an *.AL0 file is delivered. If only some national classifiers are needed, simply delete all other *.AL0 files before starting RECMAKER.BAT. The generation of all national classifiers requires about 300 MB memory and some minutes of CPU time.
  • The labels for the MARK classifier have been changed.
  • The control for alternative segmentation has been refined. TYPO_SEGALTERNATIV1, TYPO_SEGALTERNATIV2 (see manual).
  • Improved segmentation Windows 3.11 is not longer supported.
  • Error in evaluation of parm.labels with group labels.
  • Support of many code pages.New classifiers HAND*.REC and TTF*.REC
  • KADMOS files are in changed subdirectories after the installation.
  • Changes in the KADMOS directories, see current manual, chapter 2.
  • New files KADMOS.DE and KADMOS.UK, see current manual, chapter 2.
  • Improvement of the box recognition.
  • CHOPPER 3.4 error in output of [equivalence] moma, unnecessary output under [equivalence] rename.
  • Empty images delivered a (nonsense) result in rec_do().
  • Error in CHOPPER in case of more than 32 disk equivalences.
  • Extention of configuration possibilities POS_NOWORDCONTEXT. If set, the result will not be corrected according to the detected word type (upper case, lower case, number).
  • Improvements with line- and box recognition.
  • Error correction in rec_end() in case of several loaded classifiers.
  • rel_info() and rep_info() didn't react on the setting of OPTIONS_BASICLABELS (rec_info() was ok.)
  • The coordinates of the line results (rectangles) in the module REP were wrong .
  • Label selection in the modules REL and REP (parm.labels) was without effect in 3.4c.
  • The error handling was extended by two new functions:
    long WINAPI re_SetPrivateData(long private_data);
    long WINAPI re_GetPrivateData(void);
    So every KADMOS module can be given a private identification. In case of error, this identification is given back in the extended structure re_ErrorText (important for parallel execution).
      typedef struct re_ErrorText_tag {
        long ident;
        char program[64];
        char text[512];
        char systext[512];
        long private_data;
      } re_ErrorText;
  • Error in label selection (version 3.4a and 3.4b) corrected. (The error didn't occure if OPTIONS_BASICLABELS has been set.)
In KADMOS 3.4b now - for the first time - the use of several codepages is implemented (Codepages 850, 1250, 1252; ISO-8859-1 and ISO-8859-2). Further codepages can quickly be implemented. reImage.Dll has been integrated in the KADMOS libraries respectively in KADMOS.DLL, i.e. it is no more required. So the related APIs for reading image files and for connecting bitmaps could be simplified - they now work directly with pointers instead of handles.
  • Line segmentation in REP with oversize, black or distorted images could lead to a protection error.
  • The Pharlap Dos Extender is no longer supported.
  • Error in FAMULUS.EXE. The displayed image part could be wrong after loading a new image without the setting "overview"
  • Protection error in segmentation of an almost black noisy image (16 Bit) resp. error loop (32 Bit).
  • Wrong evaluation of path names in re_writeparm() and re_readparm().
  • Error in the software copy protection (KADMOS DLL version) under Windows 95/98.
  • Protection error in module REL with big black areas (> 8 kilobyte for 16 bit version, > 32 kilobyte for 32 bit version).
  • Changed (empowered) impact of parm.exclude=TRUE in module REL and REP.
  • Error in line context for extremely restricted classifiers.
  • Protection error with extremely slope an narrow characters in module REL.
  • after error return of module REP some times an old result has been left in RepData.
  • BMPs in 256 color format are accepted.
  • Error in line segmentation of narrow images in module REP.
  • Error in line segmentation of narrow images in module REP.
  • Rare protection error in segmentation in module REL.
  • Nonsense error message from empty images with more then 1024 lines removed.
  • Error in segmentation in 16 bit version in module REL.
  • infinit loop with very noisy images in module REL.
  • Strange error in REP during recognition of vertical lines corrected ("rel->dim[0]<0").
  • Error in segmentation ("Segmentation impossible") corrected.
  • Error in collecting with KADMOS.INI (line height over 128 pixel) corrected.
  • Program CHOPPER now available as Windows NT version.
  • New classifier F7B.
  • noise reduction in REC corrected.
  • result graph sorting in REL corrected.
  • Error in segmentation ("comp number not found") removed.
  • Infinit loop in REL with an equidistant image corrected senseless error messages with NEEDELPRINT removed (REL) line detection in REP improved.
  • Pointless error message with dot-matrix printing improved occasional line merges.
  • New classifier CMC7
  • With very noisy images in seldom cases very long loops appeared. The problem has been fixed.
  • We detected that the MSVC compiler didn´t return all used MMX registers correctly. We programmed around. The problem didn´t occure with WATCOM and Borland.
  • Infinite loop in REL with noisy images removed
  • KADMOS has a new segmentation for machine print recognition.
  • Using the INI file KADMOS.INI you can switch on/off image collection. The file must be in the same directory as the classifiers.
  • Correction in REL: graph_sorting and spot_removal.
  • Screen output error in CHOPPER version without device=ansi.sys corrected.
  • Segmentation Error corrected.
  • ZAccess violation with POS_LINECHECK corrected.
  • e_writeparm(), re_readparm() corrected.
  • Memory leak with TYPO_KEEPING corrected.
  • ReConfig extended to set POS_LINECHECK
  • More meaningfull segmentation alternatives provided.
  • re_writeparm(), re_readparm() corrected.
  • Incorrect handled re_Error for images over 64k or rel->dim(0) over 1024 lines - corrected.
  • Incorrect placed re_Error call in segmentation module removed.
  • Crash in diskkern caused by compiler error, corrected by switching off some - optimizations.
  • REL line tracking improved.
  • errno for NT version replaced.
  • Protection Error with rel_unlock() corrected.
  • REP line_spacing, REL char_spacing corrected.