DOUBLE analyze()
{
INT **number , i , net , net1 , net2 , num , cell ;
INT *count , different , cnum , c2num , *arraynet ;
INT num_nets , tot_cels ;
DOUBLE C , C1 , C2 , C3 , wireRatio ;
PINBOXPTR pinptr ;
INT comparex() ;
DOUBLE weight_past_runs( /* wireRatio */ ) ;
count = (INT *) Ysafe_malloc( (1 + numcellsG) * sizeof( INT ) ) ;
number = (INT **) Ysafe_malloc( (1 + numnetsG) * sizeof( INT *) ) ;
howmanyS = (INT *) Ysafe_malloc( (1 + numnetsG) * sizeof( INT ) ) ;
arraynet = (INT *) Ysafe_malloc( (1 + numnetsG) * sizeof( INT ) ) ;
for( net = 0 ; net <= numnetsG ; net++ ) {
number[net] = (INT *) Ysafe_malloc( (1 + numcellsG) * sizeof(INT) ) ;
}
for( net = 1 ; net <= numnetsG ; net++ ) {
for( cell = 0 ; cell <= numcellsG ; cell++ ) {
count[cell] = 0 ;
number[net][cell] = 0 ;
}
for( pinptr=netarrayG[net]->pins;pinptr; pinptr = pinptr->next ){
if( pinptr->cell <= numcellsG ) {
count[pinptr->cell] = 1 ;
}
}
/*
* I would like to find the number of distinct nets
*/
for( cell = 1 ; cell <= numcellsG ; cell++ ) {
if( count[cell] == 1 ) {
number[net][ ++number[net][0] ] = cell ;
}
}
}
/* ********************************************************** */
num_nets = 0 ;
tot_cels = 0 ;
for( net1 = 1 ; net1 <= numnetsG ; net1++ ) {
if( number[net1][0] <= 1 ) {
continue ;
}
num_nets++ ;
tot_cels += number[net1][0] ;
}
OUT1("\n\n*************************************\n");
OUT2("AVERAGE NUMBER OF CELLS PER NET: %f\n",
( (DOUBLE) tot_cels / (DOUBLE) num_nets ) ) ;
OUT1("*************************************\n\n\n");
/* ********************************************************** */
for( net1 = 1 ; net1 <= numnetsG ; net1++ ) {
if( number[net1][0] == 0 ) {
howmanyS[net1] = 0 ;
continue ;
}
if( number[net1][0] == 1 ) {
number[net1][0] = 0 ;
howmanyS[net1] = 0 ;
continue ;
}
howmanyS[net1] = 1 ;
for( net2 = net1 + 1 ; net2 <= numnetsG ; net2++ ) {
if( number[net2][0] != number[net1][0] ) {
continue ;
}
different = 0 ;
for( i = 1 ; i <= numcellsG ; i++ ) {
if( number[net2][i] != number[net1][i] ) {
different = 1 ;
break ;
}
}
if( ! different ) {
number[net2][0] = 0 ;
howmanyS[net1]++ ;
}
}
}
arraynet[0] = 0 ;
for( net = 1 ; net <= numnetsG ; net++ ) {
if( howmanyS[net] <= 0 ) {
continue ;
}
arraynet[ ++arraynet[0] ] = net ;
}
num = arraynet[0] ;
arraynet[0] = arraynet[ arraynet[0] ] ;
Yquicksort( (char *) arraynet , num , sizeof( INT ), comparex ) ;
/* sorted: most occurrences first */
num = 0 ;
cnum = 0 ;
c2num = 0 ;
for( net = 1 ; net <= numnetsG ; net++ ) {
if( number[net][0] > 0 ) {
cnum += number[net][0] - 1 ;
c2num += number[net][0] ;
num++ ;
}
}
C = (DOUBLE) num / (DOUBLE) numcellsG ;
C1 = (DOUBLE) cnum / (DOUBLE) num ;
C2 = (DOUBLE) c2num / (DOUBLE) num ;
C3 = (DOUBLE) cnum / (DOUBLE)(numcellsG - 1) ;
OUT1("\n\n\n**********************************************\n\n");
OUT1("The average number of distinct nets per cell is\n");
OUT2("given by: %6.2f\n\n", C );
OUT1("The average number of cells per net is\n");
OUT2("given by: %6.2f\n\n", C2 );
OUT1("The average number of other cells per net is\n");
OUT2("given by: %6.2f\n\n", C1 );
OUT1("The ratio of total cells specified per net to\n");
OUT2("numcells is given by: %6.2f\n\n", C3 );
OUT1("The average number of cells connected to a cell is\n");
OUT2("given by: %6.2f\n\n", C * C1 );
OUT1("**********************************************\n\n\n");
wireRatio = EXPECTEDWIRERATIO ;
OUT2("Expected Wire Reduction Relative to Random:%6.2f\n\n",wireRatio);
FLUSHOUT();
wireRatio = weight_past_runs( wireRatio ) ;
sprintf( YmsgG,"\n\nWire ratio updated to:%4.2f\n\n", wireRatio ) ;
M( MSG, "analyze", YmsgG ) ;
return( wireRatio );
}
int main (int argc, char * const argv[])
{
// create all necessary instances
cvNamedWindow (WINDOW_NAME, CV_WINDOW_AUTOSIZE);
CvMemStorage* storage = cvCreateMemStorage(0);
assert (storage);
IplImage * backgroundx=NULL;
IplImage * backgrounds=NULL;
IplImage * current_frame=NULL;
IplImage * backgroundgray=NULL;
if (argc!=4) {
abort ();
}
else {
backgrounds=cvLoadImage(argv[2], 4);
backgroundx=cvLoadImage(argv[3], 4);
backgroundgray=cvLoadImage(argv[3], 0);
current_frame=cvLoadImage(argv[1],4);
if (backgroundx==NULL) {
abort();
}
}
//get background
cvShowImage (WINDOW_NAME, backgrounds);
//backgroundx=seam(backgroundx, backgrounds->width, backgrounds->height);
// get an initial frame and duplicate it for later work
IplImage * draw_image = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 3);
IplImage * get_image = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 3);
cvCopy(backgrounds, get_image, NULL);
int h,w;
// as long as there are images ...
for (w=0; w<=backgrounds->width; w++) {
for (h=0; h<=backgrounds->height; h++) {
uchar* p=&CV_IMAGE_ELEM(backgrounds,uchar,h,w*3);
uchar* x=&CV_IMAGE_ELEM(backgroundx,uchar,h,w*3);
uchar* q=&CV_IMAGE_ELEM(current_frame,uchar,h,w*3);
uchar* temp=&CV_IMAGE_ELEM(draw_image,uchar,h,w*3);
if (comparex(p,q)==1) {
copypoint(x,temp);
}
else {
copypoint(q,temp);
}
}
}
// just show the image
cvShowImage (WINDOW_NAME, draw_image);
// wait a tenth of a second for keypress and window drawing
int key = cvWaitKey (0);
if (key == 'q' || key == 'Q')
abort();
// be nice and return no error
return 0;
}
