~ubuntu-branches/ubuntu/precise/cuneiform/precise

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rneg/sources/src/negmain/rnegbase.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk, c-assert.diff, slovenian-slv.diff
  • Date: 2011-01-26 21:53:07 UTC
  • mfrom: (5.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110126215307-62x61mcesr607qb7
Tags: 1.0.0+dfsg-2
* Upload to unstable.
* Explicitly build-depend on pkg-config. Thanks to Stefano Rivera for the
  bug report.
* Add Vcs-* fields.
* Use the standard C assert() macro, rather than custom Cuneiform one.
  [c-assert.diff]
* Pass CFLAGS, CXXFLAGS and LDFLAGS (get from dpkg-buildflags) to cmake
  (closes: #608345). Thanks to Sami Liedes for the bug report.
  + Build depend on dpkg-dev (>= 1.15.7).
* Pass --parallel to dh.
  + Bump debhelper minimum version to 7.4.10.
* Update debian/copyright to the latest DEP-5 version.
* Bump year in debian/copyright.
* Explicitly link to GraphicsMagick (rather than via the ImageMagick
  compatibility layer).
* Don't ship /usr/lib/cuneiform/*.so symlinks. These libraries are
  considered private, at least until #598616 is fixed.
* Rename some private variables in debian/rules to make them lowercase.
* Update patch headers.
* Provide proper ‘build-arch’ and ‘build-indep’ targets in debian/rules.
* Document input format in the manual page (closes: #572061). Thanks to
  Janusz S. Bień for the bug report.
* Use ‘slv’ (rather than ‘slo’) as language code for Slovenian.
  [slovenian-slv.diff]
* Fix package description: Slovenian is supported, Slovak is not.
* Improve documentation of the language (-l) option (closes: #602512).
  Thanks to Jari Aalto for the bug report.
* Install reasons file for vrms.

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
Copyright (c) 1993-2008, Cognitive Technologies
3
3
All rights reserved.
4
4
 
5
 
����������� ��������� ��������������� � ������������� ��� � ���� ��������� ����,
6
 
��� � � �������� �����, � ����������� ��� ���, ��� ���������� ��������� �������:
7
 
 
8
 
      * ��� ��������� ��������������� ��������� ���� ������ ���������� ���������
9
 
        ���� ����������� �� ��������� �����, ���� ������ ������� � �����������
10
 
        ����� �� ��������.
11
 
      * ��� ��������� ��������������� ��������� ���� � ������������ �/��� �
12
 
        ������ ����������, ������������ ��� ���������������, ������ �����������
13
 
        ��������� ���� ���������� �� ��������� �����, ���� ������ ������� �
14
 
        ����������� ����� �� ��������.
15
 
      * �� �������� Cognitive Technologies, �� ����� �� ����������� �� �����
16
 
        ���� ������������ � �������� �������� ��������� �/��� �����������
17
 
        ���������, ���������� �� ���� ��, ��� ���������������� �����������
18
 
        ����������.
19
 
 
20
 
��� ��������� ������������� ����������� ��������� ���� �/��� ������� ������ "���
21
 
��� ����" ��� ������-���� ���� ��������, ���������� ���� ��� ���������������,
22
 
������� �������� ������������ �������� � ����������� ��� ���������� ����, �� ��
23
 
������������� ���. �� �������� ��������� ���� � �� ���� ������ ����, �������
24
 
����� �������� �/��� �������� �������������� ���������, �� � ���� ������ ��
25
 
��Ѩ� ���������������, ������� ����� �����, ���������, ����������� ���
26
 
������������� ������, ��������� � �������������� ��� ���������� ����������
27
 
������������� ������������� ��������� (������� ������ ������, ��� ������,
28
 
������� ���������, ��� ������ �/��� ������ �������, ���������� ��-�� ��������
29
 
������� ��� �/��� ������ ��������� �������� ��������� � ������� �����������,
30
 
�� �� ������������� ����� ��������), �� �� ������������� ���, ���� ���� �����
31
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
 
5
Разрешается повторное распространение и использование как в виде исходного кода,
 
6
так и в двоичной форме, с изменениями или без, при соблюдении следующих условий:
 
7
 
 
8
      * При повторном распространении исходного кода должны оставаться указанное
 
9
        выше уведомление об авторском праве, этот список условий и последующий
 
10
        отказ от гарантий.
 
11
      * При повторном распространении двоичного кода в документации и/или в
 
12
        других материалах, поставляемых при распространении, должны сохраняться
 
13
        указанная выше информация об авторском праве, этот список условий и
 
14
        последующий отказ от гарантий.
 
15
      * Ни название Cognitive Technologies, ни имена ее сотрудников не могут
 
16
        быть использованы в качестве средства поддержки и/или продвижения
 
17
        продуктов, основанных на этом ПО, без предварительного письменного
 
18
        разрешения.
 
19
 
 
20
ЭТА ПРОГРАММА ПРЕДОСТАВЛЕНА ВЛАДЕЛЬЦАМИ АВТОРСКИХ ПРАВ И/ИЛИ ДРУГИМИ ЛИЦАМИ "КАК
 
21
ОНА ЕСТЬ" БЕЗ КАКОГО-ЛИБО ВИДА ГАРАНТИЙ, ВЫРАЖЕННЫХ ЯВНО ИЛИ ПОДРАЗУМЕВАЕМЫХ,
 
22
ВКЛЮЧАЯ ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ И ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ, НО НЕ
 
23
ОГРАНИЧИВАЯСЬ ИМИ. НИ ВЛАДЕЛЕЦ АВТОРСКИХ ПРАВ И НИ ОДНО ДРУГОЕ ЛИЦО, КОТОРОЕ
 
24
МОЖЕТ ИЗМЕНЯТЬ И/ИЛИ ПОВТОРНО РАСПРОСТРАНЯТЬ ПРОГРАММУ, НИ В КОЕМ СЛУЧАЕ НЕ
 
25
НЕСЁТ ОТВЕТСТВЕННОСТИ, ВКЛЮЧАЯ ЛЮБЫЕ ОБЩИЕ, СЛУЧАЙНЫЕ, СПЕЦИАЛЬНЫЕ ИЛИ
 
26
ПОСЛЕДОВАВШИЕ УБЫТКИ, СВЯЗАННЫЕ С ИСПОЛЬЗОВАНИЕМ ИЛИ ПОНЕСЕННЫЕ ВСЛЕДСТВИЕ
 
27
НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАНИЯ ПРОГРАММЫ (ВКЛЮЧАЯ ПОТЕРИ ДАННЫХ, ИЛИ ДАННЫЕ,
 
28
СТАВШИЕ НЕГОДНЫМИ, ИЛИ УБЫТКИ И/ИЛИ ПОТЕРИ ДОХОДОВ, ПОНЕСЕННЫЕ ИЗ-ЗА ДЕЙСТВИЙ
 
29
ТРЕТЬИХ ЛИЦ И/ИЛИ ОТКАЗА ПРОГРАММЫ РАБОТАТЬ СОВМЕСТНО С ДРУГИМИ ПРОГРАММАМИ,
 
30
НО НЕ ОГРАНИЧИВАЯСЬ ЭТИМИ СЛУЧАЯМИ), НО НЕ ОГРАНИЧИВАЯСЬ ИМИ, ДАЖЕ ЕСЛИ ТАКОЙ
 
31
ВЛАДЕЛЕЦ ИЛИ ДРУГОЕ ЛИЦО БЫЛИ ИЗВЕЩЕНЫ О ВОЗМОЖНОСТИ ТАКИХ УБЫТКОВ И ПОТЕРЬ.
32
32
 
33
33
Redistribution and use in source and binary forms, with or without modification,
34
34
are permitted provided that the following conditions are met:
107
107
int NegRecTYPEE=0;
108
108
 
109
109
 
110
 
BOOL APIENTRY DllMain( HANDLE hModule,
111
 
                        DWORD ul_reason_for_call,
112
 
                        LPVOID lpReserved )
 
110
Bool APIENTRY DllMain( HANDLE hModule,
 
111
uint32_t ul_reason_for_call,
 
112
                        pvoid lpReserved )
113
113
{
114
114
    switch( ul_reason_for_call )
115
115
        {
127
127
 
128
128
/*----------------------------------------------------------------------------*/
129
129
 
130
 
RNEG_FUNC(Bool32) RNEG_Init(Word16 wHeightCode,Handle parent)
 
130
RNEG_FUNC(Bool32) RNEG_Init(uint16_t wHeightCode,Handle parent)
131
131
{
132
132
 LDPUMA_Init(0,NULL);
133
133
 
134
134
 
135
 
 LDPUMA_Registry (&NegRoot,"����� � ������������� ���������", parent);
 
135
 LDPUMA_Registry (&NegRoot,"Поиск и распознование негативов", parent);
136
136
 const char *pText;
137
 
 /*  �������� �������  */
138
 
 pText = "<������������� ���. �����������> \
139
 
 \n �������� ������� ������� ������ � ������������� ���������.";
 
137
 /*  Корневая вершина  */
 
138
 pText = "<Ответственный тов. Степаненков> \
 
139
 \n Корневая вершина отладки поиска и распознавания негативов.";
140
140
 LDPUMA_RegistryHelp (NegRoot, pText, FALSE);
141
141
 LDPUMA_RegVariable (NegRoot,"inf_neg_black",&inf_neg_black,"double");
142
142
 LDPUMA_RegVariable (NegRoot,"sup_neg_black_del",&sup_neg_black_del,"double");
143
143
 LDPUMA_RegVariable (NegRoot,"weak_neg_black_del",&weak_neg_black_del,"double");
144
144
 
145
 
 /*������� ������� ���� �������*/
146
 
 LDPUMA_Registry (&SetSkew,"������ ���� �������", NegRoot);
147
 
 pText = "������ ���� ������� ��������";
 
145
 /*Вершина задания угла наклона*/
 
146
 LDPUMA_Registry (&SetSkew,"Задать угол наклона", NegRoot);
 
147
 pText = "Задать угол наклона страницы";
148
148
 LDPUMA_RegistryHelp (SetSkew, pText, FALSE);
149
149
 LDPUMA_RegVariable (SetSkew,"Skew",&Skew,"int");
150
150
 
151
 
 /*������� ������*/
152
 
 LDPUMA_Registry (&NegSearch,"����� ���������� � ��������", NegRoot);
153
 
 pText = "����� ���������� � ��������";
 
151
 /*Вершина поиска*/
 
152
 LDPUMA_Registry (&NegSearch,"Поиск кандидатов в негативы", NegRoot);
 
153
 pText = "Поиск кандидатов в негативы";
154
154
 LDPUMA_RegistryHelp (NegSearch, pText, FALSE);
155
155
 
156
 
 /*������� pac����������*/
157
 
 LDPUMA_Registry (&NegRec,"������������� ����������� ���������", NegRoot);
158
 
 pText = "������������� ����������� ���������";
 
156
 /*Вершина pacпознования*/
 
157
 LDPUMA_Registry (&NegRec,"Распознавание отловленных негативов", NegRoot);
 
158
 pText = "Распознавание отловленных негативов";
159
159
 LDPUMA_RegistryHelp (NegRec, pText, FALSE);
160
160
 LDPUMA_RegVariable (NegRec,"NegRecTYPEE",&NegRecTYPEE,"int");
161
161
 
162
162
 
163
 
 /*������� ������ �� ��������*/
164
 
 LDPUMA_Registry (&NegSearchSize,"����� �� ��������", NegSearch);
165
 
 pText = "����� ���������� � �������� �� ��������";
 
163
 /*Вершина поиска по размерам*/
 
164
 LDPUMA_Registry (&NegSearchSize,"Поиск по размерам", NegSearch);
 
165
 pText = "Поиск кандидатов в негативы по размерам";
166
166
 LDPUMA_RegistryHelp (NegSearchSize, pText, FALSE);
167
167
 
168
 
 /*������� ������ �� ��������*/
169
 
 LDPUMA_Registry (&NegSize,"����� �� ��������", NegSearch);
170
 
 pText = "����� ���������� � �������� �� ��������";
 
168
 /*Вершина отсева по размерам*/
 
169
 LDPUMA_Registry (&NegSize,"Отсев по размерам", NegSearch);
 
170
 pText = "Отсев кандидатов в негативы по размерам";
171
171
 LDPUMA_RegistryHelp (NegSize, pText, FALSE);
172
172
 
173
 
 /*������� ������������ ��������� ����������*/
174
 
 LDPUMA_Registry (&NegNorm,"������������", NegSearch);
175
 
 pText = "������������ ��������� ���������� � ��������";
 
173
 /*Вершина нормализации найденных кандидатов*/
 
174
 LDPUMA_Registry (&NegNorm,"Нормализация", NegSearch);
 
175
 pText = "Нормализация найденных кандидатов в негативы";
176
176
 LDPUMA_RegistryHelp (NegNorm, pText, FALSE);
177
177
 
178
 
 /*������� ����� ��������� ����������*/
179
 
 LDPUMA_Registry (&NegCut,"�����", NegSearch);
180
 
 pText = "����� ��������� ���������� � ��������";
 
178
 /*Вершина резки найденных кандидатов*/
 
179
 LDPUMA_Registry (&NegCut,"Резка", NegSearch);
 
180
 pText = "Резка найденных кандидатов в негативы";
181
181
 LDPUMA_RegistryHelp (NegCut, pText, FALSE);
182
182
 
183
 
 /*������� ����� �������������*/
184
 
 LDPUMA_Registry (&NegCutStr,"����� �������������", NegSearch);
185
 
 pText = "����� ��������� ������������� ���������� � ��������";
 
183
 /*Вершина резки многострочных*/
 
184
 LDPUMA_Registry (&NegCutStr,"Резка многострочных", NegSearch);
 
185
 pText = "Резка найденных многострочных кандидатов в негативы";
186
186
 LDPUMA_RegistryHelp (NegCutStr, pText, FALSE);
187
187
 
188
 
 /*������� ������ �� �������� �����*/
189
 
 LDPUMA_Registry (&NegColor,"����� �� �������� �����", NegSearch);
190
 
 pText = "����� �� �������� ����� ��������� ���������� � ��������";
 
188
 /*Вершина отсева по цветовой гамме*/
 
189
 LDPUMA_Registry (&NegColor,"Отсев по цветовой гамме", NegSearch);
 
190
 pText = "Отсев по цветовой гамме найденных кандидатов в негативы";
191
191
 LDPUMA_RegistryHelp (NegColor, pText, FALSE);
192
192
 
193
 
 /*������� ���������� ��������� ���������� � �������� �� ��������*/
194
 
 LDPUMA_Registry (&NegSearchSizeD,"���������� �� ��������", NegSearchSize);
195
 
 pText = "���������� ��������� ���������� � �������� �� ��������";
 
193
 /*Вершина прорисовки найденных кандидатов в негативы по размерам*/
 
194
 LDPUMA_Registry (&NegSearchSizeD,"Прорисовка по размерам", NegSearchSize);
 
195
 pText = "Прорисовка найденных кандидатов в негативы по размерам";
196
196
 LDPUMA_RegistryHelp (NegSearchSizeD, pText, FALSE);
197
197
 
198
 
 /*���� �� ��������� ?*/
199
 
 LDPUMA_Registry (&NegSearchSizeDC,"�� �������!!!", NegSearchSizeD);
200
 
 pText = "���������� ��� ��������";
 
198
 /*Надо ли подчищать ?*/
 
199
 LDPUMA_Registry (&NegSearchSizeDC,"Не чистить!!!", NegSearchSizeD);
 
200
 pText = "Специально для ГРЯЗНУЛЬ";
201
201
 LDPUMA_RegistryHelp (NegSearchSizeDC, pText, FALSE);
202
202
 
203
 
 /*������� ���������� ��������� ���������� � �������� �� ��������*/
204
 
 LDPUMA_Registry (&NegSizeD,"������������� ���������� �� ��������", NegSize);
205
 
 pText = "���������� ��������� ���������� � �������� �� ��������";
 
203
 /*Вершина прорисовки отсеянных кандидатов в негативы по размерам*/
 
204
 LDPUMA_Registry (&NegSizeD,"Окончательная прорисовка по размерам", NegSize);
 
205
 pText = "Прорисовка отсеянных кандидатов в негативы по размерам";
206
206
 LDPUMA_RegistryHelp (NegSizeD, pText, FALSE);
207
207
 
208
 
/*���� �� ��������� ?*/
209
 
 LDPUMA_Registry (&NegSizeDC,"�� �������!!!!", NegSizeD);
210
 
 pText = "���������� ��� ��������";
 
208
/*Надо ли подчищать ?*/
 
209
 LDPUMA_Registry (&NegSizeDC,"Не чистить!!!!", NegSizeD);
 
210
 pText = "Специально для ГРЯЗНУЛЬ";
211
211
 LDPUMA_RegistryHelp (NegSizeDC, pText, FALSE);
212
212
 
213
 
 /*������� ���������� ��������������� ���������� � ��������*/
214
 
 LDPUMA_Registry (&NegNormD,"���������� ���������������", NegNorm);
215
 
 pText = "���������� ��������������� ���������� � ��������";
 
213
 /*Вершина прорисовки нормализованных кандидатов в негативы*/
 
214
 LDPUMA_Registry (&NegNormD,"Прорисовка нормализованных", NegNorm);
 
215
 pText = "Прорисовка нормализованных кандидатов в негативы";
216
216
 LDPUMA_RegistryHelp (NegNormD, pText, FALSE);
217
217
 
218
 
 /*���� �� ��������� ?*/
219
 
 LDPUMA_Registry (&NegNormDC,"�� ���������!!!", NegNormD);
220
 
 pText = "���������� ��� ��������";
 
218
 /*Надо ли подчищать ?*/
 
219
 LDPUMA_Registry (&NegNormDC,"Не подтирать!!!", NegNormD);
 
220
 pText = "Специально для ГРЯЗНУЛЬ";
221
221
 LDPUMA_RegistryHelp (NegNormDC, pText, FALSE);
222
222
 
223
 
 /*������� ���������� ����������� ���������� � ��������*/
224
 
 LDPUMA_Registry (&NegCutD,"���������� �����������", NegCut);
225
 
 pText = "���������� ����������� ���������� � ��������";
 
223
 /*Вершина прорисовки разрезанных кандидатов в негативы*/
 
224
 LDPUMA_Registry (&NegCutD,"Прорисовка разрезанных", NegCut);
 
225
 pText = "Прорисовка разрезанных кандидатов в негативы";
226
226
 LDPUMA_RegistryHelp (NegCutD, pText, FALSE);
227
227
 
228
 
 /*���� �� ��������� ?*/
229
 
 LDPUMA_Registry (&NegCutDC,"�� ���������!!!!", NegCutD);
230
 
 pText = "���������� ��� ��������";
 
228
 /*Надо ли подчищать ?*/
 
229
 LDPUMA_Registry (&NegCutDC,"Не подтирать!!!!", NegCutD);
 
230
 pText = "Специально для ГРЯЗНУЛЬ";
231
231
 LDPUMA_RegistryHelp (NegCutDC, pText, FALSE);
232
232
 
233
 
 /*������� ���������� ����������� ������������� ���������� � ��������*/
234
 
 LDPUMA_Registry (&NegCutStrD,"���������� ����������� �������������", NegCutStr);
235
 
 pText = "���������� ����������� ������������� ���������� � ��������";
 
233
 /*Вершина прорисовки разрезанных многострочных кандидатов в негативы*/
 
234
 LDPUMA_Registry (&NegCutStrD,"Прорисовка разрезанных многострочных", NegCutStr);
 
235
 pText = "Прорисовка разрезанных многострочных кандидатов в негативы";
236
236
 LDPUMA_RegistryHelp (NegCutStrD, pText, FALSE);
237
237
 
238
 
 /*���� �� ��������� ?*/
239
 
 LDPUMA_Registry (&NegCutStrDC,"�� ���������!!!!!", NegCutStrD);
240
 
 pText = "���������� ��� ��������";
 
238
 /*Надо ли подчищать ?*/
 
239
 LDPUMA_Registry (&NegCutStrDC,"Не подтирать!!!!!", NegCutStrD);
 
240
 pText = "Специально для ГРЯЗНУЛЬ";
241
241
 LDPUMA_RegistryHelp (NegCutStrDC, pText, FALSE);
242
242
 
243
 
 /*������� ���������� ����� ������ �� �������� �����*/
244
 
 LDPUMA_Registry (&NegColorD,"���������� �� �������� �����", NegColor);
245
 
 pText = "���������� ���������� � �������� ����� ������ �� �������� �����";
 
243
 /*Вершина прорисовки после отсева по цветовой гамме*/
 
244
 LDPUMA_Registry (&NegColorD,"Прорисовка по цветовой гамме", NegColor);
 
245
 pText = "Прорисовка кандидатов в негативы после отсева по цветовой гамме";
246
246
 LDPUMA_RegistryHelp (NegColorD, pText, FALSE);
247
247
 
248
 
 /*���� �� ��������� ?*/
249
 
 LDPUMA_Registry (&NegColorDC,"�� ���������!!!", NegColorD);
250
 
 pText = "���������� ��� ��������";
 
248
 /*Надо ли подчищать ?*/
 
249
 LDPUMA_Registry (&NegColorDC,"Не подчищать!!!", NegColorD);
 
250
 pText = "Специально для ГРЯЗНУЛЬ";
251
251
 LDPUMA_RegistryHelp (NegColorDC, pText, FALSE);
252
252
 
253
 
 /*������� ���������� ��������� � ��������*/
254
 
 LDPUMA_Registry (&NegRecD,"���������� ���������", NegRec);
255
 
 pText = "���������� ��������� � ��������";
 
253
 /*Вершина прорисовки компонент в негативе*/
 
254
 LDPUMA_Registry (&NegRecD,"Прорисовка компонент", NegRec);
 
255
 pText = "Прорисовка компонент в негативе";
256
256
 LDPUMA_RegistryHelp (NegRecD, pText, FALSE);
257
257
 
258
 
 /*���� �� ��������� ?*/
259
 
 LDPUMA_Registry (&NegRecDC,"�� �������!!!", NegRecD);
260
 
 pText = "���������� ��� ��������";
 
258
 /*Надо ли подчищать ?*/
 
259
 LDPUMA_Registry (&NegRecDC,"Не стирать!!!", NegRecD);
 
260
 pText = "Специально для ГРЯЗНУЛЬ";
261
261
 LDPUMA_RegistryHelp (NegRecDC, pText, FALSE);
262
262
 
263
 
 /*������� ���������� ����������*/
264
 
 LDPUMA_Registry (&NegResD,"���������� �������� ����������", NegRoot);
265
 
 pText = "���������� �������� ����������";
 
263
 /*Вершина прорисовки результата*/
 
264
 LDPUMA_Registry (&NegResD,"Визуальный просмотр результата", NegRoot);
 
265
 pText = "Визуальный просмотр результата";
266
266
 LDPUMA_RegistryHelp (NegResD, pText, FALSE);
267
267
 PrintResConsole=NegResD;
268
268
 
269
 
 /*����� ��������� � ����������� �������� � ��������� ������������*/
270
 
 LDPUMA_Registry (&hShowNegComps, "�������� ��������� � ��������� ����", NegResD);
271
 
 LDPUMA_RegistryHelp (hShowNegComps, "������ ���������� � ������������ �������� ������������ ��� ���� ����������: �����-����� � ������-����", FALSE);
 
269
 /*Показ компонент в вертикаьном негативе в различных направлениях*/
 
270
 LDPUMA_Registry (&hShowNegComps, "Просмотр компонент в отдельном окне", NegResD);
 
271
 LDPUMA_RegistryHelp (hShowNegComps, "Каждая компонента в вертикальном негативе показывается для двух напрвлений: снизу-вверх и сверху-вниз", FALSE);
272
272
 
273
 
 /*������� ������ � ���� ����������*/
274
 
 LDPUMA_Registry (&NegPrintFILE,"������ � ���� �����������", NegRoot);
275
 
 pText = "������ � ���� recneg.res �����������";
 
273
 /*Вершина печати в файл результата*/
 
274
 LDPUMA_Registry (&NegPrintFILE,"Печать в файл результатов", NegRoot);
 
275
 pText = "Печать в файл recneg.res результатов";
276
276
 LDPUMA_RegistryHelp (NegPrintFILE, pText, FALSE);
277
277
 
278
 
/*������� ������ � ������� ����������*/
 
278
/*Вершина печати в консоль результата*/
279
279
/*
280
 
 LDPUMA_Registry (&PrintResConsole,"������ � ������� �����������", NegRoot);
281
 
 pText = "������ � ������� ����������� ������������� � ������������� ������";
 
280
 LDPUMA_Registry (&PrintResConsole,"Печать в консоль результатов", NegRoot);
 
281
 pText = "Печать в консоль результатов распознавания и вероятностных оценок";
282
282
 LDPUMA_RegistryHelp (PrintResConsole, pText, FALSE);
283
283
*/
284
 
 /*������������ ������� RecogOneLetter*/
285
 
 LDPUMA_Registry (&RecOneLetter,"������������ ������� RecogOneLetter", NegRec);
286
 
 pText = "������������ ������� RecogOneLetter";
 
284
 /*Использовать функцию RecogOneLetter*/
 
285
 LDPUMA_Registry (&RecOneLetter,"Использовать функцию RecogOneLetter", NegRec);
 
286
 pText = "Использовать функцию RecogOneLetter";
287
287
 LDPUMA_RegistryHelp (RecOneLetter, pText, FALSE);
288
288
 
289
 
 /*���� ���������� CHSTR*/
290
 
 LDPUMA_Registry (&TestCHSTR,"���� ���������� CHSTR", NegRoot);
291
 
 pText = "�������� � CHSTR ������ � �����������, ��������� � ������ �������";
 
289
 /*Тест контейнера CHSTR*/
 
290
 LDPUMA_Registry (&TestCHSTR,"Тест контейнера CHSTR", NegRoot);
 
291
 pText = "Положить в CHSTR объект с параметрами, заданными в данной вершине";
292
292
 LDPUMA_RegistryHelp (TestCHSTR, pText, FALSE);
293
293
 LDPUMA_RegVariable (TestCHSTR,"TOP",&TOP,"int");
294
294
 LDPUMA_RegVariable (TestCHSTR,"BOTTOM",&BOTTOM,"int");
297
297
 LDPUMA_RegVariable (TestCHSTR,"VERTICALE",&VERTICALE,"int");
298
298
 LDPUMA_RegVariable (TestCHSTR,"NEGATIVE",&NEGATIVE,"int");
299
299
 
300
 
 /*���� ���������� CHSTR*/
301
 
 LDPUMA_Registry (&PutToCHSTR,"���������� ���������� � CHSTR", NegRoot);
302
 
 pText = "���������� ���������� ���������� � CHSTR";
 
300
 /*Тест контейнера CHSTR*/
 
301
 LDPUMA_Registry (&PutToCHSTR,"Складывать результаты в CHSTR", NegRoot);
 
302
 pText = "Складывать приемлимые результаты в CHSTR";
303
303
 LDPUMA_RegistryHelp (PutToCHSTR, pText, FALSE);
304
304
 
305
 
 /*���������� ���������� � CPage*/
306
 
 LDPUMA_Registry (&PutToCPage,"���������� ���������� � CPage", NegRoot);
307
 
 pText = "���������� ���������� ���������� � CPage";
 
305
 /*Складывать результаты в CPage*/
 
306
 LDPUMA_Registry (&PutToCPage,"Складывать результаты в CPage", NegRoot);
 
307
 pText = "Складывать приемлимые результаты в CPage";
308
308
 LDPUMA_RegistryHelp (PutToCPage, pText, FALSE);
309
309
 LDPUMA_RegVariable (PutToCPage,"inf_prob",&inf_prob,"double");
310
310
 
311
 
 LDPUMA_Registry (&hTime,"�������� �������!!!!!!", NegRoot);
312
 
 pText = "�������� �������!";
 
311
 LDPUMA_Registry (&hTime,"Контроль времени!!!!!!", NegRoot);
 
312
 pText = "Контроль времени!";
313
313
 LDPUMA_RegistryHelp (hTime, pText, FALSE);
314
314
 
315
315
 
323
323
        return TRUE;
324
324
}
325
325
/*---------------------------------------------------------------------------*/
326
 
RNEG_FUNC(Word32) RNEG_GetReturnCode()
 
326
RNEG_FUNC(uint32_t) RNEG_GetReturnCode()
327
327
{
328
 
        return (Word32)(0);
 
328
        return (uint32_t)(0);
329
329
}
330
330
/*---------------------------------------------------------------------------*/
331
 
RNEG_FUNC(Int8 *) RNEG_GetReturnString(Word32 dwError)
 
331
RNEG_FUNC(char *) RNEG_GetReturnString(uint32_t dwError)
332
332
{
333
333
        return NULL;
334
334
}
335
335
/*---------------------------------------------------------------------------*/
336
 
RNEG_FUNC(Bool32) RNEG_GetExportData(Word32 dwType, void * pData)
 
336
RNEG_FUNC(Bool32) RNEG_GetExportData(uint32_t dwType, void * pData)
337
337
{
338
338
 
339
339
 
352
352
}
353
353
 
354
354
/*---------------------------------------------------------------------------*/
355
 
RNEG_FUNC(Bool32) RNEG_SetImportData(Word32 dwType, void *pData)
 
355
RNEG_FUNC(Bool32) RNEG_SetImportData(uint32_t dwType, void *pData)
356
356
{
357
357
 
358
358
        return FALSE;