← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rline/sources/rline.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
http://bugs.debian.org/608345
http://bugs.debian.org/572061
http://bugs.debian.org/602512
* 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:
cuneiform_src/Kern/rline/sources/rline.cpp
1
1
/*
2
 
Copyright (c) 1993-2008, Cognitive Technologies
3
 
All rights reserved.
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
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
32
 
 
33
 
Redistribution and use in source and binary forms, with or without modification,
34
 
are permitted provided that the following conditions are met:
35
 
 
36
 
    * Redistributions of source code must retain the above copyright notice,
37
 
      this list of conditions and the following disclaimer.
38
 
    * Redistributions in binary form must reproduce the above copyright notice,
39
 
      this list of conditions and the following disclaimer in the documentation
40
 
      and/or other materials provided with the distribution.
41
 
    * Neither the name of the Cognitive Technologies nor the names of its
42
 
      contributors may be used to endorse or promote products derived from this
43
 
      software without specific prior written permission.
44
 
 
45
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
46
 
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
47
 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48
 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
49
 
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50
 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
51
 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
52
 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
53
 
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
54
 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55
 
*/
 
2
 Copyright (c) 1993-2008, Cognitive Technologies
 
3
 All rights reserved.
 
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
 ВЛАДЕЛЕЦ ИЛИ ДРУГОЕ ЛИЦО БЫЛИ ИЗВЕЩЕНЫ О ВОЗМОЖНОСТИ ТАКИХ УБЫТКОВ И ПОТЕРЬ.
 
32
 
 
33
 Redistribution and use in source and binary forms, with or without modification,
 
34
 are permitted provided that the following conditions are met:
 
35
 
 
36
 * Redistributions of source code must retain the above copyright notice,
 
37
 this list of conditions and the following disclaimer.
 
38
 * Redistributions in binary form must reproduce the above copyright notice,
 
39
 this list of conditions and the following disclaimer in the documentation
 
40
 and/or other materials provided with the distribution.
 
41
 * Neither the name of the Cognitive Technologies nor the names of its
 
42
 contributors may be used to endorse or promote products derived from this
 
43
 software without specific prior written permission.
 
44
 
 
45
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
46
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
47
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
48
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 
49
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
50
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
51
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 
52
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 
53
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
54
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
55
 */
56
56
 
57
57
// ============================================================================
58
58
//
60
60
 
61
61
 
62
62
#include <stdlib.h>
63
 
/*#include <windows.h>*/
64
63
#include <memory.h>
65
 
/*#include <crtdbg.h>*/
66
64
#include <fstream>
67
65
#include <stdio.h>
68
66
#include <assert.h>
71
69
#include "rline.h"
72
70
#include "cline.h"
73
71
#include "ctiimage.h"
74
 
#include "c_types.h"
75
72
#include "cpage.h"
76
73
#include "lns.h"
77
74
#include "dpuma.h"
80
77
 
81
78
#include "compat_defs.h"
82
79
 
83
 
Handle    hMainWindow;
84
 
 
85
 
Handle    RLINE_Root;
86
 
 
87
 
Handle    hRLINE_Pass1;
88
 
Handle    hRLINE_Pass2;
89
 
Handle    hRLINE_Pass3;
90
 
 
91
 
Handle    hMainDebug;
92
 
 
93
 
Handle    RLINE_Search;
94
 
Handle    hRLINE_Correct;
95
 
 
96
 
Handle    hRLINE_Search_Debug;
97
 
Handle    hRLINE_Search_Output;
98
 
Handle    hRLINE_Search_Output_ShowFrags;
99
 
Handle    hRLINE_CorrectOutput;
100
 
Handle    hRLINE_CorrectDebug;
101
 
Handle    hRLINE_CorrectDebugFrag;
102
 
Handle    hRLINE_CorrectControl;
103
 
Handle    hRLINE_CorrectDrawLines;
104
 
Handle    hRLINE_CorrectDrawFrags;
105
 
Handle    hRLINE_Pass3_Control;
106
 
Handle    hRLINE_Pass3Input;
107
 
Handle    hRLINE_Pass3Output;
108
 
Handle    hRLINE_Pass3DrawLines;
109
 
Handle    hRLINE_Pass3DrawFrags;
110
 
Handle    RLINE_NoFillgap;
111
 
Handle    RLINE_NoHorBorder;
112
 
Handle    RLINE_NoVerBorder;
113
 
Handle    RLINE_ShowLines;
114
 
Handle    RLINE_DeleteAll;
115
 
Handle    RLINE_ShowWithoutLines;
116
 
Handle    hDotKilledD;
117
 
Handle    hWriteLineInFile;
118
 
Handle    hWriteLineInFile3;
119
 
Handle    hSkipDelSmallLines;
120
 
Handle    hLinesPass2;
121
 
Handle    hPrint1Cr;
122
 
Handle    hPrint2Cr;
123
 
Handle    hPrint3Cr;
124
 
Handle    hPrint4Cr;
125
 
Handle    hDrawCrRast;
126
 
Handle    hRLINE_Pass2Output;
127
 
Handle    hRLINE_Pass2DrawLines;
128
 
Handle    hRLINE_Pass2DrawFrags;
129
 
Handle    hLinesPass2Debug;
130
 
Handle    hLinesPass2DebugSkipDouble;
131
 
Handle    hLinesPass2DebugSkipGlue;
132
 
Handle    hLinesPass2DebugSkipFindLost;
133
 
Handle    hDebugPrintCrossCheck;
134
 
 
135
 
Handle    hDebugDrowTableZone;
136
 
Handle    hDebugDrowFriendLines;
137
 
Handle    hDebugDrowGroupOfExtensibleLines;
138
 
Handle    hDebugDrawLosedVerticalLines;
139
 
Handle    hWriteLineInFile2;
140
 
 
141
 
Handle    hDebugShortLinesPrint;
142
 
Handle    hDebugShortLinesDrawRect;
143
 
Handle    hShowCP;
144
 
Handle    hShowCheckedRects;
145
 
Handle    hPrintCheckedRects;
146
 
Handle    hShowCPLines;
147
 
 
148
 
Int32 hMinInterval = 10;
149
 
Int32 h1Interval = 25;
150
 
Int32 h2Interval = 63;
151
 
Int32 hMaxInterval = 150;
152
 
Int32 hSmallLineLen = 20;
153
 
Int32 hLongLineLen = 50;
154
 
Int32 hMaxDegreeDiff = 5;
155
 
Int32 hMaxShift = 36;
156
 
Int32 hRastDelta = 1;
157
 
Int32 hRLINE_Pass2Lost1 = 75;
158
 
Int32 hRLINE_Pass2Lost2 = 95;
 
80
Handle hMainWindow;
 
81
 
 
82
Handle RLINE_Root;
 
83
 
 
84
Handle hRLINE_Pass1;
 
85
Handle hRLINE_Pass2;
 
86
Handle hRLINE_Pass3;
 
87
 
 
88
Handle hMainDebug;
 
89
 
 
90
Handle RLINE_Search;
 
91
Handle hRLINE_Correct;
 
92
 
 
93
Handle hRLINE_Search_Debug;
 
94
Handle hRLINE_Search_Output;
 
95
Handle hRLINE_Search_Output_ShowFrags;
 
96
Handle hRLINE_CorrectOutput;
 
97
Handle hRLINE_CorrectDebug;
 
98
Handle hRLINE_CorrectDebugFrag;
 
99
Handle hRLINE_CorrectControl;
 
100
Handle hRLINE_CorrectDrawLines;
 
101
Handle hRLINE_CorrectDrawFrags;
 
102
Handle hRLINE_Pass3_Control;
 
103
Handle hRLINE_Pass3Input;
 
104
Handle hRLINE_Pass3Output;
 
105
Handle hRLINE_Pass3DrawLines;
 
106
Handle hRLINE_Pass3DrawFrags;
 
107
Handle RLINE_NoFillgap;
 
108
Handle RLINE_NoHorBorder;
 
109
Handle RLINE_NoVerBorder;
 
110
Handle RLINE_ShowLines;
 
111
Handle RLINE_DeleteAll;
 
112
Handle RLINE_ShowWithoutLines;
 
113
Handle hDotKilledD;
 
114
Handle hWriteLineInFile;
 
115
Handle hWriteLineInFile3;
 
116
Handle hSkipDelSmallLines;
 
117
Handle hLinesPass2;
 
118
Handle hPrint1Cr;
 
119
Handle hPrint2Cr;
 
120
Handle hPrint3Cr;
 
121
Handle hPrint4Cr;
 
122
Handle hDrawCrRast;
 
123
Handle hRLINE_Pass2Output;
 
124
Handle hRLINE_Pass2DrawLines;
 
125
Handle hRLINE_Pass2DrawFrags;
 
126
Handle hLinesPass2Debug;
 
127
Handle hLinesPass2DebugSkipDouble;
 
128
Handle hLinesPass2DebugSkipGlue;
 
129
Handle hLinesPass2DebugSkipFindLost;
 
130
Handle hDebugPrintCrossCheck;
 
131
 
 
132
Handle hDebugDrowTableZone;
 
133
Handle hDebugDrowFriendLines;
 
134
Handle hDebugDrowGroupOfExtensibleLines;
 
135
Handle hDebugDrawLosedVerticalLines;
 
136
Handle hWriteLineInFile2;
 
137
 
 
138
Handle hDebugShortLinesPrint;
 
139
Handle hDebugShortLinesDrawRect;
 
140
Handle hShowCP;
 
141
Handle hShowCheckedRects;
 
142
Handle hPrintCheckedRects;
 
143
Handle hShowCPLines;
 
144
 
 
145
int32_t hMinInterval = 10;
 
146
int32_t h1Interval = 25;
 
147
int32_t h2Interval = 63;
 
148
int32_t hMaxInterval = 150;
 
149
int32_t hSmallLineLen = 20;
 
150
int32_t hLongLineLen = 50;
 
151
int32_t hMaxDegreeDiff = 5;
 
152
int32_t hMaxShift = 36;
 
153
int32_t hRastDelta = 1;
 
154
int32_t hRLINE_Pass2Lost1 = 75;
 
155
int32_t hRLINE_Pass2Lost2 = 95;
159
156
//Handle    hUseCLine;
160
 
void *    hTmpDIB;
161
 
Word32    HorType;
162
 
Word32    VerType;
 
157
void * hTmpDIB;
 
158
uint32_t HorType;
 
159
uint32_t VerType;
163
160
 
164
161
Handle Parts;
165
162
Handle Part2;
178
175
Bool32 gbNOHBORDER = FALSE;
179
176
Bool32 gbNOVBORDER = FALSE;
180
177
 
181
 
CIMAGEIMAGECALLBACK         cbk;
 
178
CIMAGEIMAGECALLBACK cbk;
182
179
 
183
180
Imxs* swp_imxs;
184
181
Imxs imxs;
185
182
 
186
 
 
187
 
Word16    min_h_len = 40,
188
 
              min_v_len = 40;
189
 
Word16    rc16;
190
 
Word32    rc32;
191
 
 
192
 
        //Almi 16.05.01
193
 
    int MinHorLenForTrue = 129;//113;//���� 100
