~ubuntu-branches/debian/experimental/cuneiform/experimental

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk, libm.diff, swapbytes.diff
  • Date: 2010-09-14 15:53:54 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914155354-hhxaa13xmhb82e3e
Tags: 1.0.0+dfsg-1
* New upstream release (closes: #575419).
* New maintainer (closes: #543893).
* Document in README.source how to repackage upstream tarball.
* Update debian/copyright.
  + Document that the package is auto-buildable.
  + Document which files were stripped from the upstream tarball.
  + Convert to the DEP-5 format.
* Drop README.Debian, no longer needed.
* Rewrite debian/rules from scratch using dh.
  + Bump debhelper minimum version to 7.4.4 (for cmake support).
  + Turn on MAKE_VERBOSE_MAKEFILE.
  + Disable call to dh_makeshlibs to avoid creation of spurious
    calls to ldconfig in postrm/postinst.
  + Add get-orig-source target.
* Remove unused overrides.
* Link to GraphicsMagick rather than ImageMagick:
  + Build-depend on graphicsmagick-libmagick-dev-compat.
  + Add patch to properly initialize the library. [graphicsmagick.diff]    
* Bump standards version to 3.9.1 (no changes needed).
* Force upgrade of ocrodjvu to at least 0.4.2; earlier versions of ocrodjvu
  don't support this version of Cuneiform.
* List all the supported languages in the package description.
* Update the manual page.
  + Document --dotmatrix, --fax and --singlecolumn options.
  + Document all output formats.
  + Don't use hyphen as minus sign.
  + Fix a few formatting issues.
* Drop Vcs-* fields.
* Add watch file.
* Add patch from Dmitrijs Ledkovs to link the lao library with libm.
  [libm.diff]
* Add patch for a for a more portable function to swap byte order.
  [swapbytes.diff]
* Set Architecture to any; there's no good reason to limit it.
* Run rudimentary tests at build time.

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:
66
66
 
67
67
# define IDEAL_XY(x, y)   \
68
68
         {\
69
 
             y = (INT) (y - (LONG) x * nIncline / INCLINE_FACTOR);\
70
 
             x = (INT) (x + (LONG) y * nIncline / INCLINE_FACTOR);\
 
69
             y = (int16_t) (y - (int32_t) x * nIncline / INCLINE_FACTOR);\
 
70
             x = (int16_t) (x + (int32_t) y * nIncline / INCLINE_FACTOR);\
71
71
         }
72
72
 
73
73
# define REAL_XY(x, y)   \
74
74
         {\
75
 
             x = (INT) (x - (LONG) y * nIncline / INCLINE_FACTOR);\
76
 
             y = (INT) (y + (LONG) x * nIncline / INCLINE_FACTOR);\
 
75
             x = (int16_t) (x - (int32_t) y * nIncline / INCLINE_FACTOR);\
 
76
             y = (int16_t) (y + (int32_t) x * nIncline / INCLINE_FACTOR);\
77
77
                }
78
78
 
79
79
/*----------------------------------------------------------------------------*/
80
80
 
81
 
//���������
 
81
//Настройки
82
82
 
83
83
int inf_neg_h;
84
84
int inf_neg_w;
92
92
int inf_betw_str_h;
93
93
int sup_square;
94
94
/*----------------------------------------------------------------------------*/
95
 
//���������
 
95
//Параметры
96
96
 
97
97
int     DPIX;
98
98
int     DPIY;
99
99
int Height;
100
100
int Width;
101
 
Word8 ImageName[CPAGE_MAXNAME];
 
101
uchar ImageName[CPAGE_MAXNAME];
102
102
int nIncline;
103
 
BOOL dpTime;
104
 
BOOL dpPrintResConsole;
105
 
BOOL dpNegResD;
106
 
BOOL dpNegRecD;
107
 
BOOL dpRecOneLetter;
 
103
Bool dpTime;
 
104
Bool dpPrintResConsole;
 
105
Bool dpNegResD;
 
106
Bool dpNegRecD;
 
107
Bool dpRecOneLetter;
108
108
/*----------------------------------------------------------------------------*/
109
109
NegImage* pNegImage;
110
110
 
112
112
 
113
113
 
114
114
 
115
 
RNEG_FUNC(void) RNEG_RecogNeg(CCOM_handle hCCOM, Handle hCPage,Word8* pImageName,int skew)
 
115
RNEG_FUNC(void) RNEG_RecogNeg(CCOM_handle hCCOM, Handle hCPage,uchar* pImageName,int skew)
116
116
{
117
117
 
118
118
 MainWindowD=NULL;
119
 
 MainWindowD=LDPUMA_GetWindowHandle ("����������� ����� ���������");
 
119
 MainWindowD=LDPUMA_GetWindowHandle ("Изображение после разворота");
120
120
 if(!MainWindowD)
121
121
    MainWindowD=LDPUMA_GetWindowHandle ("Main");
122
122
 
128
128
 
129
129
// LDPUMA_ConsoleN("");
130
130
 if(dpTime)
131
 
     LDPUMA_ConsoleN("�������������� ������� ������ � ������������� ���������");
 
131
     LDPUMA_ConsoleN("Активизируется функция поиска и разпознования негативов");
132
132
 int time=clock();
133
133
 if(!(LDPUMA_Skip (NegSearch)) )
134
134
         return;
135
135
 
136
 
 Word32 code_sersized=(512<<16);
137
 
 Word32 code_normd=(512<<17);
138
 
 Word32 code_colord=(512<<17)+(512<<16);
139
 
 Word32 code_cutd=(512<<18);
140
 
 Word32 code_cutstrd=(512<<18)+(512<<16);
141
 
 Word32 code_sized=(512<<18)+(512<<17);
 
136
 uint32_t code_sersized=(512<<16);
 
137
 uint32_t code_normd=(512<<17);
 
138
 uint32_t code_colord=(512<<17)+(512<<16);
 
139
 uint32_t code_cutd=(512<<18);
 
140
 uint32_t code_cutstrd=(512<<18)+(512<<16);
 
141
 uint32_t code_sized=(512<<18)+(512<<17);
142
142
 
143
143
 #define NEGA   1<<14
144
144
 #define VERTICA 1<<13
182
182
 NegList* temp;
183
183
 int nRC=0;
184
184
 int i;
185
 
 BOOL fl_del_mas_neg;
186
 
 BOOL flag_rotate;
187
 
 BOOL flag_rimage_rotate;
 
185
 Bool fl_del_mas_neg;
 
186
 Bool flag_rotate;
 
187
 Bool flag_rimage_rotate;
188
188
 
189
189
 
190
190
 if(!LDPUMA_Skip(SetSkew))
204
204
        time=clock();
205
205
 }
206
206
 
207
 
/* �������������� ����� ���������� � �������� �� �������*/
 
207
/* Осуществляется поиск кандидатов в негативы по размеру*/
208
208
 
209
209
 if(LDPUMA_Skip (NegSearchSize) )
210
210
 {
211
211
  fl_del_mas_neg=SearchNegBySize(hCCOM,hCPage,&root,nRC);
212
212
 
213
 
  /*���������� ��������� ���������� � �������� �� ��������*/
 
213
  /*Прорисовка найденных кандидатов в негативы по размерам*/
214
214
 
215
215
  if(nRC>0)
216
216
  {
222
222
     NegDrawRect(MainWindowD,code_sersized,RGB(0,0,255),(now->neg).pRc[0]);
223
223
     now=now->next;
224
224
        }
225
 
        LDPUMA_ConsoleN("�� ��������");
 
225
        LDPUMA_ConsoleN("По размерам");
226
226
    LDPUMA_WaitUserInput (NegSearchSizeD,MainWindowD);
227
227
    if(LDPUMA_Skip (NegSearchSizeDC) )
228
228
      LDPUMA_DeleteRects (MainWindowD,code_sersized);
252
252
          now=now->next;
253
253
 }
254
254
 
255
 
/* �������������� ��������(���� ������) �����, �.�. ����������
256
 
          �������� � ������������� ����*/
 
255
/* Осуществляется удаление(если повезёт) грязи, т.е. приведение
 
256
          негатива к каноническому виду*/
257
257
 
258
258
 if(LDPUMA_Skip (NegNorm) )
259
259
 {
260
260
 
261
 
/* ������� (���� ���������) ���������*/
 
261
/* Поворот (если необходим) негативов*/
262
262
 
263
263
  flag_rotate=NegRotate(hCPage,root,nRC,skew);
264
264
 
275
275
   }
276
276
 
277
277
 
278
 
/*�������� ��������������*/
 
278
/*Обратное преобразование*/
279
279
   if(flag_rotate)
280
280
   {
281
281
          now=root;
292
292
   }
293
293
 
294
294
 
295
 
  /* ���������� ��������������� ���������� � ��������*/
 
295
  /* Прорисовка нормализованных кандидатов в негативы*/
296
296
 
297
297
  if(nRC>0)
298
298
  {
304
304
     NegDrawRect(MainWindowD,code_normd,RGB(0,255,0),(now->neg).pRc[0]);
305
305
     now=now->next;
306
306
        }
307
 
        LDPUMA_ConsoleN("���������������");
 
307
        LDPUMA_ConsoleN("Нормализованные");
308
308
    LDPUMA_WaitUserInput (NegNormD,MainWindowD);
309
309
    if(LDPUMA_Skip (NegNormDC) )
310
310
      LDPUMA_DeleteRects (MainWindowD,code_normd);
314
314
 
315
315
 
316
316
 
317
 
/* ����� ������� ���������*/
 
317
/* Резка сложных негативов*/
318
318
 
319
319
 if(LDPUMA_Skip (NegCut) )
320
320
 {
321
321
 
322
 
/* ������� (���� ���������) ���������*/
 
322
/* Поворот (если необходим) негативов*/
323
323
 flag_rotate=NegRotate(hCPage,root,nRC,skew);
324
324
 
325
325
 
326
326
  CutNeg(hCPage,&root,nRC,skew);
327
327
 
328
328
 
329
 
   /* ������� (���� ���������) ���������*/
 
329
   /* Поворот (если необходим) негативов*/
330
330
  flag_rotate=NegRotate(hCPage,root,nRC,skew);
331
331
 
332
332
 
342
342
        now=temp;
343
343
   }
344
344
 
345
 
   /*�������� ��������������*/
 
345
   /*Обратное преобразование*/
346
346
   if(flag_rotate)
347
347
   {
348
348
           now=root;
359
359
   }
360
360
 
361
361
 
362
 
  /* ���������� ����������� ���������*/
 
362
  /* Прорисовка разрезанных негативов*/
363
363
 
364
364
  if(nRC>0)
365
365
  {
371
371
     NegDrawRect(MainWindowD,code_cutd,RGB(255,0,0),(now->neg).pRc[0]);
372
372
     now=now->next;
373
373
        }
374
 
        LDPUMA_ConsoleN("�����������");
 
374
        LDPUMA_ConsoleN("Разрезанные");
375
375
    LDPUMA_WaitUserInput (NegCutD,MainWindowD);
376
376
    if(LDPUMA_Skip (NegCutDC) )
377
377
      LDPUMA_DeleteRects (MainWindowD,code_cutd);
389
389
 int w;
390
390
 Rect16 Rc;
391
391
 
392
 
 /*����� �� �������*/
 
392
 /*Отсев по размеру*/
393
393
 if(LDPUMA_Skip (NegSize) )
394
394
 {
395
395
  while(now)
409
409
                  now=now->prev;
410
410
  }
411
411
 
412
 
  /* ���������� ��������� �� �������*/
 
412
  /* Прорисовка отсеянных по размеру*/
413
413
 
414
414
  if(nRC>0)
415
415
  {
425
425
     NegDrawRect(MainWindowD,code_sized,RGB(255,255,0),Rc);
426
426
     now=now->next;
427
427
        }
428
 
        LDPUMA_ConsoleN("������������� ����������");
 
428
        LDPUMA_ConsoleN("Окончательная прорисовка");
429
429
    LDPUMA_WaitUserInput (NegSizeD,MainWindowD);
430
430
    if(LDPUMA_Skip (NegSizeDC) )
431
431
      LDPUMA_DeleteRects (MainWindowD,code_sized);
434
434
 
435
435
 }
436
436
 
437
 
/* ������� (���� ���������) ���������*/
 
437
/* Поворот (если необходим) негативов*/
438
438
 flag_rotate=NegRotate(hCPage,root,nRC,skew);
439
439
 
440
440
 
441
 
/* �������������� ����� ���������� � �������� �� ������������
442
 
            ������� �����*/
 
441
/* Осуществляется отсев кандидатов в негативы по насыщенности
 
442
            чёрного цвета*/
443
443
 
444
444
 if(LDPUMA_Skip (NegColor) )
445
445
 {
446
446
  SearchNegByBlack(hCPage,&root,nRC);
447
447
 
448
 
  /*���������� ���������� � �������� ����� ������ �� �������� �����*/
 
448
  /*Прорисовка кандидатов в негативы после отсева по цветовой гамме*/
449
449
 
450
450
  if(nRC>0)
451
451
  {
457
457
     NegDrawRect(MainWindowD,code_colord,RGB(0,255,255),(now->neg).pRc[0]);
458
458
     now=now->next;
459
459
        }
460
 
        LDPUMA_ConsoleN("��������� �� �������� �����");
 
460
        LDPUMA_ConsoleN("Отсеянные по цветовой гамме");
461
461
    LDPUMA_WaitUserInput (NegColorD,MainWindowD);
462
462
    if(LDPUMA_Skip (NegColorDC) )
463
463
      LDPUMA_DeleteRects (MainWindowD,code_colord);
465
465
  }
466
466
 }
