News & Bugs

16-May-2022

• Rare crash in rep_do().

25-April-2022

• Reading of PDF files implemented.

03-Nov-2021

• Corrupted REC files. New computation of large parts of them.

29-June-2021

• Rare memory leaks got corrected.

KADMOS Warp2 is our latest development of the proven KADMOS single character recognition technology using so-called basic classifiers. Warp2 achieves a measured improvement of single character recognition of 10-20% compared to the previous version.

How does KADMOS Warp2 achieve this improvement?
The basic classifiers used by KADMOS for single character recognition separate the feature clouds of the individual character classes with specially curved separation surfaces. The parameters for the curvature of the separators are chosen in such a way that the best possible separation is achieved with a minimum number of features in as many cases as possible.
The previous version of KADMOS recognises just over 1'000 individual character classes with almost 600'000 basic classifiers, which are calculated in such a way that each of them provides less than 0.01% substitutions. Unfortunately, this only works for 99.5% of all basic classifiers.

With KADMOS Warp2, we succeeded in finding a solution for the remaining half percent - about 2'500 basic classifiers - so that these also provide less than 0.01% substitutions. Our trick: For the remaining 2'500 basic classifiers we have provided a new, second set of curved separators. Hence the name Warp2.
This means for you an even more powerful and reliable single character recognition with the new KADMOS Warp2 technology.

• New locally heavily improved classifiers Jumbo, Fraktur, Hand and Ttf.
• Support of the 64 bit versions of the operating systems iOS and Android.

• 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.

• Bug in rec_accent() with distinction of (multiple) accented characters and special signs which consist of multiple components (:, ;, ..).

• Improved recognition of multiple accented characters (Vietnam).
• New computation of all classifiers jumbo*.rec, hand*.rec, ttf*.rec and num*.rec.

• 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().

• 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().

• 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 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.

• Very rare, very old bug in alternative segmentation, resulting in an endless loop in RelGraph.

• Bug in the subroutine chopkern. So RecMaker, Chopper, and Alcfill didn't work correctly.

• 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.

• With neatly written hand print, the mixed classifiers jumbo*.rec and num*.rec sometimes activated their machine print part only for recognition.

• Rare crash in re_layout(), and so also in re_page() and re_idcard().

• 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.

• 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.

• New parameter RESPELL_DICTIONARY_COMPLETE for RESPELL.
• Extension of the classifier hand_s.rec with the most common accents.

• 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().

• 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.

• 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.

• Error in re?_textline with the output of ligatures under Unicode.
• Error "loop" in rel_do() processing horozontal lines without lines removal.

• Error reading TIFF with missing specification of bitspersample.

• Error with parameter OPTIONS_STRICTSELECT. Not all deselected character classes were excluded during classification.

• Very rare endless loop in rel_do().

• Allocation problem in rel_lineshadow().
• Error in the combination of Kadmos dll version and server version.
• Integration of the full Open Source Tiff library.

• Remarkably improved blank recognition, especially with machine print.

• Rare floating point exception. Several inconsistencies in accent recognition.

• 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.

• 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().

• 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.

• 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.

• 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.

• Wrong plausibility check in rel_do() with images, that internally got enlarged by PREP_SCALING.
• Improved treatment of small i without i-dot.

• 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.

• 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().
• CODE_ASCII_GREEK_EXTENDED removed.

• 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.

• 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.

• 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.

• 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'.

• Integration of libpng version 1.2.10 and extension to color PNG images.

• 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.

• Access violation in blank detection in rel_do() with noise-only lines.

• 6 dot Braille classifier available on request.

• 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.

• 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.

• Improved memory handling in rep_do(), especially for large images.

• 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().

• 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).

• Sporadic Protection Error with grid detection in empty images.
• Wrong treatment of nonsense resolution values in rel_do().

• 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).

• 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.

• 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.

• 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

• 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.

• 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.

• 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 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 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.

• 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.

• 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.

• 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.

• 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.

• 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).

• Memory leak in case of error (Loop-Error in rel_graph_sort) 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.

• Wrong (no) evaluation of OPTIONS_EXCLUDE with rec_do(), whenever the same classifier has been initialised simultaneously with rel_init() or rep_init.

• 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

• 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.

• 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.

• 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).

• 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.

• Setting of OPTIONS_EXCLUDE hasn't been processed correctly.

• 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.

• Error in CHOPPER in case of more than 32 disk equivalences.

• Improvements with line- and box recognition.
• Error correction in rec_end() in case of several loaded classifiers.

• 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.)

• Line segmentation in REP with oversize, black or distorted images could lead to a protection error.

• The Pharlap Dos Extender is no longer supported.

• 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().

• Protection error in module REL with big black areas (> 8 kilobyte for 16 bit version, > 32 kilobyte for 32 bit version).

• Protection error with extremely slope an narrow characters in module REL.

• Error in line segmentation of narrow images in module REP.

• Rare protection error in segmentation in module REL.

• Error in segmentation in 16 bit version in module REL.

• Strange error in REP during recognition of vertical lines corrected ("rel->dim[0]<0").

• Program CHOPPER now available as Windows NT version.

• noise reduction in REC corrected.
• result graph sorting in REL corrected.

• Error in segmentation ("comp number not found") removed.

• 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

• Correction in REL: graph_sorting and spot_removal.

• 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

• Incorrect handled re_Error for images over 64k or rel->dim(0) over 1024 lines - corrected.

• 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.