194
 
        int MinVerLenForTrue = 94;//58; //����  50
 
183
uint16_t min_h_len = 40, min_v_len = 40;
 
184
uint16_t rc16;
 
185
uint32_t rc32;
 
186
 
 
187
//Almi 16.05.01
 
188
int MinHorLenForTrue = 129;//113;//было 100
 
189
int MinVerLenForTrue = 94;//58; //было  50
195
190
//////////////////////////////////////////////////////////////////////////////////////////////
196
191
 
197
 
void SetReturnCode_rline( Word32 );
198
 
void SetReturnCode_rline( Word16 );
199
 
void CleanLineData( void* pdata,int size);
200
 
 
201
 
 
202
 
Bool16 SampleImageOpen (CIMAGE_ImageInfo* lpImageInfo)
203
 
{ return swp_imxs->f_op( (Imxs_ImageInfo*)lpImageInfo ); }
204
 
Word16 SampleImageRead ( PInt8 lpImage, Word16 wMaxSize)
205
 
{ return swp_imxs->f_re( (Word8*)lpImage, wMaxSize ); }
206
 
Bool16 SampleImageClose ( void )
207
 
{ return swp_imxs->f_cl( ); }
208
 
 
209
 
 
210
 
Bool16 DibOpen (Imxs_ImageInfo* lpImageInfo)
211
 
{ return cbk.CIMAGE_ImageOpen( (CIMAGE_ImageInfo*)lpImageInfo ); }
212
 
Int16  DibRead ( Word8* lpImage, Word16 wMaxSize)
213
 
{ return cbk.CIMAGE_ImageRead( (PInt8)lpImage, wMaxSize ); }
214
 
Bool16 DibClose ( void )
215
 
{ return cbk.CIMAGE_ImageClose( ); }
216
 
 
217
 
 
218
 
 
219
 
Bool32 RLINE_SubInit ( void )
220
 
{
221
 
        hMainWindow = LDPUMA_CreateWindow( NULL, NULL );
222
 
 
223
 
        LDPUMA_Registry(&hMainDebug,SNAP_ROOT_MAIN_DEBUG,NULL);
224
 
 
225
 
        LDPUMA_Registry(&RLINE_Root,SNAP_ROOT_LINES, NULL); // ����������� ������� �������
 
192
void SetReturnCode_rline(uint32_t);
 
193
void SetReturnCode_rline(uint16_t);
 
194
void CleanLineData(void* pdata, int size);
 
195
 
 
196
Bool16 SampleImageOpen(CIMAGE_ImageInfo* lpImageInfo) {
 
197
        return swp_imxs->f_op((Imxs_ImageInfo*) lpImageInfo);
 
198
}
 
199
uint16_t SampleImageRead(pchar lpImage, uint16_t wMaxSize) {
 
200
        return swp_imxs->f_re((uchar*) lpImage, wMaxSize);
 
201
}
 
202
Bool16 SampleImageClose(void) {
 
203
        return swp_imxs->f_cl();
 
204
}
 
205
 
 
206
Bool16 DibOpen(Imxs_ImageInfo* lpImageInfo) {
 
207
        return cbk.CIMAGE_ImageOpen((CIMAGE_ImageInfo*) lpImageInfo);
 
208
}
 
209
int16_t DibRead(uchar* lpImage, uint16_t wMaxSize) {
 
210
        return cbk.CIMAGE_ImageRead((pchar) lpImage, wMaxSize);
 
211
}
 
212
Bool16 DibClose(void) {
 
213
        return cbk.CIMAGE_ImageClose();
 
214
}
 
215
 
 
216
Bool32 RLINE_SubInit(void) {
 
217
        hMainWindow = LDPUMA_CreateWindow(NULL, NULL);
 
218
 
 
219
        LDPUMA_Registry(&hMainDebug, SNAP_ROOT_MAIN_DEBUG, NULL);
 
220
 
 
221
        LDPUMA_Registry(&RLINE_Root, SNAP_ROOT_LINES, NULL); // регистрация вершины отладки
226
222
 
227
223
        LDPUMA_Registry(&hRLINE_Pass1, SNAP_PASS1_LINES, RLINE_Root);
228
224
        LDPUMA_Registry(&hRLINE_Pass2, SNAP_PASS2_LINES, RLINE_Root);
229
 
        LDPUMA_RegistryHelp(hRLINE_Pass2, "��� ��������� - ���������� II ������", FALSE);
230
 
                LDPUMA_RegVariable(hRLINE_Pass2, "���������� (%) ��� �����. �����", &hRLINE_Pass2Lost1, "long");
231
 
                LDPUMA_RegVariable(hRLINE_Pass2, "���������� (%) ��� �����. �����", &hRLINE_Pass2Lost2, "long");
 
225
        LDPUMA_RegistryHelp(hRLINE_Pass2, "При выделении - пропустить II проход",
 
226
                        FALSE);
 
227
        LDPUMA_RegVariable(hRLINE_Pass2, "Почернение (%) при подтв. линии",
 
228
                        &hRLINE_Pass2Lost1, "long");
 
229
        LDPUMA_RegVariable(hRLINE_Pass2, "Почернение (%) без подтв. линии",
 
230
                        &hRLINE_Pass2Lost2, "long");
232
231
        LDPUMA_Registry(&hRLINE_Pass3, SNAP_PASS3_LINES, RLINE_Root);
233
232
 
234
 
        LDPUMA_Registry(&RLINE_Search,"����� LNS", hRLINE_Pass1); // ����������� ������� �������
 
233
        LDPUMA_Registry(&RLINE_Search, "Линии LNS", hRLINE_Pass1); // регистрация вершины отладки
235
234
        LDPUMA_RegistryHelp(RLINE_Search,
236
 
                "��������� ����� ����� ��������� LNS32.DLL.", FALSE);
237
 
        LDPUMA_Registry(&hRLINE_Correct, "��������� ����� LNS", hRLINE_Pass1);
238
 
        LDPUMA_RegistryHelp(hRLINE_Correct,
239
 
                "��������� �����, ��������� LNS.", FALSE);
240
 
 
241
 
        LDPUMA_Registry(&hRLINE_CorrectOutput,"��������� ��������� �����", hRLINE_Correct);
242
 
                LDPUMA_Registry(&hRLINE_CorrectDrawLines,"�������� ����������������� ����� (I)", hRLINE_CorrectOutput);
243
 
                LDPUMA_Registry(&hRLINE_CorrectDrawFrags,"�������� ��������� ����� (I)", hRLINE_CorrectOutput);
244
 
        LDPUMA_Registry(&hRLINE_CorrectDebug,"������� ��������� �����", hRLINE_Correct);
245
 
                LDPUMA_Registry(&hRLINE_CorrectDebugFrag, "������������ ������������ �� LNS", hRLINE_CorrectDebug);
246
 
                LDPUMA_RegistryHelp(hRLINE_CorrectDebugFrag, "�.�. �� ��������������������� ����� ��� ���������", FALSE);
247
 
        LDPUMA_Registry(&hRLINE_CorrectControl,"�������� ��������� �����", hRLINE_Correct);
248
 
        LDPUMA_Registry(&Part2,"������������ ��������� �����", hRLINE_Correct);
249
 
 
250
 
        LDPUMA_Registry(&hRLINE_Pass3Input,"������� ������ III �������", hRLINE_Pass3);
251
 
        LDPUMA_Registry(&hRLINE_Pass3Output,"��������� III �������", hRLINE_Pass3);
252
 
                LDPUMA_Registry(&hRLINE_Pass3DrawLines,"�������� ����� (III)", hRLINE_Pass3Output);
253
 
                LDPUMA_Registry(&hRLINE_Pass3DrawFrags,"�������� ��������� ����� (III)", hRLINE_Pass3Output);
254
 
        LDPUMA_Registry(&hRLINE_Pass3_Control,"�������� �������� �������",hRLINE_Pass3);
255
 
        LDPUMA_Registry(&Part3,"������������ �������� �������",hRLINE_Pass3);
256
 
 
257
 
        LDPUMA_Registry(&hRLINE_Search_Output, "��������� LNS", RLINE_Search);
258
 
        LDPUMA_Registry(&hRLINE_Search_Debug, "������� LNS", RLINE_Search);
259
 
 
260
 
        //LDPUMA_Registry(&RLINE_NoFillgap,"�� ��������� '������������' �����", RLINE_Root); // ����������� ������� �������
261
 
        LDPUMA_Registry(&RLINE_NoFillgap,"��������� '������������' �����", hRLINE_Search_Debug); // ����������� ������� �������
262
 
        LDPUMA_RegistryHelp(RLINE_NoFillgap,
263
 
                "��� '�������������' ���������� ��������� ������� ����� �� 3 �������. ���� ����� ������������ \
264
 
��� ������ � ������������ �� ���������� ��������.", FALSE);
265
 
        //LDPUMA_Registry(&RLINE_NoHorBorder,"�� �������� �������������� ����", RLINE_Root); // ����������� ������� �������
266
 
        LDPUMA_Registry(&RLINE_NoHorBorder,"�������� �������������� ����", hRLINE_Search_Debug); // ����������� ������� �������
 
235
                        "Выполнить поиск линий используя LNS32.DLL.", FALSE);
 
236
        LDPUMA_Registry(&hRLINE_Correct, "Коррекция линий LNS", hRLINE_Pass1);
 
237
        LDPUMA_RegistryHelp(hRLINE_Correct, "Коррекция линий, найденных LNS.",
 
238
                        FALSE);
 
239
 
 
240
        LDPUMA_Registry(&hRLINE_CorrectOutput, "Результат коррекции линий",
 
241
                        hRLINE_Correct);
 
242
        LDPUMA_Registry(&hRLINE_CorrectDrawLines,
 
243
                        "Рисовать скорректированные линии (I)", hRLINE_CorrectOutput);
 
244
        LDPUMA_Registry(&hRLINE_CorrectDrawFrags, "Рисовать фрагменты линий (I)",
 
245
                        hRLINE_CorrectOutput);
 
246
        LDPUMA_Registry(&hRLINE_CorrectDebug, "Отладка коррекции линий",
 
247
                        hRLINE_Correct);
 
248
        LDPUMA_Registry(&hRLINE_CorrectDebugFrag,
 
249
                        "Использовать фрагментацию от LNS", hRLINE_CorrectDebug);
 
250
        LDPUMA_RegistryHelp(hRLINE_CorrectDebugFrag,
 
251
                        "т.е. не перефрагментировывать линию при коррекции", FALSE);
 
252
        LDPUMA_Registry(&hRLINE_CorrectControl, "Контроль коррекции линий",
 
253
                        hRLINE_Correct);
 
254
        LDPUMA_Registry(&Part2, "Этапирование коррекции линий", hRLINE_Correct);
 
255
 
 
256
        LDPUMA_Registry(&hRLINE_Pass3Input, "Входные данные III прохода",
 
257
                        hRLINE_Pass3);
 
258
        LDPUMA_Registry(&hRLINE_Pass3Output, "Результат III прохода", hRLINE_Pass3);
 
259
        LDPUMA_Registry(&hRLINE_Pass3DrawLines, "Рисовать линии (III)",
 
260
                        hRLINE_Pass3Output);
 
261
        LDPUMA_Registry(&hRLINE_Pass3DrawFrags, "Рисовать фрагменты линий (III)",
 
262
                        hRLINE_Pass3Output);
 
263
        LDPUMA_Registry(&hRLINE_Pass3_Control, "Контроль третьего прохода",
 
264
                        hRLINE_Pass3);
 
265
        LDPUMA_Registry(&Part3, "Этапирование третьего прохода", hRLINE_Pass3);
 
266
 
 
267
        LDPUMA_Registry(&hRLINE_Search_Output, "Результат LNS", RLINE_Search);
 
268
        LDPUMA_Registry(&hRLINE_Search_Debug, "Отладка LNS", RLINE_Search);
 
269
 
 
270
        //LDPUMA_Registry(&RLINE_NoFillgap,"Не выполнять 'размазывание' линий", RLINE_Root); // регистрация вершины отладки
 
271
        LDPUMA_Registry(&RLINE_NoFillgap, "Выполнить 'размазывание' линий",
 
272
                        hRLINE_Search_Debug); // регистрация вершины отладки
 
273
        LDPUMA_RegistryHelp(
 
274
                        RLINE_NoFillgap,
 
275
                        "Под 'размазыванием' понимается удлинение базовых линий на 3 пиксела. Этот режим используется \
 
276
при работе с изображением от матричного принтера.",
 
277
                        FALSE);
 
278
        //LDPUMA_Registry(&RLINE_NoHorBorder,"Не выделять горизонтальные поля", RLINE_Root); // регистрация вершины отладки
 
279
        LDPUMA_Registry(&RLINE_NoHorBorder, "Выделять горизонтальные поля",
 
280
                        hRLINE_Search_Debug); // регистрация вершины отладки
267
281
        LDPUMA_RegistryHelp(RLINE_NoHorBorder,
268
 
                "����������� ������ ��������� ��������� �������� �����������", FALSE); // ����������� ������� �������
269
 
        //LDPUMA_Registry(&RLINE_NoVerBorder,"�� �������� ������������ ����", RLINE_Root); // ����������� ������� �������
270
 
        LDPUMA_Registry(&RLINE_NoVerBorder,"�������� ������������ ����", hRLINE_Search_Debug); // ����������� ������� �������
 
282
                        "Специальный случай обработки граничных участков изображения",
 
283
                        FALSE); // регистрация вершины отладки
 
284
        //LDPUMA_Registry(&RLINE_NoVerBorder,"Не выделять вертикальные поля", RLINE_Root); // регистрация вершины отладки
 
285
        LDPUMA_Registry(&RLINE_NoVerBorder, "Выделять вертикальные поля",
 
286
                        hRLINE_Search_Debug); // регистрация вершины отладки
271
287
        LDPUMA_RegistryHelp(RLINE_NoVerBorder,
272
 
                "����������� ������ ��������� ��������� �������� �����������", FALSE); // ����������� ������� �������
273
 
 
274
 
        LDPUMA_Registry(&RLINE_ShowLines,"���������� ����� ����� ���������", hRLINE_Search_Output); // ����������� ������� �������
275
 
        LDPUMA_RegistryHelp(RLINE_ShowLines,
276
 
                "���������� ����� ����� ���������", FALSE); // ����������� ������� �������
277
 
        LDPUMA_Registry(&hRLINE_Search_Output_ShowFrags,"���������� ��������� ����� LNS", hRLINE_Search_Output); // ����������� ������� �������
278
 
        LDPUMA_RegistryHelp(hRLINE_Search_Output_ShowFrags,
279
 
                "���������� ��������� ����� ����� ��������� (��������, ���� ��� ��������� ����� �� ������ ������� ������������ ������������ LNS)", FALSE); // ����������� ������� �������
280
 
 
281
 
        LDPUMA_Registry(&hWriteLineInFile, "������ ����� ����� ���������", hRLINE_CorrectControl);
282
 
    LDPUMA_RegistryHelp(hWriteLineInFile, "�������� ���������� ������� ������� � ���� lines.res", FALSE);
283
 
 
284
 
    LDPUMA_Registry(&hWriteLineInFile3, "������ ����������� ������ �������� ������� �� ������", hRLINE_Pass3_Control);
285
 
    LDPUMA_RegistryHelp(hWriteLineInFile3, "�������� ���������� �������� ������� � ���� lines3.res", FALSE);
286
 
 
287
 
        /*      //������� ���������� � RStuff
288
 
        LDPUMA_Registry(&RLINE_ShowWithoutLines,"�������� ����������� ����� ������ �����", RLINE_Root); // ����������� ������� �������
289
 
        LDPUMA_RegistryHelp(RLINE_ShowWithoutLines,
290
 
                "�������� ����������� ����� ������ �����", FALSE); // ����������� ������� �������
291
 
*/
292
 
//    LDPUMA_Registry (&hUseCLine,"������ � ����������� �����",NULL);
293
 
/*
294
 
        LDPUMA_Registry(&Parts,"������������ ������� � �������� �������",RLINE_Root);
295
 
        LDPUMA_RegistryHelp(Parts,"������������ ������� � �������� ������� �� ������",FALSE);
296
 
*/
297
 
//      LDPUMA_Registry(&Part2,"������ ������",Parts);
298
 
        LDPUMA_Registry(&Prep2,"���������������� ����� (2)",Part2);
299
 
        LDPUMA_Registry(&MainWork2,"�������������� ����� (2)",Part2);
300
 
        LDPUMA_Registry(&PutContainer2,"������� � ��������� (2)",Part2);
301
 
    LDPUMA_Registry(&Epilog2,"������ (2)",Part2);
302
 
        LDPUMA_Registry(&Exit2,"����� �� ������� (2)",Part2);
303
 
 
304
 
//      LDPUMA_Registry(&Part3,"������ ������",Parts);
305
 
        LDPUMA_Registry(&GetContainer3,"������ �� ���������� (3)",Part3);
306
 
        LDPUMA_Registry(&MainWork3,"�������������� ����� (3)",Part3);
307
 
        LDPUMA_Registry(&PutContainer3,"������� � ��������� (3)",Part3);
308
 
        LDPUMA_Registry(&Exit3,"����� �� ������� (3)",Part3);
 
288
                        "Специальный случай обработки граничных участков изображения",
 
289
                        FALSE); // регистрация вершины отладки
 
