TByteMatrix Class Reference

#include <bytematrix.h>

Inheritance diagram for TByteMatrix:

Collaboration diagram for TByteMatrix:

Public Member Functions
void	Add1 (long i, long j)
void	ClearAll (void)
void	ClearByte (long i, long j)
void	GetAngle (double *tgx, double *tgy)
int	GetByte (int type, long i, long j)
int	GetElement (int type, long i, long j)
TByteMatrix &	operator+= (TBitMatrix &TBit)
TByteMatrix &	operator+= (TByteMatrix &TByt)
TObjArray *	Pick8 (int type, int thr)
void	SetAngle (double tgx, double tgy)
void	SetByte (long i, long j, unsigned char byte=0xff)
	TByteMatrix ()
	TByteMatrix (long x_size, long y_size)
	TByteMatrix (long x_size, long y_size, double tgx, double tgy)
	TByteMatrix (TBaseMatrix &T)
virtual	~TByteMatrix ()
Public Member Functions inherited from TBaseMatrix
void	Adopt (unsigned char *mas, long rows, long columns)
long	GetSize (long *ix_size=NULL, long *iy_size=NULL)
void	Init (long ix_size, long iy_size)
void	MoveMatrix (long ud, long lr)
TBaseMatrix &	operator= (TBaseMatrix &T)
void	Print (int type)
void	ResetShift (void)
	TBaseMatrix ()
	TBaseMatrix (long ix_size, long iy_size)
	TBaseMatrix (TBaseMatrix &iT)
virtual	~TBaseMatrix ()

Protected Attributes
double	Tgx
double	Tgy
Protected Attributes inherited from TBaseMatrix
long	byteSize
unsigned char *	mas
long	shiftX
long	shiftY
long	xSize
long	ySize

Additional Inherited Members
Protected Member Functions inherited from TBaseMatrix
const unsigned char *	GetPointer (void)

Constructor & Destructor Documentation

TByteMatrix() [1/4]

TByteMatrix::TByteMatrix

(

)

                        :TBaseMatrix() {
//  TBaseMatrix();
/*  xSize=0;
    ySize=0;
    byteSize=0;
    mas = NULL;
 
    xSize=0;
    ySize=0;
    byteSize=0;
    mas = NULL;
    shiftX=0;
    shiftY=0;
    position = 0;
    NonZeroPoints = new TObjArray();
*/
}

TByteMatrix() [2/4]

TByteMatrix::TByteMatrix	(	long	x_size,
		long	y_size
	)

                                      :TBaseMatrix(x,y) {
//  TByteMatrix();
/*  xSize = x;
    ySize = y;
    long bitSize = xSize*ySize;
    byteSize = (long)(bitSize/8) + (bitSize%8)?1:0;
    mas = (unsigned char *)calloc(byteSize,sizeof(unsigned char));
 
    Init(x,y);
*/}

TByteMatrix() [3/4]

TByteMatrix::TByteMatrix	(	long	x_size,
		long	y_size,
		double	tgx,
		double	tgy
	)

                                                                            :TBaseMatrix(x_size,y_size)
{
//  Init(x_size,y_size);
    Tgx = tgx;
    Tgy = tgy;
}

TByteMatrix() [4/4]

TByteMatrix::TByteMatrix

(

TBaseMatrix &

T

)

                                      :TBaseMatrix(T)
{
/*  long xs,ys;
    T.GetSize(&xs,&ys);
    Init(xs,ys);
*/}

~TByteMatrix()

TByteMatrix::~TByteMatrix ( )

virtual

                          {
/*  if (imas) {
        free(imas);
        imas = NULL;
    }
    if (cmas) {
        free(cmas);
        cmas = NULL;
    }
    ixSize=0;
    iySize=0;
    ibyteSize=0;
 
    cxSize=0;
    cySize=0;
    cbyteSize=0;
*/}

Member Function Documentation

Add1()

void TByteMatrix::Add1	(	long	i,
		long	j
	)

{
    long byt = xSize * j + i;
    mas[byt]++;
/*  MyPoint *point = 0;
    int n = NonZeroPoints->GetEntries();
    for (int k=0; k<n; k++) {
        point = (MyPoint *)(NonZeroPoints->At(k));
        if ((point->x == i)&&(point->y == j)) return;
    }
    NonZeroPoints->Add(new MyPoint(i,j,0));
*/
}

ClearAll()

void TByteMatrix::ClearAll

(

void

)

{
    memset((void *)mas,0,byteSize);
//  NonZeroPoints->Delete();
}

ClearByte()

void TByteMatrix::ClearByte	(	long	i,
		long	j
	)

{
    long byt = xSize * j + i;
//  int byte = (int)(xSize/8)*j + (int)(i/8);
//  int bit_byte = i%8;
    mas[byt] &=0x00 ;
/*  MyPoint *point = 0;
    int n = NonZeroPoints->GetEntries();
    for (int k=0; k<n; k++) {
        point = (MyPoint *)(NonZeroPoints->At(k));
        if ((point->x == i)&&(point->y == j)) {
            delete NonZeroPoints->RemoveAt(k);
            NonZeroPoints->Compress();
            break;
        }
    }
*/
}

GetAngle()

void TByteMatrix::GetAngle	(	double *	tgx,
		double *	tgy
	)

