コード例 #1
0
// --------------------------------------------------------------------------------------
void RedrawPrefsWindowList(WindowRef prefsWindow)
{
    ListHandle iconList;
    ListBounds visibleCells;
    SInt16 pixelDepth;
    Boolean isColorDevice;
    short row;
    Cell theCell;

    GetWindowProperty(prefsWindow, kAppSignature, kIconListTag, sizeof(ListHandle), NULL,
                      &iconList);
    GetListVisibleCells(iconList, &visibleCells);

    GetWindowDeviceDepthAndColor(prefsWindow, &pixelDepth, &isColorDevice);
    SetThemeBackground(kThemeBrushWhite, pixelDepth, isColorDevice);

    for (row = visibleCells.top; row < visibleCells.bottom; row++)	// redraw just the
    {   // visible cells
        SetPt(&theCell, 0, row);
        LDraw(theCell, iconList);
    }
}
コード例 #2
0
//                             ОДИН ЗАПУСК
// Подпрограмма фильтрации строк с вычисленным параметром фильтрации KHigS;
// -----------------------------------------------------------------------------
void GBitset::RepeatStringDetector() {
  int y,x,p,d,s;
  int MGilb,PGilb;
  int print=1;
  /// GAmp; амплитуда сигнала после 2х преобразований ГИЛБЕРТА.


			   BufHelp.assign(ncnr,0);

			   PGilb=KFStrok; // PGilb - параметр (ширина) преобразования ГИЛБЕРТА
//               p=KFStrok;     // KHigS - параметр фильтрации

			   MGilb=nrows;   // размер массива преобразования ГИЛБЕРТА
			  // KHigS=PGilb*4+8;  // KHigS - параметр фильтрации

			  // нормировка импульсной характеристики фильтра, т.е. импульсные
			  // характеристики фильтров разных порядков должны иметь одинаковые амплитуды.
			  s=sqrt((float)100*KHigS) ;
			  for ( y=0; y < nrows; y++ ){
				if( HStr[y]<4 ){ BufS[y]=0; } // Суммы меньше 8 пикселов считаются равными нолю.
				// <8 (4) пикселей - строки определяются начиная с 2 (1) букв
				else { BufS[y]=HStr[y]*s/7; } // ВАЖНО - сумма вдоль текста HStr[y] домножена на 4  (BufS[y]=4*HStr[y]*s/28;)
				  } // for y                  // BufS[y]=24*sqrt(HStr[y]*s/28);

			  // адаптивная фильтрация  H[y]
			  SP->filterHigh(BufS,KHigS);

			  // преобразование ГИЛБЕРТА 1 - BufT
			  filterGilbert(BufS,BufT, MGilb,PGilb);

#ifdef DEBUGLVL
if ( GrafT[1][5] ) {LDraw(BufT,1200,0x0000AA00);} // вызов функции рисования зеленый
#endif


			  // преобразование ГИЛБЕРТА 2 - BufR сигнал без постоянной составляющей
			  filterGilbert(BufT,BufR, MGilb,PGilb);

//// PolarCoordinates( BufT, BufR, 50000, 500, 200, 16, 0x0000AA00);

			   // увеличение градиента преобразования ГИЛБЕРТА
			   // в окрестности максимума исходной кривой H[y]
			   for (  y=6; y < nrows-6; y++ ){
						x=BufT[y]*BufS[y];
						if(x>=0) BufT[y] = sqrt((float)x);
						else     BufT[y] =-sqrt((float)-x);
				  }// for y
#ifdef DEBUGLVL
if ( GrafT[1][5] ) { LDraw(BufT,1100,0x0000AA00); } // вызов функции рисования зеленый
#endif

		// предворительное вычисление трех направляющих строки.Вычисление максимальнй
		// амплитуды (8 пиксемей от края печа не используются)
		d=0; NStrok=0; // GAmp=0;
		for ( y=8; y < nrows-8; y++ ){
		   // вычисление координат середины строки SAmp по максимому энергии
		   if( BufT[y]<=0 && BufT[y+1]>0 &&
			   BufT[y-2]< BufT[y]   && BufT[y+1]< BufT[y+3] &&
			   BufT[y-4]< BufT[y-2] && BufT[y+3]< BufT[y+5]
			 )
			   {  NStrok++;  /// BufHelp[y]=800;
//                 GAmp=BufR[y]/2; SAmp=BufS[y];
				 // вычисление 2 координат верха и низа строки по уровню GAmp=BufR[y]/2;
				 for ( p=y-4; BufR[p]<BufR[y]/2 && p>8 && p < nrows-8; p-- ){ }
					 HBuf[d]=0;        HBuf[d+1]=p; d+=2;   /// BufHelp[p]+=400;
				 for ( p=y+4; BufR[p]<BufR[y]/2 && p>8 && p < nrows-8; p++ ){ }
					 HBuf[d]=ncolumns; HBuf[d+1]=p; d+=2;   /// BufHelp[p]+=300;
				} // BufHelp[y]=400;
		}// for y
		// NStrok вычисленное колличество строк в печа

DT(" NStrok="<<NStrok);DM(END);

/*        // смещение направляющих строк в вверх и в низ на долю от ширины строки
               for(y=0; y < NStrok*4 && y<nrows; y+=4){
                   // смещение направляющий строки в вверх на одну пятую
                   HBuf[y+3]=HBuf[y+3]+(HBuf[y+3]-HBuf[y+1])/5;
                   // смещение направляющий строки в низ на одну треть
                   HBuf[y+1]=HBuf[y+1]-(HBuf[y+3]-HBuf[y+1])/5;
               }// for y
*/

       // Заполнение структур координатами строк
       // OCRclases.h  // ImageProcessor.cpp
	   strArray->resize(NStrok);   d=0;
       if(NStrok){
         for ( y=0; y < NStrok*4 && y<nrows-4; y+=4 ){
                 // x0,y0,x1,y1 координаты строк
				 strArray[0][d].x0=HBuf[y];   strArray[0][d].y0=HBuf[y+1];
				 strArray[0][d].x1=HBuf[y+2]; strArray[0][d].y1=HBuf[y+3];
				 strArray[0][d].stringFlag=1; // флаг cтроки  =1 (=0), cтрока состоит из букв (линии).
				 strArray[0][d].NLetter=0;    // примерная длинна строки (оценка)
				 d++;
				 // DM( " x0="<<wt.x0<< " y0="<<wt.y0<< " x1="<<wt.x1<< "
                 // y1="<<wt.y1<< "\n---\n");
         }// for y
       }
/* */

// x0,y0,x1,y1
// x0,y0 координаты левого нижнего угла прямоугольника строки (глифа, слога, буквы).
// x1,y1координаты правого верхнего угла прямоугольника строки (глифа, слога, буквы).
//cout<<" @@@@ NStrok="<<NStrok<<" strArray[0][ns].y0="<<strArray[0][0].y0<<" strArray[0][ns].y1="<<strArray[0][0].y1<<endl;

	

/// Дополнение структуры координатами середины между строк и производными от них
    int ns, LimY0, LimY1;
//  strArray->resize(NStrok);
    if( NStrok >=1 ){

         for ( d=0; d < NStrok && d<nrows-4; d++ ){
                 // h высота строки
                 strArray[0][d].h=(strArray[0][d].y1-strArray[0][d].y0);
                 // vLim минимальная длинна вектора
                 strArray[0][d].vLim=strArray[0][d].h*2; // *3/2 сами вектора домножены на *10
         }// for d

         for ( d=0; d < NStrok-1 && d<nrows-4; d++ ){ //
                 // LimY0  верхний лимит строки
                 strArray[0][d].LimY0=(strArray[0][d].y0 + strArray[0][d].y1
                    + strArray[0][d+1].y0 + strArray[0][d+1].y1)/4;
                 // LimY1  нижний лимит строки
                 strArray[0][d+1].LimY1=strArray[0][d].LimY0;
         }// for d
/**/
   } // if(NStrok)

   // отработка самой верхней и самой нижней строки
   // для получения лимитов строк (середины между строками)
   if( NStrok >=2 ){
        ns=NStrok-1;
          // самый нижний лимит
          LimY1=strArray[0][0].y0  + strArray[0][0].y1  - strArray[0][1].LimY1;
          // самый верхний лимит
          LimY0=strArray[0][ns].y1 + strArray[0][ns].y0 - strArray[0][ns-1].LimY0;
          // проверка выхода за граници изображения
          if ( LimY1 < 2 ) LimY1=1;      if ( LimY0 > nrows-2 ) LimY0=nrows-1;
          strArray[0][0].LimY1=LimY1;    strArray[0][ns].LimY0=LimY0;

        /// ТАБЛИЦА
        // DM(END); DM(strArray[0][d].y0<<"\t"); if (y%10==0)DM(END); DM(END);
   }
	
   if( NStrok ==1 ){
	   LimY0=strArray[0][0].y0 - (strArray[0][0].y0 - strArray[0][0].y1)*2;
	   // проверка выхода за граници изображения
	   if ( LimY0<0 ) LimY0=0;
	   strArray[0][0].LimY0=LimY0;
	   
   }
/**/



  // ВИЗУАЛИЗАЦИЯ лимитов строк (черная)
/*  int delta1=strArray[0][0].LimY1;     int delta0=strArray[0][ns].LimY0;
  for(x=0; x < ncolumns-1; x++) {
  for (y=delta1; y<12+delta1; y++)drawData[0][y][x]*=0.1; // 0.8*ncolumns;
  for (y=delta0; y<6 +delta0; y++)drawData[0][y][x]*=0.1; // 0.8*ncolumns;
  }
*/


#ifdef DEBUGLVL
if ( GrafT[1][5] ) {
/*					  // ВИЗУАЛИЗАЦИЯ цифровая
		DM(END);  DM(nrows<<" nrows "); DM(END); DM(END);
  DM(KFStrok<<" KFStrok "); DM(KHigS<<" KHigS "); DM(NStrok<<" NStrok ");
							 DM(END); DM(END);
*/

/*			// ВИЗУАЛИЗАЦИЯ цифровая, координаты строк, медленный вывод
			  DM(END);
			  for ( y=0; y < NStrok*4;  y++ ){   // ТАБЛИЦА
				DM(HBuf[y]<<"\t"); if ((y+1)%10==0)DM(END);
				  }//for y
			  DM(END); DM(END);
*/

					 // ВИЗУАЛИЗАЦИЯ аналоговая
LDraw(BufS,1350,0x000000FF);       // вызов функции рисования красный
LDraw(BufR,1200,0x000000FF);       // вызов функции рисования красный
//LDraw(BufHelp,1100,0x000000FF);  // вызов функции рисования красный
LineVertical(1200, 0x0000AA00);    // зеленый
//sm =(KHigS*8+1250);
//LDraw(BufR,sm,0x00AA0011);     // вызов функции рисования темно синий
/* */
/*
                      /// ТАБЛИЦА лимитов строк
            DM(END);
            for ( y=0; y < NStrok; y++  ){
DM(strArray[0][y].LimY0<<"\t"); if (y%10==0)DM(END);  /// ТАБЛИЦА
              }//for y
            DM(END);

                      /// ТАБЛИЦА лимитов строк
            DM(END);
            for ( y=0; y < NStrok; y++  ){
DM(strArray[0][y].LimY1<<"\t"); if (y%10==0)DM(END);
              }//for y
            DM(END);
*/

					  // ВИЗУАЛИЗАЦИЯ аналоговая
// получение координат верхнего LimY0 и нижнего LimY1 лимита строки из структуры
/* for (int m=0; m <NStrok; m++ ){   //  m+=2
   for( int x =0; x <ncolumns; x++ ){
	  drawData[0][strArray[0][m].LimY0][x]*=0.1;
	  drawData[0][strArray[0][m].LimY0+1][x]*=0.1;
	  drawData[0][strArray[0][m].LimY1][x]*=0.1;
	  drawData[0][strArray[0][m].LimY1+1][x]*=0.1;
   }
  ////  DM(strArray[0][m].LimY1<<"LimY1  ");  DM(strArray[0][m].LimY0<<"LimY0  ");
 } // m
 ////   DM(END);
 */

} // if ( GrafT[1][5] )


 // Визуализация аналоговая  прямоугольников в структурах //
if ( GrafT[1][6] ) { stringDraw(0x0000AA00); } // зеленый
#endif


/**/
 //strArray[0][ns].LimY0 = 1000;
 //strArray[0][0].LimY1=2000;
}//_____________________________________________________________________________