290
 
 
291
        LDPUMA_Registry(&RLINE_ShowLines, "Показывать линии после выделения",
 
292
                        hRLINE_Search_Output); // регистрация вершины отладки
 
293
        LDPUMA_RegistryHelp(RLINE_ShowLines, "Показывать линии после выделения",
 
294
                        FALSE); // регистрация вершины отладки
 
295
        LDPUMA_Registry(&hRLINE_Search_Output_ShowFrags,
 
296
                        "Показывать фрагменты линий LNS", hRLINE_Search_Output); // регистрация вершины отладки
 
297
        LDPUMA_RegistryHelp(
 
298
                        hRLINE_Search_Output_ShowFrags,
 
299
                        "Показывать фрагменты линий после выделения (работает, если при коррекции линий на первом проходе используется фрагментация LNS)",
 
300
                        FALSE); // регистрация вершины отладки
 
301
 
 
302
        LDPUMA_Registry(&hWriteLineInFile, "Отпись линий после коррекции",
 
303
                        hRLINE_CorrectControl);
 
304
        LDPUMA_RegistryHelp(hWriteLineInFile,
 
305
                        "Записать результаты первого прохода в файл lines.res", FALSE);
 
306
 
 
307
        LDPUMA_Registry(&hWriteLineInFile3,
 
308
                        "Отпись результатов работы третьего прохода по линиям",
 
309
                        hRLINE_Pass3_Control);
 
310
        LDPUMA_RegistryHelp(hWriteLineInFile3,
 
311
                        "Записать результаты третьего прохода в файл lines3.res", FALSE);
 
312
 
 
313
        /*      //вершина перенесена в RStuff
 
314
         LDPUMA_Registry(&RLINE_ShowWithoutLines,"Показать изображение после снятия линий", RLINE_Root); // регистрация вершины отладки
 
315
         LDPUMA_RegistryHelp(RLINE_ShowWithoutLines,
 
316
         "Показать изображение после снятия линий", FALSE); // регистрация вершины отладки
 
317
         */
 
318
        //    LDPUMA_Registry (&hUseCLine,"Работа с контейнером линий",NULL);
 
319
        /*
 
320
         LDPUMA_Registry(&Parts,"Этапирование второго и третьего прохода",RLINE_Root);
 
321
         LDPUMA_RegistryHelp(Parts,"Этапирование второго и третьего прохода по линиям",FALSE);
 
322
         */
 
323
        //      LDPUMA_Registry(&Part2,"Второй проход",Parts);
 
324
        LDPUMA_Registry(&Prep2, "Подготовительная часть (2)", Part2);
 
325
        LDPUMA_Registry(&MainWork2, "Содержательная часть (2)", Part2);
 
326
        LDPUMA_Registry(&PutContainer2, "Складка в контейнер (2)", Part2);
 
327
        LDPUMA_Registry(&Epilog2, "Эпилог (2)", Part2);
 
328
        LDPUMA_Registry(&Exit2, "Выход из функции (2)", Part2);
 
329
 
 
330
        //      LDPUMA_Registry(&Part3,"Третий проход",Parts);
 
331
        LDPUMA_Registry(&GetContainer3, "Взятие из контейнера (3)", Part3);
 
332
        LDPUMA_Registry(&MainWork3, "Содержательная часть (3)", Part3);
 
333
        LDPUMA_Registry(&PutContainer3, "Складка в контейнер (3)", Part3);
 
334
        LDPUMA_Registry(&Exit3, "Выход из функции (3)", Part3);
309
335
 
310
336
        //Almi 16.05.01
311
 
    LDPUMA_RegVariable(hRLINE_Correct,"������������ ������ ��������",&MinHorLenForTrue,"unsigned");
312
 
    LDPUMA_RegVariable(hRLINE_Correct,"������������ ������ ��������",&MinVerLenForTrue,"unsigned");
313
 
 
314
 
        LDPUMA_Registry(&hDotKilledD,"���������� �������� �������� �����", hRLINE_CorrectControl);
315
 
        LDPUMA_RegistryHelp(hDotKilledD,"���������� �������� �������� �����", FALSE);
316
 
 
317
 
        LDPUMA_Registry(&hSkipDelSmallLines, "�� ������� ��������� ������� �����", hRLINE_CorrectDebug);
318
 
        LDPUMA_RegistryHelp(hSkipDelSmallLines, "��������� � ���������� �������� (������ ������ 30) ���������� �� ����� �������", FALSE);
319
 
 
320
 
        LDPUMA_Registry(&hRLINE_Pass2Output,"��������� II �������", hRLINE_Pass2);
321
 
                LDPUMA_Registry(&hRLINE_Pass2DrawLines,"�������� ����� (II)", hRLINE_Pass2Output);
322
 
                LDPUMA_Registry(&hRLINE_Pass2DrawFrags,"�������� ��������� ����� (II)", hRLINE_Pass2Output);