467
467
 
468
 
 /* ����� ������������� ���������*/
 
468
 /* Резка многострочных негативов*/
469
469
 
470
470
 
471
471
 if(LDPUMA_Skip (NegCutStr) )
473
473
  CutNegStr(hCPage,&root,nRC,skew);
474
474
 
475
475
 
476
 
  /* ���������� ����������� ���������*/
 
476
  /* Прорисовка разрезанных негативов*/
477
477
 
478
478
  if(nRC>0)
479
479
  {
486
486
      NegDrawRect(MainWindowD,code_cutstrd,RGB(255,0,255),(now->neg).pRc[i]);
487
487
     now=now->next;
488
488
        }
489
 
        LDPUMA_ConsoleN("����������� �� ������");
 
489
        LDPUMA_ConsoleN("Разрезанные на строки");
490
490
    LDPUMA_WaitUserInput (NegCutStrD,MainWindowD);
491
491
    if(LDPUMA_Skip (NegCutStrDC) )
492
492
      LDPUMA_DeleteRects (MainWindowD,code_cutstrd);
497
497
 
498
498
 
499
499
 
500
 
/*����� ��������������*/
 
500
/*Отсев пересекающихся*/
501
501
 
502
502
 DelIn(hCPage,&root,nRC);
503
503
 