{
    *tgx = Tgx;
    *tgy = Tgy;
}

GetByte()

int TByteMatrix::GetByte	(	int	type,
		long	i,
		long	j
	)

{
    long shi, shj, shx, shy;
    if (type==0) {
        shx = 0;
        shy = 0;
    }
    else if (type==1) {
        shx = shiftX;
        shy = shiftY;
    }
    else {
        cout<<"UNKNOWN GETBIT TYPE"<<endl;
        return 0;
    }
    shi = i - shx;
    shj = j - shy;
    if ((shi>=xSize)||(shj>=ySize)||(shi<0)||(shj<0)) return 0;
    long byte = xSize * shj + shi;
    return mas[byte];
}

GetElement()

int TByteMatrix::GetElement ( int  type, long  i, long  j  )

inlinevirtual

Implements TBaseMatrix.

{return GetByte(type,i,j);}

operator+=() [1/2]

TByteMatrix & TByteMatrix::operator+=

(

TBitMatrix &

TBit

)

{
    long xthis,ythis,x2,y2;
    GetSize(&xthis,&ythis);
    TBit.GetSize(&x2,&y2);
    long xs = (x2<xthis)?x2:xthis;
    long ys = (y2<ythis)?y2:ythis;
//  TByteMatrix* TByte = new TByteMatrix(xs,ys);
/*  long i,j;
    if (TBit.FirstPoint(1,&i,&j)) Add1(i,j);
    while (TBit.NextPoint(1,&i,&j)) {
        Add1(i,j);
    }
*/
    for (long j=0; j<ys; j++) {
        for (long i=0; i<xs; i++) {
            if (TBit.GetBit(1,i,j)) Add1(i,j);
        }
    }
 
    return *this;
}

operator+=() [2/2]

TByteMatrix & TByteMatrix::operator+=

(

TByteMatrix &

TByt

)

{
    long xthis,ythis,x2,y2;
    GetSize(&xthis,&ythis);
    TByt.GetSize(&x2,&y2);
    long xs = (x2<xthis)?x2:xthis;
    long ys = (y2<ythis)?y2:ythis;
//  TByteMatrix* TByte = new TByteMatrix(xs,ys);
/*  long i,j;
    if (TByt.FirstPoint(1,&i,&j)) 
        if (int b = TByt.GetByte(1,i,j)) SetByte(i,j,GetByte(0,i,j)+b);
    while (TByt.NextPoint(1,&i,&j)) {
        if (int b = TByt.GetByte(1,i,j)) SetByte(i,j,GetByte(0,i,j)+b);
    }
*/
    for (long j=0; j<ys; j++) {
        for (long i=0; i<xs; i++) {
            if (int b = TByt.GetByte(1,i,j)) SetByte(i,j,GetByte(0,i,j)+b);
        }
    }
    return *this;
}

Pick8()

TObjArray * TByteMatrix::Pick8	(	int	type,
		int	thr
	)

{
//This is a modified code from Valeri's FEDRA
    int xn[8] = { 1, -1, 0,  0, 1,  1, -1, -1 }; //pixel 3x3 suburbs
    int yn[8] = { 0,  0, 1, -1, 1, -1,  1, -1 };
    TObjArray* Ta = new TObjArray();
    long nc,nr;
    GetSize(&nc,&nr);
    int pix,pp,pix1;
 
//  printf("hist: %d %d\n",nc,nr);
//  int npeaks=0;
    int ic,ir,in;           // declare here to fix marazmatic eror messages of VC++
    for(ic=2; ic<nc-3; ic++) {
        for(ir=2; ir<nr-3; ir++) {
 
            pix = GetByte(type,ic,ir); 
            if( pix < thr)   goto NEXTPIX;
            pix1=pix+1;
 
            for(in=0; in<8; in++) {
                pp = GetByte(type, ic+xn[in], ir+yn[in] );
                if( pix1 <= pp ) goto NEXTPIX;          //it was <=
                SetByte(ic,ir,pix1);
            }
//      printf("peak8(%d,%d) =  %d\n",ic,ir,pix); 
        Ta->Add(new MyPoint(ic,ir,pix));
NEXTPIX:
        continue;
    }
  }
    return Ta;
}

SetAngle()

void TByteMatrix::SetAngle	(	double	tgx,
		double	tgy
	)

{
    Tgx = tgx;
    Tgy = tgy;
}

SetByte()

void TByteMatrix::SetByte	(	long	i,
		long	j,
		unsigned char	byte = 0xff
	)

{
    long byt = xSize * j + i;
//  int byte = (int)(xSize/8)*j + (int)(i/8);
//  int bit_byte = i%8;
    mas[byt] =byte ;
/*  MyPoint *point = 0;
    int n = NonZeroPoints->GetEntries();
    for (int k=0; k<n; k++) {
        point = (MyPoint *)(NonZeroPoints->At(k));
        if ((point->x == i)&&(point->y == j)) return;
    }
    NonZeroPoints->Add(new MyPoint(i,j,0));
*/
}

Member Data Documentation

Tgx

double TByteMatrix::Tgx

protected

Tgy

double TByteMatrix::Tgy

protected

---

The documentation for this class was generated from the following files:

• src/appl/bmatrix/bytematrix.h
• src/appl/bmatrix/bytematrix.cxx