323
 
        LDPUMA_Registry(&hLinesPass2, "�������� II ������� �� ������", hRLINE_Pass2);
324
 
        LDPUMA_RegistryHelp(hLinesPass2, "��� ��������� - ���������� II ������", FALSE);
325
 
        LDPUMA_Registry(&hLinesPass2Debug, "������� II ������� �� ������", hRLINE_Pass2);
326
 
                LDPUMA_Registry(&hLinesPass2DebugSkipDouble, "���������� ��������� �������", hLinesPass2Debug);
327
 
                LDPUMA_Registry(&hLinesPass2DebugSkipGlue, "���������� ������� �����", hLinesPass2Debug);
328
 
                LDPUMA_Registry(&hLinesPass2DebugSkipFindLost, "���������� �������������� ����������", hLinesPass2Debug);
329
 
 
330
 
            LDPUMA_Registry(&hWriteLineInFile2, "������ ����������� ������ ������� ������� �� ������", hLinesPass2);
331
 
                LDPUMA_RegistryHelp(hWriteLineInFile2, "�������� ���������� ������� ������� � ���� lines2.res", FALSE);
332
 
 
333
 
        LDPUMA_RegVariable(hRLINE_Pass2, "����������� �������� ����� �������", &hMinInterval, "unsigned");
334
 
        LDPUMA_RegVariable(hRLINE_Pass2, "������ �������� ����� �������", &h1Interval, "unsigned");
335
 
        LDPUMA_RegVariable(hRLINE_Pass2, "������ �������� ����� �������", &h2Interval, "unsigned");
336
 
        LDPUMA_RegVariable(hRLINE_Pass2, "������������ �������� ����� �������", &hMaxInterval, "unsigned");
337
 
        LDPUMA_RegVariable(hRLINE_Pass2, "����� ��������� �����", &hSmallLineLen, "unsigned");
338
 
        LDPUMA_RegVariable(hRLINE_Pass2, "����� ������� �����", &hLongLineLen, "unsigned");
339
 
        LDPUMA_RegVariable(hRLINE_Pass2, "������������ �������� ���� ������� (� ����� ����� �������)", &hMaxDegreeDiff, "unsigned");
340
 
        LDPUMA_RegVariable(hRLINE_Pass2, "������������ ������� ����� (� ��������)", &hMaxShift, "unsigned");
341
 
        LDPUMA_RegVariable(hRLINE_Pass2, "���������� ������", &hRastDelta, "unsigned");
342
 
 
343
 
        LDPUMA_Registry(&hPrint1Cr, "������ �������� 1 ��������", hLinesPass2);
344
 
        LDPUMA_RegistryHelp(hPrint1Cr, "������ � ������� ����������� �������� 1 �������� (� ������ ������)", FALSE);
345
 
        LDPUMA_Registry(&hPrint2Cr, "������ �������� 2 ��������", hLinesPass2);
346
 
        LDPUMA_RegistryHelp(hPrint2Cr, "������ � ������� ����������� �������� 2 �������� (� ������ ������)", FALSE);
347
 
        LDPUMA_Registry(&hPrint3Cr, "������ �������� 3 ��������", hLinesPass2);
348
 
        LDPUMA_RegistryHelp(hPrint3Cr, "������ � ������� ����������� �������� 3 �������� (� ������ ������)", FALSE);
349
 
        LDPUMA_Registry(&hPrint4Cr, "������ �������� 4 ��������", hLinesPass2);
350
 
        LDPUMA_RegistryHelp(hPrint4Cr, "������ � ������� ����������� �������� 4 �������� (� ������ ������)", FALSE);
351
 
        LDPUMA_Registry(&hDrawCrRast, "�������� ����� ����� �������", hLinesPass2);
352
 
        LDPUMA_RegistryHelp(hDrawCrRast, "�������� ����� ����� ������� ��� �������� ����������", FALSE);
353
 
        LDPUMA_Registry(&hShowCPLines, "�������� ����� ����� ���������������", hLinesPass2);
354
 
        LDPUMA_RegistryHelp(hShowCPLines, "�������� ����� ����� ��������������� �� ������ � �������� ����", FALSE);
355
 
        LDPUMA_Registry(&hShowCP, "�������� ����� �����������", hLinesPass2);
356
 
        LDPUMA_RegistryHelp(hShowCP, "�������� ����� ����������� ����� � �������� ����", FALSE);
357
 
        LDPUMA_Registry(&hShowCheckedRects, "�������� ����������� ���������", hLinesPass2);
358
 
        LDPUMA_RegistryHelp(hShowCheckedRects, "�������� ����������� �������������� ����������-���������� �� �������������� � �������� ����", FALSE);
359
 
        LDPUMA_Registry(&hPrintCheckedRects, "������ �������� ����������", hLinesPass2);
360
 
        LDPUMA_RegistryHelp(hPrintCheckedRects, "�������� � ������� ���������� �������� ���������� ��������������� ����������-���������� �� ��������������", FALSE);
361
 
 
362
 
        LDPUMA_Registry(&hDebugDrowTableZone,"�������� ���� ������ ����� II �������",hRLINE_Pass3Input);
363
 
        LDPUMA_Registry(&hDebugDrowFriendLines,"�������� �����, �������� � ���� ������",hRLINE_Pass3_Control);
364
 
        LDPUMA_Registry(&hDebugDrowGroupOfExtensibleLines,"�������� ������ �����(������� ����� ������� ����� �����) � �������� ����",hRLINE_Pass3_Control);
365
 
        LDPUMA_Registry(&hDebugDrawLosedVerticalLines,"�������� ������ ������������ �����(������� � ������ ������ LNS-�� ����� ���������������) � �������� ����",hRLINE_Pass3_Control);
366
 
        LDPUMA_Registry(&hDebugPrintCrossCheck,"������ �������� ����� ����������� ���. �����", hRLINE_Pass3_Control);
367
 
 
368
 
        LDPUMA_Registry(&hDebugShortLinesPrint, "����� ����������� �������� �������� ����� �� �������", hRLINE_CorrectControl);
369
 
//      LDPUMA_Registry(&hDebugShortLinesDrawRect, "�������� �������������� �������� �����", hRLINE_CorrectControl);
370
 
//  LDPUMA_RegistryHelp(hDebugShortLinesDrawRect, "�������� �������������� ������� ����� ��� ���������� �� ���������", FALSE);
 
337
        LDPUMA_RegVariable(hRLINE_Correct, "Подтверждать ГорЛин НеКороче",
 
338
                        &MinHorLenForTrue, "unsigned");
 
339
        LDPUMA_RegVariable(hRLINE_Correct, "Подтверждать ВерЛин НеКороче",
 
340
                        &MinVerLenForTrue, "unsigned");
 
341
 
 
342
        LDPUMA_Registry(&hDotKilledD, "Прорисовка удалённых точечных линий",
 
343
                        hRLINE_CorrectControl);
 
344
        LDPUMA_RegistryHelp(hDotKilledD, "Прорисовка удалённых точечных линий",
 
345
                        FALSE);
 
346
 
 
347
        LDPUMA_Registry(&hSkipDelSmallLines, "НЕ удалять маленькие остатки линий",
 
348
                        hRLINE_CorrectDebug);
 
349
        LDPUMA_RegistryHelp(
 
350
                        hSkipDelSmallLines,
 
351
                        "Оставлять в контейнере короткие (длиной меньше 30) отделенные от линий остатки",
 
352
                        FALSE);
 
353
 
 
354
        LDPUMA_Registry(&hRLINE_Pass2Output, "Результат II прохода", hRLINE_Pass2);
 
355
        LDPUMA_Registry(&hRLINE_Pass2DrawLines, "Рисовать линии (II)",
 
356
                        hRLINE_Pass2Output);
 
357
        LDPUMA_Registry(&hRLINE_Pass2DrawFrags, "Рисовать фрагменты линий (II)",
 
358
                        hRLINE_Pass2Output);
 
359
        LDPUMA_Registry(&hLinesPass2, "Контроль II прохода по линиям", hRLINE_Pass2);
 
360
        LDPUMA_RegistryHelp(hLinesPass2, "При выделении - пропустить II проход",
 
361
                        FALSE);
 
362
        LDPUMA_Registry(&hLinesPass2Debug, "Отладка II прохода по линиям",
 
363
                        hRLINE_Pass2);
 
364
        LDPUMA_Registry(&hLinesPass2DebugSkipDouble,
 
365
                        "Пропустить коррекцию двойных", hLinesPass2Debug);
 
366
        LDPUMA_Registry(&hLinesPass2DebugSkipGlue, "Пропустить склейку линий",
 
367
                        hLinesPass2Debug);
 
368
        LDPUMA_Registry(&hLinesPass2DebugSkipFindLost,
 
369
                        "Пропустить восстановление потерянных", hLinesPass2Debug);
 
370
 
 
371
        LDPUMA_Registry(&hWriteLineInFile2,
 
372
                        "Отпись результатов работы второго прохода по линиям", hLinesPass2);
 
373
        LDPUMA_RegistryHelp(hWriteLineInFile2,
 
374
                        "Записать результаты второго прохода в файл lines2.res", FALSE);
 
375
 
 
376
        LDPUMA_RegVariable(hRLINE_Pass2, "Минимальный интервал между линиями",
 
377
                        &hMinInterval, "unsigned");
 
378
        LDPUMA_RegVariable(hRLINE_Pass2, "Первый интервал между линиями",
 
379
                        &h1Interval, "unsigned");
 
380
        LDPUMA_RegVariable(hRLINE_Pass2, "Второй интервал между линиями",
 
381
                        &h2Interval, "unsigned");
 
382
        LDPUMA_RegVariable(hRLINE_Pass2, "Максимальный интервал между линиями",
 
383
                        &hMaxInterval, "unsigned");
 
384
        LDPUMA_RegVariable(hRLINE_Pass2, "Длина маленькой линии", &hSmallLineLen,
 
385
                        "unsigned");
 
386
        LDPUMA_RegVariable(hRLINE_Pass2, "Длина большой линии", &hLongLineLen,
 
387
                        "unsigned");
 
388
        LDPUMA_RegVariable(hRLINE_Pass2,
 
389
                        "Максимальное различие угла наклона (в сотых долях радиана)",
 
390
                        &hMaxDegreeDiff, "unsigned");
 
391
        LDPUMA_RegVariable(hRLINE_Pass2, "Максимальный боковой сдвиг (в квадрате)",
 
392
                        &hMaxShift, "unsigned");
 
393
        LDPUMA_RegVariable(hRLINE_Pass2, "Размывание растра", &hRastDelta,
 
394
                        "unsigned");
 
395
 
 
396
        LDPUMA_Registry(&hPrint1Cr, "Печать проверки 1 критерия", hLinesPass2);
 
397
        LDPUMA_RegistryHelp(
 
398
                        hPrint1Cr,
 
399
                        "Печать в консоль результатов проверки 1 критерия (в случае успеха)",
 
400
                        FALSE);
 
401
        LDPUMA_Registry(&hPrint2Cr, "Печать проверки 2 критерия", hLinesPass2);
 
402
        LDPUMA_RegistryHelp(
 
403
                        hPrint2Cr,
 
404
                        "Печать в консоль результатов проверки 2 критерия (в случае успеха)",
 
405
                        FALSE);
 