505
505
 if(dpTime)
506
506
   LDPUMA_ConsoleN("Time stuff=%d",time_stuff-time);
507
507
 
508
 
/* �������������� ������������� �� ������� ����������*/
 
508
/* Осуществляется распознование из массива кандидатов*/
509
509
 if(flag_rimage_rotate)
510
510
 {
511
511
         UnRotateNeg(root,skew);
539
539
  }
540
540
 }
541
541
 
542
 
 /* ������ � CPage*/
 
542
 /* Отпись в CPage*/
543
543
 
544
544
 
545
545
 
547
547
 if(1/*!(LDPUMA_Skip (PutToCPage) )*/)
548
548
 {
549
549
 POLY_ block={0};
550
 
 Word32 size_poly=sizeof(POLY_);
 
550
 uint32_t size_poly=sizeof(POLY_);
551
551
  while(now)
552
552
  {
553
553
   if((now->neg).p>inf_prob)
557
557
    Rc.right=(now->neg).pRc[0].right;
558
558
    Rc.top=(now->neg).pRc[(now->neg).nRc-1].top;
559
559
    Rc.bottom=(now->neg).pRc[0].bottom;
560
 
            block.com.type = TYPE_TEXT; //�����, ��������, �������;
 
560
            block.com.type = TYPE_TEXT; //Текст, Картинка, Таблица;
561
561
                        block.com.count = 4;
562
562
                        block.negative=TYPE_NEGATIVE;
563
563
                        block.com.Flags=NEGA;
605
605
 {
606
606
  now=root;
607
607
 
608
 
  Word8 Name[CPAGE_MAXNAME];
 
608
  uchar Name[CPAGE_MAXNAME];
609
609
  for (int j=0; j<CPAGE_MAXNAME; j++)
610
610
                Name[j] = ImageName[j];
611
611
 
642
642
}
643
643
 
644
644
 
645
 
BOOL NegRotate(Handle hCPage,NegList* root,int nRc,int skew)
 
645
Bool NegRotate(Handle hCPage,NegList* root,int nRc,int skew)
646
646
{
647
 
 BOOL ret=FALSE;
 
647
 Bool ret=FALSE;
648
648
 int oldskew=skew;
649
649
 if(skew<0)
650
650
         skew=-skew;
654
654
 int h;
655
655
 int bytewide;
656
656
 
657
 
 Word8 Data[1000];
 
657
 uchar Data[1000];
658
658
 memset (Data, 0, sizeof (Data));
659
 
 Word8* pmasp;
 
659
 uchar* pmasp;
660
660
 
661
661
 NegList* now=root;
662
662
 Rect16 Rc;
663
 
 BOOL fl_cont;
 
663
 Bool fl_cont;
664
664
 
665
665
 while(now)
666
666
 {
686
686
  }
687
687
  if(fl_cont)
688
688
          continue;
689
 
  if(!( (now->neg).rot.pmasp=new Word8[bytewide*h]))
 
689
  if(!( (now->neg).rot.pmasp=new uchar[bytewide*h]))
690
690
  {
691
691
          fl_cont=TRUE;
692
692
          now=now->next;
727
727
 return ret;
728
728
}
729
729
 
730
 
void NegCopy(Word8* from,Word8* to,int bytewide,int h)
 
730
void NegCopy(uchar* from,uchar* to,int bytewide,int h)
731
731
{
732
732
        int j=bytewide*h;
733
733
        for(int i=0;i<j;i++)
734
734
                to[i]=from[i];
735
735
}
736
736
 
737
 
BOOL InitRotateMas(int w,int h,Int16** ppbegx,Int16** ppmovey,Word8** ppflmovey,int** pphi)
 
737
Bool InitRotateMas(int w,int h,int16_t** ppbegx,int16_t** ppmovey,uchar** ppflmovey,int** pphi)
738
738
{
739
 
        if(!( (*ppbegx)=new Int16[h+1]))
 
739
        if(!( (*ppbegx)=new int16_t[h+1]))
740
740
                return FALSE;
741
 
        if(!( (*ppmovey)=new Int16[w+1]))
 
741
        if(!( (*ppmovey)=new int16_t[w+1]))
742
742
        {
743
743
                delete[] (*ppbegx);
744
744
                (*ppbegx)=NULL;
745
745
                return FALSE;
746
746
        }
747
 
        if(!( (*ppflmovey)=new Word8[w+1]))
 
747
        if(!( (*ppflmovey)=new uchar[w+1]))
748
748
        {
749
749
                delete[] (*ppbegx);
750
750
                (*ppbegx)=NULL;
765
765
        return TRUE;
766
766
}
767
767
 
768
 
void DeleteRotateMas(Word8** pmasp,Int16** begx,Int16** movey,Word8** flmovey,int** hi)
 
768
void DeleteRotateMas(uchar** pmasp,int16_t** begx,int16_t** movey,uchar** flmovey,int** hi)
769
769
{
770
770
            delete[] (*pmasp);
771
771
                *pmasp=NULL;
779
779
                *hi=NULL;
780
780
}
781
781
 
782
 
BOOL IfNeedGlobalRotate(NegList* root,int& skew)
 
782
Bool IfNeedGlobalRotate(NegList* root,int& skew)
783
783
{
784
784
 NegList* now=root;
785
785
 Rect16 Rc;
786
786
 int w;
787
787
 int h;
788
 
 BOOL fl_break=FALSE;
 
788
 Bool fl_break=FALSE;
789
789
 int modskew=skew;
790
790
 if(modskew<0)
791
791
         modskew=-modskew;
818
818
 w=pNegImage->Wide;
819
819
 h=pNegImage->Height;
820
820
 
821
 
 Word8* newlpdata=pNegImage->GetPmasp(&Rc);
 
821
 uchar* newlpdata=pNegImage->GetPmasp(&Rc);
822
822
 if(!newlpdata)
823
823
         return FALSE;
824
824
 
847
847
 Width=Rc.right+1;
848
848
 const int bytewide=(Width+7)/8;
849
849
 int i;
850
 
 Word8* lptemp = new Word8[bytewide];
 
850
 uchar* lptemp = new uchar[bytewide];
851
851
 if(!lptemp)
852
852
 {
853
853
         delete pRotImage;
854
854
         return FALSE;
855
855
 }
856
856
 
857
 
 Word8* to=newlpdata;
858
 
 Word8* from=newlpdata+(Height-1)*bytewide;
 
857
 uchar* to=newlpdata;
 
858
 uchar* from=newlpdata+(Height-1)*bytewide;
859
859
 for(i=Height>>1;i>0;i--,to+=bytewide,from-=bytewide)
860
860
 {
861
861
         memcpy(lptemp,to,bytewide);
879
879
 nIncline=skew;
880
880
 while(now)
881
881
 {
882
 
//Andrey 06.03.2003 - ��-����� ��� �����: �� ����� left ����������� ��� �������� �� ��������� ������������� ����
 
882
//Andrey 06.03.2003 - по-моему тут глюки: не может left уменьшиться при довороте на небольшой положительный угол
883
883
/*  if(nIncline>=0)
884
884
  {
885
885
          now->neg.pRc->left-=pNegImage->rotate.begx[now->neg.pRc->top];
888
888
                  now->neg.pRc->left=0;
889
889
          if(now->neg.pRc->right>=pNegImage->Wide)
890
890
                  now->neg.pRc->right=pNegImage->Wide-1;
891
 
          now->neg.pRc->top-=(Int16)((int)(now->neg.pRc->right)*nIncline/2048);
892
 
          now->neg.pRc->bottom-=(Int16)((int)(now->neg.pRc->left)*nIncline/2048);
 
891
          now->neg.pRc->top-=(int16_t)((int)(now->neg.pRc->right)*nIncline/2048);
 
892
          now->neg.pRc->bottom-=(int16_t)((int)(now->neg.pRc->left)*nIncline/2048);
893
893
          if(now->neg.pRc->top<0)
894
894
                  now->neg.pRc->top=0;
895
895
          if(now->neg.pRc->bottom>=pNegImage->Height)
919
919
                  now->neg.pRc->left=0;
920
920
          if(now->neg.pRc->right>=pNegImage->Wide)
921
921
                  now->neg.pRc->right=pNegImage->Wide-1;
922
 
          now->neg.pRc->top-=(Int16)((int)(now->neg.pRc->left)*nIncline/2048);
923
 
          now->neg.pRc->bottom-=(Int16)((int)(now->neg.pRc->right)*nIncline/2048);
 
922
          now->neg.pRc->top-=(int16_t)((int)(now->neg.pRc->left)*nIncline/2048);
 
923
          now->neg.pRc->bottom-=(int16_t)((int)(now->neg.pRc->right)*nIncline/2048);
924
924
          if(now->neg.pRc->top<0)
925
925
                  now->neg.pRc->top=0;
926
926
          if(now->neg.pRc->bottom>=pNegImage->Height)
961
961
 now=root;
962
962
 while(now)
963
963
 {
964
 
//Andrey 06.03.2003 - ��-����� ��� �����: �� ����� left ����������� ��� �������� �� ���������� �������������� �����
 
964
//Andrey 06.03.2003 - по-моему тут глюки: не может left уменьшиться при отвороте от небольшого положительного угола
965
965
/*  if(nIncline>=0)
966
966
  {
967
967
          for(int i=0;i<now->neg.nRc;i++)
968
968
          {
969
 
           now->neg.pRc[i].top+=(Int16)((int)(now->neg.pRc[i].left)*nIncline/2048);
970
 
           now->neg.pRc[i].bottom+=(Int16)((int)(now->neg.pRc[i].right)*nIncline/2048);
 
969
           now->neg.pRc[i].top+=(int16_t)((int)(now->neg.pRc[i].left)*nIncline/2048);
 
970
           now->neg.pRc[i].bottom+=(int16_t)((int)(now->neg.pRc[i].right)*nIncline/2048);
971
971
           if(now->neg.pRc[i].left<0)
972
972
                  now->neg.pRc[i].left=0;
973
973
           if(now->neg.pRc[i].right>pNegImage->rotate.Rc.right)
995
995
  {
996
996
          for(int i=0;i<now->neg.nRc;i++)
997
997
          {
998
 
           now->neg.pRc[i].top+=(Int16)((int)(now->neg.pRc[i].left)*nIncline/2048);
999
 
           now->neg.pRc[i].bottom+=(Int16)((int)(now->neg.pRc[i].right)*nIncline/2048);
 
998
           now->neg.pRc[i].top+=(int16_t)((int)(now->neg.pRc[i].left)*nIncline/2048);
 
999
           now->neg.pRc[i].bottom+=(int16_t)((int)(now->neg.pRc[i].right)*nIncline/2048);
1000
1000
           now->neg.pRc[i].left-=pNegImage->rotate.begx[now->neg.pRc[i].top];
1001
1001
           now->neg.pRc[i].right-=pNegImage->rotate.begx[now->neg.pRc[i].bottom];
1002
1002
 
1047
1047
 }
1048
1048
}
1049
1049
 
1050
 
BOOL InitMyImage()
 
1050
Bool InitMyImage()
1051
1051
{
1052
1052
        Handle lpDIB;
1053
1053
        if(!CIMAGE_ReadDIB(ImageName,&lpDIB,1))
1066
1066
    const int bytewide=ctdib->GetLineWidthInBytes();
1067
1067
    const int num_str=ctdib->GetLinesNumber ();
1068
1068
        const int w=ctdib->GetImageWidth();
1069
 
    Word8* pmasp=(Word8*)(ctdib->GetPtrToBitFild());
 
1069
    uchar* pmasp=(uchar*)(ctdib->GetPtrToBitFild());
1070
1070
 
1071
1071
        pNegImage = new NegImage;
1072
1072
        if(!pNegImage)