406
        LDPUMA_Registry(&hPrint3Cr, "Печать проверки 3 критерия", hLinesPass2);
 
407
        LDPUMA_RegistryHelp(
 
408
                        hPrint3Cr,
 
409
                        "Печать в консоль результатов проверки 3 критерия (в случае успеха)",
 
410
                        FALSE);
 
411
        LDPUMA_Registry(&hPrint4Cr, "Печать проверки 4 критерия", hLinesPass2);
 
412
        LDPUMA_RegistryHelp(
 
413
                        hPrint4Cr,
 
414
                        "Печать в консоль результатов проверки 4 критерия (в случае успеха)",
 
415
                        FALSE);
 
416
        LDPUMA_Registry(&hDrawCrRast, "Рисовать растр между линиями", hLinesPass2);
 
417
        LDPUMA_RegistryHelp(hDrawCrRast,
 
418
                        "Рисовать растр между линиями при проверке почернения", FALSE);
 
419
        LDPUMA_Registry(&hShowCPLines, "Показать линии перед восстановлением",
 
420
                        hLinesPass2);
 
421
        LDPUMA_RegistryHelp(hShowCPLines,
 
422
                        "Показать линии перед восстановлением по штырям в основном окне",
 
423
                        FALSE);
 
424
        LDPUMA_Registry(&hShowCP, "Показать точки пересечения", hLinesPass2);
 
425
        LDPUMA_RegistryHelp(hShowCP,
 
426
                        "Показать точки пересечения линий в основном окне", FALSE);
 
427
        LDPUMA_Registry(&hShowCheckedRects, "Показать проверяемые интервалы",
 
428
                        hLinesPass2);
 
429
        LDPUMA_RegistryHelp(
 
430
                        hShowCheckedRects,
 
431
                        "Показать проверяемые прямоугольники интервалов-кандидатов на восстановление в основном окне",
 
432
                        FALSE);
 
433
        LDPUMA_Registry(&hPrintCheckedRects, "Печать проверки интервалов",
 
434
                        hLinesPass2);
 
435
        LDPUMA_RegistryHelp(
 
436
                        hPrintCheckedRects,
 
437
                        "Печатать в консоль результаты проверки почернения прямоугольников интервалов-кандидатов на восстановление",
 
438
                        FALSE);
 
439
 
 
440
        LDPUMA_Registry(&hDebugDrowTableZone,
 
441
                        "Рисуются зоны таблиц после II прохода", hRLINE_Pass3Input);
 
442
        LDPUMA_Registry(&hDebugDrowFriendLines,
 
443
                        "Рисуются линии, попавшие в зоны таблиц", hRLINE_Pass3_Control);
 
444
        LDPUMA_Registry(
 
445
                        &hDebugDrowGroupOfExtensibleLines,
 
446
                        "Рисуются группы линий(которые могут создать новую линию) в основном окне",
 
447
                        hRLINE_Pass3_Control);
 
448
        LDPUMA_Registry(
 
449
                        &hDebugDrawLosedVerticalLines,
 
450
                        "Рисуются группы вертикальных линий(которые в случае потери LNS-ом будем восстанавливать) в основном окне",
 
451
                        hRLINE_Pass3_Control);
 
452
        LDPUMA_Registry(&hDebugPrintCrossCheck,
 
453
                        "Печать проверки точек пересечения кор. линий",
 
454
                        hRLINE_Pass3_Control);
 
455
 
 
456
        LDPUMA_Registry(&hDebugShortLinesPrint,
 
457
                        "Вывод результатов проверки коротких линий на консоль",
 
458
                        hRLINE_CorrectControl);
 
459
        //      LDPUMA_Registry(&hDebugShortLinesDrawRect, "Рисовать прямоугольники коротких линий", hRLINE_CorrectControl);
 
460
        //  LDPUMA_RegistryHelp(hDebugShortLinesDrawRect, "Рисовать прямоугольники растров линий или содержащих их компонент", FALSE);
371
461
 
372
462
#ifdef _DEBUG
373
 
/*    ofstream outfile("lines.res", ios::out|ios::binary);
374
 
    if (outfile) outfile.close();
375
 
*/
 
463
        /*    ofstream outfile("lines.res", ios::out|ios::binary);
 
464
         if (outfile) outfile.close();
 
465
         */
376
466
        int err_no;
377
467
        if (remove("lines.res") == -1) err_no = errno;
378
468
        if (remove("lines.txt") == -1) err_no = errno;
385
475
 
386
476
//////////////////////////////////////////////////////////////////////////////////
387
477
 
388
 
Bool32 RLINE_SearchLines( void* lpInPage,void* phCLINE)
389
 
{
390
 
 
391
 
        CLINE_handle* PHCLINE=(CLINE_handle*)phCLINE;
392
 
    CLINE_DeleteContainer(*PHCLINE);
393
 
        LinesTotalInfo          lti;             // ��������� �������� �����
394
 
        PAGEINFO                PInfo;           // �������� ��������
395
 
        char*                       pImage;          // ��������� �� �����������
396
 
        LnsSetupStr                             ls;
397
 
 
398
 
        Int32  result_h_count,
399
 
                   result_v_count;
400
 
 
401
 
        // �������� PAGEINFO ������� ��������
402
 
        if (!CPAGE_GetPageData( lpInPage,PT_PAGEINFO,(void*)&PInfo,sizeof(PInfo)))
403
 
        {
404
 
                LDPUMA_Console( " Error in GetPageData " );
 
478
Bool32 RLINE_SearchLines(void* lpInPage, void* phCLINE) {
 
479
 
 
480
        CLINE_handle* PHCLINE = (CLINE_handle*) phCLINE;
 
481
        CLINE_DeleteContainer(*PHCLINE);
 
482
        LinesTotalInfo lti; // Структура хранения линий
 
483
        PAGEINFO PInfo; // Описание страницы
 
484
        char* pImage; // Указатель на изображение
 
485
        LnsSetupStr ls;
 
486
 
 
487
        int32_t result_h_count, result_v_count;
 
488
 
 
489
        // Получаем PAGEINFO текущей страницы
 
490
        if (!CPAGE_GetPageData(lpInPage, PT_PAGEINFO, (void*) &PInfo, sizeof(PInfo))) {
 
491
                LDPUMA_Console(" Error in GetPageData ");
405
492
                rc32 = CPAGE_GetReturnCode();
406
 
                SetReturnCode_rline( rc32 );
 
493
                SetReturnCode_rline(rc32);
407
494
                return FALSE;
408
495
        }
409
496
 
410
 
        // �������� � pImage �� PInfo ��������� �� �����������, ��������� �� ���������
411
 
        pImage = (char*)&PInfo.szImageName;
412
 
 
413
 
        min_h_len = (Word16)(PInfo.DPIX*40/300);
414
 
        min_v_len = (Word16)(PInfo.DPIY*40/300);
415
 
 
416
 
        if (!CIMAGE_GetCallbackImage( (PWord8)pImage, &cbk))
417
 
        {
418
 
                LDPUMA_Console( " Error in GetCallbackImage " );
 
497
        // Копируем в pImage из PInfo указатель на изображение, связанное со страницей
 
498
        pImage = (char*) &PInfo.szImageName;
 
499
 
 
500
        min_h_len = (uint16_t) (PInfo.DPIX * 40 / 300);
 
501
        min_v_len = (uint16_t) (PInfo.DPIY * 40 / 300);
 
502
 
 
503
        if (!CIMAGE_GetCallbackImage((puchar) pImage, &cbk)) {
 
504
                LDPUMA_Console(" Error in GetCallbackImage ");
419
505
                rc32 = CIMAGE_GetReturnCode();
420
 
                SetReturnCode_rline( rc32 );
 
506
                SetReturnCode_rline(rc32);
421
507
                return FALSE;
422
508
        }
423
509
 
424
 
        imxs.f_op = DibOpen;                                                            // �� �� ����� �� �� ������ �������� ������
425
 
        imxs.f_re = DibRead;                                                            // � ���� �� ���� � CIMAGE � LNS32 ���������
426
 
        imxs.f_cl = DibClose;                                                           // imxs->... cbk->... ����� �������������� �����.
427
 
 
428
 
 
429
 
        // �������������� ��������
 
510
        imxs.f_op = DibOpen; // Мы не можем из за разных названий одного
 
511
        imxs.f_re = DibRead; // и того же типа в CIMAGE и LNS32 присвоить
 
512
        imxs.f_cl = DibClose; // imxs->... cbk->... нужно преобразование типов.
 
513
 
 
514
 
 
515
        // Подготавливаем страницу
430
516
        LnsPageStart(&imxs);
431
517
 
432
 
        // ��������� ���������� ������ LNS32.dll
 
518
        // Установка параметров работы LNS32.dll
433
519
        ls.nOptions = 0;
434
 
        LnsSetup ( &ls );
 
520
        LnsSetup(&ls);
435
521
 
436
 
        if ( !LDPUMA_Skip(RLINE_NoFillgap) )
437
 
        {
 
522
        if (!LDPUMA_Skip(RLINE_NoFillgap)) {
438
523
                gbNOFILLGAP3 = TRUE;
439
 
        }
440
 
        else
441
 
        {
 
524
        } else {
442
525
                gbNOFILLGAP3 = FALSE;
443
526
        }
444
527
        ls.nOptions |= gbNOFILLGAP3 ? 0 : LSS_NOFILLGAP3_FILTER;
445
528
 
446
 
        if ( !LDPUMA_Skip(RLINE_NoHorBorder) )
447
 
        {
 
529
        if (!LDPUMA_Skip(RLINE_NoHorBorder)) {
448
530
                gbNOHBORDER = TRUE;
449
 
        }
450
 
        else
451
 
        {
 
531
        } else {
452
532
                gbNOHBORDER = FALSE;
453
533
        }
454
534
        ls.nOptions |= gbNOHBORDER ? 0 : LSS_NOHBORDER_FILTER;
455
535
 
456
 
        if ( !LDPUMA_Skip(RLINE_NoVerBorder) )
457
 
        {
 
536
        if (!LDPUMA_Skip(RLINE_NoVerBorder)) {
458
537
                gbNOVBORDER = TRUE;
459
 
        }
460
 
        else
461
 
        {
 
538
        } else {
462
539
                gbNOVBORDER = FALSE;
463
540
        }
464
541
        ls.nOptions |= gbNOVBORDER ? 0 : LSS_NOVBORDER_FILTER;
465
542
 
466
 
        LnsSetup ( &ls );
467
 
 
468
 
 
469
 
        // ��������...
470
 
        if (!LnsExtractLines( min_h_len, min_v_len, &result_h_count, &result_v_count ))
471
 
        {
 
543
        LnsSetup(&ls);
 
544
 
 
545
        // Работаем...
 
546
        if (!LnsExtractLines(min_h_len, min_v_len, &result_h_count, &result_v_count)) {
472
547
                //rc16 = LnsGetError ();
473
 
                SetReturnCode_rline( rc16 );
474
 
        CLINE_DeleteContainer(*PHCLINE);
475
 
        *PHCLINE = CLINE_CreateContainer(TRUE);
476
 
                return FALSE;
477
 
        }
478
 
 
479
 
        if (result_h_count)
480
 
    {
481
 
      lti.Hor.Lns = (LineInfo*)malloc(result_h_count * sizeof(LineInfo));
482
 
      if (lti.Hor.Lns == NULL)
483
 
          {
484
 
                  SetReturnCode_rline( rc16 );
485
 
                  return FALSE;
486
 
          }
487
 
        }
488
 
        else lti.Hor.Lns = NULL;
489
 
    lti.Hor.Cnt = result_h_count;
490
 
 
491
 
        if (result_v_count)
492
 
        {
493
 
      lti.Ver.Lns = (LineInfo*)malloc(result_v_count * sizeof(LineInfo));
494
 
      if (lti.Ver.Lns == NULL)
495
 
          {
496
 
                  SetReturnCode_rline( rc16 );
497
 
                  return FALSE;
498
 
          }
499
 
        }
500
 
        else lti.Ver.Lns = NULL;
501
 
    lti.Ver.Cnt = result_v_count;
502
 
 
503
 
        if (!LnsUpload( &lti, min_h_len, min_v_len ))
504
 
        {
505
 
                SetReturnCode_rline( rc16 );
506
 
                return FALSE;
507
 
        }
508
 
 
509
 
        if(!LDPUMA_Skip(RLINE_ShowLines))
510
 
        {
511
 
        Handle draw_window = LDPUMA_GetWindowHandle (NAME_IMAGE_ORTOMOVE);
512
 
                if (!draw_window) draw_window = LDPUMA_GetWindowHandle (PUMA_IMAGE_TURN);
513
 
        if (!draw_window) draw_window = LDPUMA_CreateWindow(NULL, NULL);
514
 
 
515
 
        Word32 x = 255<<8;
516
 
                Int32 temp;
 
548
                SetReturnCode_rline(rc16);
 
549
                CLINE_DeleteContainer(*PHCLINE);
 
550
                *PHCLINE = CLINE_CreateContainer(TRUE);
 
551
                return FALSE;
 
552
        }
 
553
 
 
554
        if (result_h_count) {
 
555
                lti.Hor.Lns = (LineInfo*) malloc(result_h_count * sizeof(LineInfo));
 
556
                if (lti.Hor.Lns == NULL) {
 
557
                        SetReturnCode_rline(rc16);
 
558
                        return FALSE;
 
559
                }
 
560
        } else
 
561
                lti.Hor.Lns = NULL;
 
562
        lti.Hor.Cnt = result_h_count;
 
563
 
 
564
        if (result_v_count) {
 
565
                lti.Ver.Lns = (LineInfo*) malloc(result_v_count * sizeof(LineInfo));
 
566
                if (lti.Ver.Lns == NULL) {
 
567
                        SetReturnCode_rline(rc16);
 
568
                        return FALSE;
 
569
                }
 
570
        } else
 
571
                lti.Ver.Lns = NULL;
 
572
        lti.Ver.Cnt = result_v_count;
 
573
 
 
574
        if (!LnsUpload(&lti, min_h_len, min_v_len)) {
 
575
                SetReturnCode_rline(rc16);
 
576
                return FALSE;
 
577
        }
 
578
 
 
579
        if (!LDPUMA_Skip(RLINE_ShowLines)) {
 
580
                Handle draw_window = LDPUMA_GetWindowHandle(NAME_IMAGE_ORTOMOVE);
 
581
                if (!draw_window)
 
582
                        draw_window = LDPUMA_GetWindowHandle(PUMA_IMAGE_TURN);
 
583
                if (!draw_window)
 
584
                        draw_window = LDPUMA_CreateWindow(NULL, NULL);
 
585
 
 
586
                uint32_t x = 255 << 8;
 
587
                int32_t temp;
517
588
                int i;
518
 
                for(i=0;i<lti.Hor.Cnt;i++)
519
 
                {
520
 
                        temp = (-100)*lti.Hor.Lns[i].Thickness;
521
 
                        _ASSERT(lti.Hor.Lns[i].Thickness>0);
522
 
                        LDPUMA_DrawLine(draw_window, &lti.Hor.Lns[i].A, &lti.Hor.Lns[i].B, 0, x, (WORD)temp, 512);
523
 
                }
524
 
                for(i=0;i<lti.Ver.Cnt;i++)
525
 
                {
526
 
                        temp = (-100)*lti.Ver.Lns[i].Thickness;
527
 
                        _ASSERT(lti.Ver.Lns[i].Thickness>0);
528
 
                        LDPUMA_DrawLine(draw_window, &lti.Ver.Lns[i].A, &lti.Ver.Lns[i].B, 0, x, (WORD)temp, 512);
529
 
                }
530
 
                if (lti.Hor.Cnt || lti.Ver.Cnt)
531
 
        {
532
 
            LDPUMA_Console("������� ����� �������...\n");
533
 
                    LDPUMA_WaitUserInput(RLINE_ShowLines, draw_window );
534
 
            LDPUMA_DeleteLines(draw_window, 512);
535
 
        }
 
589
                for (i = 0; i < lti.Hor.Cnt; i++) {
 
590
                        temp = (-100) * lti.Hor.Lns[i].Thickness;
 
591
                        _ASSERT(lti.Hor.Lns[i].Thickness > 0);
 
592
                        LDPUMA_DrawLine(draw_window, &lti.Hor.Lns[i].A, &lti.Hor.Lns[i].B,
 
593
                                        0, x, (uint16_t) temp, 512);
 
594
                }
 
595
                for (i = 0; i < lti.Ver.Cnt; i++) {
 
596
                        temp = (-100) * lti.Ver.Lns[i].Thickness;
 
597
                        _ASSERT(lti.Ver.Lns[i].Thickness > 0);
 
598
                        LDPUMA_DrawLine(draw_window, &lti.Ver.Lns[i].A, &lti.Ver.Lns[i].B,
 
599
                                        0, x, (uint16_t) temp, 512);
 
600
                }
 
601
                if (lti.Hor.Cnt || lti.Ver.Cnt) {
 
602
                        LDPUMA_Console("Нажмите любую клавишу...\n");
 
603
                        LDPUMA_WaitUserInput(RLINE_ShowLines, draw_window);
 
604
                        LDPUMA_DeleteLines(draw_window, 512);
 
605
                }
536
606
        }
537
607
 
538
 
///////////////////////////////////////////////////////////////////////////////////////////////////
539
 
   int i;
 
608
        ///////////////////////////////////////////////////////////////////////////////////////////////////
 
609
        int i;
540
610
 
541
 
        CLINE_handle hCLINE=CLINE_CreateContainer(TRUE);
542
 
        if(!hCLINE)
 
611
        CLINE_handle hCLINE = CLINE_CreateContainer(TRUE);
 
612
        if (!hCLINE)
543
613
                return FALSE;
544
614
        CLINE_handle hline;
545
615
        DLine data;
546
 
        int size_line=sizeof(DLine);
 
616
        int size_line = sizeof(DLine);
547
617
        LineInfo* linfo;
548
 
    for(i=0;i<lti.Hor.Cnt;i++)
549
 
        {
550
 
         hline=CLINE_AddNewLine(hCLINE);
551
 
         if(!hline)
552
 
         {
553
 
                 CLINE_DeleteContainer(hCLINE);
554
 
                 return FALSE;
555
 
         }
556
 
         linfo=&(lti.Hor.Lns[i]);
557
 
         CleanLineData(&data,size_line);
558
 
         data.ProcessingType=HorizantalLine;
559
 
         data.Line.Beg_X=linfo->A.x;
560
 
     data.Line.Beg_Y=linfo->A.y;
561
 
         data.Line.End_X=linfo->B.x;
562
 
         data.Line.End_Y=linfo->B.y;
563
 
         data.Line.Wid10=linfo->Thickness*10;
564
 
         data.Dens=(linfo->Quality*100)/255;
565
 
         data.Flags=linfo->Flags;
566
 
         data.n_event=linfo->SegCnt;
567
 
         data.Dir=LD_Horiz;
568
 
 
569
 
         if(!CLINE_SetLineData(hline,(CPDLine)(&data)))
570
 
         {
571
 
                 CLINE_DeleteContainer(hCLINE);
572
 
                 return FALSE;
573
 
         }
574
 
 
575
 
        }
576
 
    for(i=0;i<lti.Ver.Cnt;i++)
577
 
        {
578
 
         hline=CLINE_AddNewLine(hCLINE);
579
 
         if(!hline)
580
 
         {
581
 
                 CLINE_DeleteContainer(hCLINE);
582
 
                 return FALSE;
583
 
         }
584
 
         linfo=&(lti.Ver.Lns[i]);
585
 
         CleanLineData(&data,size_line);
586
 
 
587
 
         data.Line.Beg_X=linfo->A.x;
588
 
     data.Line.Beg_Y=linfo->A.y;
589
 
         data.Line.End_X=linfo->B.x;
590
 
         data.Line.End_Y=linfo->B.y;
591
 
         data.Line.Wid10=linfo->Thickness*10;
592
 
         data.Dens=(linfo->Quality*100)/255;
593
 
         data.n_event=linfo->SegCnt;
594
 
         data.Flags=linfo->Flags;
595
 
         data.Dir=LD_Verti;
596
 
         data.ProcessingType=VerticalLine;
597
 
 
598
 
         if(!CLINE_SetLineData(hline,(CPDLine)(&data)))
599
 
         {
600
 
                 CLINE_DeleteContainer(hCLINE);
601
 
                 return FALSE;
602
 
         }
603
 
        }
604
 
    *PHCLINE=hCLINE;
605
 
 
606
 
        if (!LDPUMA_Skip(hRLINE_CorrectDebugFrag))
607
 
        {
 
618
        for (i = 0; i < lti.Hor.Cnt; i++) {
 
619
                hline = CLINE_AddNewLine(hCLINE);
 
620
                if (!hline) {
 
621
                        CLINE_DeleteContainer(hCLINE);
 
622
                        return FALSE;
 
623
                }
 
624
                linfo = &(lti.Hor.Lns[i]);
 
625
                CleanLineData(&data, size_line);
 
626
                data.ProcessingType = HorizantalLine;
 
627
                data.Line.Beg_X = linfo->A.x;
 
628
                data.Line.Beg_Y = linfo->A.y;
 
629
                data.Line.End_X = linfo->B.x;
 
630
                data.Line.End_Y = linfo->B.y;
 
631
                data.Line.Wid10 = linfo->Thickness * 10;
 
632
                data.Dens = (linfo->Quality * 100) / 255;
 
633
                data.Flags = linfo->Flags;
 
634
                data.n_event = linfo->SegCnt;
 
635
                data.Dir = LD_Horiz;
 
636
 
 
637
                if (!CLINE_SetLineData(hline, (CPDLine)(&data))) {
 
638
                        CLINE_DeleteContainer(hCLINE);
 
639
                        return FALSE;
 
640
                }
 
641
 
 
642
        }
 
643
        for (i = 0; i < lti.Ver.Cnt; i++) {
 
644
                hline = CLINE_AddNewLine(hCLINE);
 
645
                if (!hline) {
 
646
                        CLINE_DeleteContainer(hCLINE);
 
647
                        return FALSE;
 
648
                }
 
649
                linfo = &(lti.Ver.Lns[i]);
 
650
                CleanLineData(&data, size_line);
 
651
 
 
652
                data.Line.Beg_X = linfo->A.x;
 
653
                data.Line.Beg_Y = linfo->A.y;
 
654
                data.Line.End_X = linfo->B.x;
 
655
                data.Line.End_Y = linfo->B.y;
 
656
                data.Line.Wid10 = linfo->Thickness * 10;
 
657
                data.Dens = (linfo->Quality * 100) / 255;
 
658
                data.n_event = linfo->SegCnt;
 
659
                data.Flags = linfo->Flags;
 
660
                data.Dir = LD_Verti;
 
661
                data.ProcessingType = VerticalLine;
 
662
 
 
663
                if (!CLINE_SetLineData(hline, (CPDLine)(&data))) {
 
664
                        CLINE_DeleteContainer(hCLINE);
 
665
                        return FALSE;
 
666
                }
 
667
        }
 
668
        *PHCLINE = hCLINE;
 
669
 
 
670
        if (!LDPUMA_Skip(hRLINE_CorrectDebugFrag)) {
608
671
                ExtractAllEvents(hCLINE, &lti);
609
672
 
610
 
                if (!LDPUMA_Skip(hRLINE_Search_Output_ShowFrags))
 
673
                if (!LDPUMA_Skip(hRLINE_Search_Output_ShowFrags))
611
674
                        DrawFragsForAllLines(hCLINE, hRLINE_Search_Output_ShowFrags);
612
675
        }
613
676
 
614
 
        if(lti.Hor.Lns) free(lti.Hor.Lns);
615
 
        if(lti.Ver.Lns) free(lti.Ver.Lns);
 
677
        if (lti.Hor.Lns)
 
678
                free(lti.Hor.Lns);
 
679
        if (lti.Ver.Lns)
 
680
                free(lti.Ver.Lns);
616
681
 
617
 
        // ��������� ������ �� ���������
 
682
        // Завершаем работу со страницей
618
683
        LnsPageFinish();
619
684
 
620
 
 
621
 
        if ( !LDPUMA_Skip(RLINE_Search) )
622
 
        {
623
 
                LDPUMA_Console("��������� ����� ����������� SerachLines");
624
 
                LDPUMA_WaitUserInput(RLINE_Search,NULL);
 
685
        if (!LDPUMA_Skip(RLINE_Search)) {
 
686
                LDPUMA_Console("Остановка перед завершением SerachLines");
 
687
                LDPUMA_WaitUserInput(RLINE_Search, NULL);
625
688
        }
626
689
 
627
 
 
628
690
        return TRUE;
629
691
}
630
692
 
631
 
 
632
 
 
633
 
Bool32 RLINE_DeleteLines(void* lpInPage, const char* lpOutDIB)
634
 
{
635
 
        LinesTotalInfo            lti2;
636
 
        PAGEINFO              PInfo;     // �������� ��������
637
 
        char*                     pImage;        // ��������� �� �����������
638
 
        LnsSetupStr                       ls;
639
 
        int                                       i;
640
 
 
641
 
 
642
 
        Int32  result_h_count,
643
 
                   result_v_count;
 
693
Bool32 RLINE_DeleteLines(void* lpInPage, const char* lpOutDIB) {
 
694
        LinesTotalInfo lti2;
 
695
        PAGEINFO PInfo; // Описание страницы
 
696
        char* pImage; // Указатель на изображение
 
697
        LnsSetupStr ls;
 
698
        int i;
 
699
 
 
700
        int32_t result_h_count, result_v_count;
644
701
        Bool DelAllLines;
645
702
        DelAllLines = FALSE;
646
 
        CLINE_handle hCLINE=CLINE_GetMainContainer();
 
703
        CLINE_handle hCLINE = CLINE_GetMainContainer();
647
704
 
648
 
        // �������� PAGEINFO ������� ��������
649
 
        if (!CPAGE_GetPageData( lpInPage,PT_PAGEINFO,(void*)&PInfo,sizeof(PInfo)))
650
 
        {
651
 
                LDPUMA_Console( " Error in GetPageData " );
 
705
        // Получаем PAGEINFO текущей страницы
 
706
        if (!CPAGE_GetPageData(lpInPage, PT_PAGEINFO, (void*) &PInfo, sizeof(PInfo))) {
 
707
                LDPUMA_Console(" Error in GetPageData ");
652
708
                rc32 = CPAGE_GetReturnCode();
653
 
                SetReturnCode_rline( rc32 );
 
709
                SetReturnCode_rline(rc32);
654
710
                return FALSE;
655
711
        }
656
712
 
657
 
        // �������� � pImage �� PInfo ��������� �� �����������,
658
 
        // ��������� �� ���������
659
 
        pImage = (char*)&PInfo.szImageName;
660
 
 
661
 
        min_h_len = (Word16)(PInfo.DPIX*40/300);
662
 
        min_v_len = (Word16)(PInfo.DPIY*40/300);
663
 
 
664
 
        if (!CIMAGE_GetCallbackImage((PWord8) pImage, &cbk))
665
 
        {
666
 
                LDPUMA_Console( " Error in GetCallbackImage " );
 
713
        // Копируем в pImage из PInfo указатель на изображение,
 
714
        // связанное со страницей
 
715
        pImage = (char*) &PInfo.szImageName;
 
716
 
 
717
        min_h_len = (uint16_t) (PInfo.DPIX * 40 / 300);
 
718
        min_v_len = (uint16_t) (PInfo.DPIY * 40 / 300);
 
719
 
 
720
        if (!CIMAGE_GetCallbackImage((puchar) pImage, &cbk)) {
 
721
                LDPUMA_Console(" Error in GetCallbackImage ");
667
722
                rc32 = CIMAGE_GetReturnCode();
668
 
                SetReturnCode_rline( rc32 );
 
723
                SetReturnCode_rline(rc32);
669
724
                return FALSE;
670
725
        }
671
726
 
672
 
        imxs.f_op = DibOpen;                                                            // �� �� ����� �� �� ������ �������� ������
673
 
        imxs.f_re = DibRead;                                                            // � ���� �� ���� � CIMAGE � LNS32 ���������
674
 
        imxs.f_cl = DibClose;                                                           // imxs->... cbk->... ����� �������������� �����.
 
727
        imxs.f_op = DibOpen; // Мы не можем из за разных названий одного
 
728
        imxs.f_re = DibRead; // и того же типа в CIMAGE и LNS32 присвоить
 
729
        imxs.f_cl = DibClose; // imxs->... cbk->... нужно преобразование типов.
675
730
 
676
 
        // �������������� ��������
 
731
        // Подготавливаем страницу
677
732
        LnsPageStart(&imxs);
678
733
 
679
 
        // ��������� ���������� ������ LNS32.dll
 
734
        // Установка параметров работы LNS32.dll
680
735
        ls.nOptions = 0;
681
 
        LnsSetup ( &ls );
 
736
        LnsSetup(&ls);
682
737
 
683
 
        if ( !LDPUMA_Skip(RLINE_NoFillgap) )
684
 
        {
 
738
        if (!LDPUMA_Skip(RLINE_NoFillgap)) {
685
739
                gbNOFILLGAP3 = TRUE;
686
 
        }
687
 
        else
688
 
        {
 
740
        } else {
689
741
                gbNOFILLGAP3 = FALSE;
690
742
        }
691
743
        ls.nOptions |= gbNOFILLGAP3 ? 0 : LSS_NOFILLGAP3_FILTER;
692
744
 
693
 
        if ( !LDPUMA_Skip(RLINE_NoHorBorder) )
694
 
        {
 
745
        if (!LDPUMA_Skip(RLINE_NoHorBorder)) {
695
746
                gbNOHBORDER = TRUE;
696
 
        }
697
 
        else
698
 
        {
 
747
        } else {
699
748
                gbNOHBORDER = FALSE;
700
749
        }
701
750
        ls.nOptions |= gbNOHBORDER ? 0 : LSS_NOHBORDER_FILTER;
702
751
 
703
 
        if ( !LDPUMA_Skip(RLINE_NoVerBorder) )
704
 
        {
 
752
        if (!LDPUMA_Skip(RLINE_NoVerBorder)) {
705
753
                gbNOVBORDER = TRUE;
706
 
        }
707
 
        else
708
 
        {
 
754
        } else {
709
755
                gbNOVBORDER = FALSE;
710
756
        }
711
757
        ls.nOptions |= gbNOVBORDER ? 0 : LSS_NOVBORDER_FILTER;
712
758
 
713
 
        LnsSetup ( &ls );
 
759
        LnsSetup(&ls);
714
760
 
715
 
        //��������...
716
 
        if (!LnsExtractLines( min_h_len, min_v_len, &result_h_count, &result_v_count ))
717
 
        {
718
 
                SetReturnCode_rline( rc16 );
 
761
        //работаем...
 
762
        if (!LnsExtractLines(min_h_len, min_v_len, &result_h_count, &result_v_count)) {
 
763
                SetReturnCode_rline(rc16);
719
764
                return FALSE;
720
765
        }
721
766
 
722
 
        if (result_h_count)
723
 
    {
724
 
      lti2.Hor.Lns = (LineInfo*)malloc(result_h_count * sizeof(LineInfo));
725
 
      if (lti2.Hor.Lns == NULL)
726
 
      {
727
 
                  SetReturnCode_rline( rc16 );
728
 
                  return FALSE;
729
 
          }
730
 
        }
731
 
        else lti2.Hor.Lns = NULL;
732
 
    lti2.Hor.Cnt = result_h_count;
733
 
 
734
 
        if (result_v_count)
735
 
        {
736
 
      lti2.Ver.Lns = (LineInfo*)malloc(result_v_count * sizeof(LineInfo));
737
 
      if (lti2.Ver.Lns == NULL)
738
 
      {
739
 
                  SetReturnCode_rline( rc16 );
740
 
                  return FALSE;
741
 
          }
742
 
        }
743
 
        else lti2.Ver.Lns = NULL;
744
 
    lti2.Ver.Cnt = result_v_count;
745
 
 
746
 
        if (!LnsUpload( &lti2, min_h_len, min_v_len ))
747
 
        {
748
 
                SetReturnCode_rline( rc16 );
 
767
        if (result_h_count) {
 
768
                lti2.Hor.Lns = (LineInfo*) malloc(result_h_count * sizeof(LineInfo));
 
769
                if (lti2.Hor.Lns == NULL) {
 
770
                        SetReturnCode_rline(rc16);
 
771
                        return FALSE;
 
772
                }
 
773
        } else
 
774
                lti2.Hor.Lns = NULL;
 
775
        lti2.Hor.Cnt = result_h_count;
 
776
 
 
777
        if (result_v_count) {
 
778
                lti2.Ver.Lns = (LineInfo*) malloc(result_v_count * sizeof(LineInfo));
 
779
                if (lti2.Ver.Lns == NULL) {
 
780
                        SetReturnCode_rline(rc16);
 
781
                        return FALSE;
 
782
                }
 
783
        } else
 
784
                lti2.Ver.Lns = NULL;
 
785
        lti2.Ver.Cnt = result_v_count;
 
786
 
 
787
        if (!LnsUpload(&lti2, min_h_len, min_v_len)) {
 
788
                SetReturnCode_rline(rc16);
749
789
                return FALSE;
750
790
        }
751
791
 
752
792
        CLINE_handle hline;
753
 
        if(DelAllLines)
754
 
        {
755
 
                for(i=lti2.Hor.Cnt-1;i>=0;i--)
756
 
                        lti2.Hor.Lns[i].Flags=LI_SWEEP;
757
 
                for(i=lti2.Ver.Cnt-1;i>=0;i--)
758
 
                        lti2.Ver.Lns[i].Flags=LI_SWEEP;
759
 
        }
760
 
        else
761
 
        {
762
 
         for(hline=CLINE_GetFirstLine(hCLINE);hline;hline=CLINE_GetNextLine(hline))
763
 
         {
764
 
      CPDLine cpdata=CLINE_GetLineData(hline);
765
 
          if (!cpdata)
766
 
          {
767
 
                        rc32 = CLINE_GetReturnCode();
768
 
                        SetReturnCode_rline( rc32 );
769
 
                        return FALSE;
770
 
          }
771
 
      if(cpdata->Dir==LD_Horiz)
772
 
          {
773
 
                for (i=0; i<lti2.Hor.Cnt; i++)
774
 
                {
775
 
                        if( (lti2.Hor.Lns[i].A.x == cpdata->Line.Beg_X) && (lti2.Hor.Lns[i].B.x == cpdata->Line.End_X) &&
776
 
                                        (lti2.Hor.Lns[i].A.y == cpdata->Line.Beg_Y) && (lti2.Hor.Lns[i].B.y == cpdata->Line.End_Y) )
777
 
                        {
778
 
                                        if (cpdata->Flags & LI_NOTWHOLE)
779
 
                                        {
780
 
                                         lti2.Hor.Lns[i].Anew = cpdata->lns_data.Anew;
781
 
                                         lti2.Hor.Lns[i].Bnew = cpdata->lns_data.Bnew;
782
 
                                        }
783
 
                                        lti2.Hor.Lns[i].Flags = cpdata->Flags;
784
 
                                        if (cpdata->Flags &  LI_IsTrue)
785
 
                                                lti2.Hor.Lns[i].Flags |= LI_SWEEP;
786
 
                                        i=lti2.Hor.Cnt;
787
 
                        }
788
 
                }
789
 
          }
790
 
          else
791
 
          {
792
 
                for (i=0; i<lti2.Ver.Cnt; i++)
793
 
                {
794
 
                        if( (lti2.Ver.Lns[i].A.x == cpdata->Line.Beg_X) && (lti2.Ver.Lns[i].B.x == cpdata->Line.End_X) &&
795
 
                                        (lti2.Ver.Lns[i].A.y == cpdata->Line.Beg_Y) && (lti2.Ver.Lns[i].B.y == cpdata->Line.End_Y) )
796
 
                        {
797
 
                                        if (cpdata->Flags & LI_NOTWHOLE)
798
 
                                        {
799
 
                                         lti2.Ver.Lns[i].Anew = cpdata->lns_data.Anew;
800
 
                                         lti2.Ver.Lns[i].Bnew = cpdata->lns_data.Bnew;
801
 
                                        }
802
 
                                        lti2.Ver.Lns[i].Flags = cpdata->Flags;
803
 
                                        if (cpdata->Flags &  LI_IsTrue)
804
 
                                                lti2.Ver.Lns[i].Flags |= LI_SWEEP;
805
 
                                        i=lti2.Ver.Cnt;
806
 
                        }
807
 
                }
808
 
          }
809
 
         }
810
 
        }
811
 
/////////////////////////////////////////////////////////////////////////////////////////////
812
 
        swp_imxs = LnsGetSweepedImage( &lti2 );
813
 
 
 
793
        if (DelAllLines) {
 
794
                for (i = lti2.Hor.Cnt - 1; i >= 0; i--)
 
795
                        lti2.Hor.Lns[i].Flags = LI_SWEEP;
 
796
                for (i = lti2.Ver.Cnt - 1; i >= 0; i--)
 
797
                        lti2.Ver.Lns[i].Flags = LI_SWEEP;
 
798
        } else {
 
799
                for (hline = CLINE_GetFirstLine(hCLINE); hline; hline
 
800
                                = CLINE_GetNextLine(hline)) {
 
801
                        CPDLine cpdata = CLINE_GetLineData(hline);
 
802
                        if (!cpdata) {
 
803
                                rc32 = CLINE_GetReturnCode();
 
804
                                SetReturnCode_rline(rc32);
 
805
                                return FALSE;
 
806
                        }
 
807
                        if (cpdata->Dir == LD_Horiz) {
 
808
                                for (i = 0; i < lti2.Hor.Cnt; i++) {
 
809
                                        if ((lti2.Hor.Lns[i].A.x == cpdata->Line.Beg_X)
 
810
                                                        && (lti2.Hor.Lns[i].B.x == cpdata->Line.End_X)
 
811
                                                        && (lti2.Hor.Lns[i].A.y == cpdata->Line.Beg_Y)
 
812
                                                        && (lti2.Hor.Lns[i].B.y == cpdata->Line.End_Y)) {
 
813
                                                if (cpdata->Flags & LI_NOTWHOLE) {
 
814
                                                        lti2.Hor.Lns[i].Anew = cpdata->lns_data.Anew;
 
815
                                                        lti2.Hor.Lns[i].Bnew = cpdata->lns_data.Bnew;
 
816
                                                }
 
817
                                                lti2.Hor.Lns[i].Flags = cpdata->Flags;
 
818
                                                if (cpdata->Flags & LI_IsTrue)
 
819
                                                        lti2.Hor.Lns[i].Flags |= LI_SWEEP;
 
820
                                                i = lti2.Hor.Cnt;
 
821
                                        }
 
822
                                }
 
823
                        } else {
 
824
                                for (i = 0; i < lti2.Ver.Cnt; i++) {
 
825
                                        if ((lti2.Ver.Lns[i].A.x == cpdata->Line.Beg_X)
 
826
                                                        && (lti2.Ver.Lns[i].B.x == cpdata->Line.End_X)
 
827
                                                        && (lti2.Ver.Lns[i].A.y == cpdata->Line.Beg_Y)
 
828
                                                        && (lti2.Ver.Lns[i].B.y == cpdata->Line.End_Y)) {
 
829
                                                if (cpdata->Flags & LI_NOTWHOLE) {
 
830
                                                        lti2.Ver.Lns[i].Anew = cpdata->lns_data.Anew;
 
831
                                                        lti2.Ver.Lns[i].Bnew = cpdata->lns_data.Bnew;
 
832
                                                }
 
833
                                                lti2.Ver.Lns[i].Flags = cpdata->Flags;
 
834
                                                if (cpdata->Flags & LI_IsTrue)
 
835
                                                        lti2.Ver.Lns[i].Flags |= LI_SWEEP;
 
836
                                                i = lti2.Ver.Cnt;
 
837
                                        }
 
838
                                }
 
839
                        }
 
840
                }
 
841
        }
 
842
        /////////////////////////////////////////////////////////////////////////////////////////////
 
843
        swp_imxs = LnsGetSweepedImage(&lti2);
814
844
 
815
845
        CIMAGEIMAGECALLBACK cbk1;
816
 
        cbk1.CIMAGE_ImageOpen  = SampleImageOpen;
817
 
        cbk1.CIMAGE_ImageRead  = SampleImageRead;
 
846
        cbk1.CIMAGE_ImageOpen = SampleImageOpen;
 
847
        cbk1.CIMAGE_ImageRead = SampleImageRead;
818
848
        cbk1.CIMAGE_ImageClose = SampleImageClose;
819
849
 
820
 
 
821
 
        if (!CIMAGE_GetCallbackImage( (PWord8)pImage, &cbk))
822
 
        {
823
 
                rc32 = CIMAGE_GetReturnCode();
824
 
                SetReturnCode_rline( rc32 );
825
 
                return FALSE;
826
 
        }
827
 
 
828
 
        if (!CIMAGE_WriteCallbackImage( (PWord8)lpOutDIB, cbk1 ))
829
 
        {
830
 
                rc32 = CIMAGE_GetReturnCode();
831
 
                SetReturnCode_rline( rc32 );
832
 
                return FALSE;
833
 
        }
834
 
 
 
850
        if (!CIMAGE_GetCallbackImage((puchar) pImage, &cbk)) {
 
851
                rc32 = CIMAGE_GetReturnCode();
 
852
                SetReturnCode_rline(rc32);
 
853
                return FALSE;
 
854
        }
 
855
 
 
856
        if (!CIMAGE_WriteCallbackImage((puchar) lpOutDIB, cbk1)) {
 
857
                rc32 = CIMAGE_GetReturnCode();
 
858
                SetReturnCode_rline(rc32);
 
859
                return FALSE;
 
860
        }
835
861
 
836
862
        LnsPageFinish();
837
863
 
838
 
        if(!LDPUMA_Skip(RLINE_ShowWithoutLines))
839
 
        {
840
 
                BITMAPINFOHEADER * lp = NULL ;
841
 
                CIMAGE_ReadDIB((PWord8)PUMA_IMAGE_DELLINE,(Handle*)&lp,TRUE);
842
 
                Handle hwnd = LDPUMA_CreateWindow("����� ������ �����",lp);
843
 
                LDPUMA_Console("������� ����� �������...");
844
 
                LDPUMA_WaitUserInput(RLINE_ShowWithoutLines, hwnd );
 
864
        if (!LDPUMA_Skip(RLINE_ShowWithoutLines)) {
 
865
                BITMAPINFOHEADER * lp = NULL;
 
866
                CIMAGE_ReadDIB((puchar) PUMA_IMAGE_DELLINE, (Handle*) &lp, TRUE);
 
867
                Handle hwnd = LDPUMA_CreateWindow("После снятия линий", lp);
 
868
                LDPUMA_Console("Нажмите любую клавишу...");
 
869
                LDPUMA_WaitUserInput(RLINE_ShowWithoutLines, hwnd);
845
870
        }
846
871
 
847
 
        if(lti2.Hor.Lns) free(lti2.Hor.Lns);
848
 
        if(lti2.Ver.Lns) free(lti2.Ver.Lns);
 
872
        if (lti2.Hor.Lns)
 
873
                free(lti2.Hor.Lns);
 
874
        if (lti2.Ver.Lns)
 
875
                free(lti2.Ver.Lns);
849
876
 
850
877
        return TRUE;
851
878
}
852
879
 
853
 
void CleanLineData(void* pdata,int size)
854
 
{
855
 
        Word8* mas=(Word8*)pdata;
856
 
        for(int i=size-1;i>=0;i--)
857
 
        {
858
 
                mas[i]=0;
 
880
void CleanLineData(void* pdata, int size) {
 
881
        uchar* mas = (uchar*) pdata;
 
882
        for (int i = size - 1; i >= 0; i--) {
 
883
                mas[i] = 0;
859
884
        }
860
885
}