www.pudn.com > CVPR12_SAS_code.zip > BgGlobalFc.cpp, change:2002-04-12,size:10415b

```/////////////////////////////////////////////////////////////////////////////
// Name:        BgGlobalFc.cpp
// Purpose:     global functions
// Author:      Bogdan Georgescu
// Modified by:
// Created:     06/22/2000
// Version:     v0.1
/////////////////////////////////////////////////////////////////////////////

#include <math.h>
#include <stdio.h>
#include <string.h>
#include "BgDefaults.h"
// !!! only MSV
#include <sys/timeb.h>
#include <time.h>

double bgSign(double x)
{
if (x>=0)
return 1.0;
return -1.0;
}

double factorial(double num)
{
if (num==0 || num==1)
return 1;
return (num * factorial(num - 1));
}

// return 0 - error
// return 1 - one real solution
// return 3 - three real solutions
int bgSolveCubic(double a, double b, double c, double d, double& s1, double& s2, double& s3)
{
double p, q;
double r, s, t, z;

// convert to canonical form
r = b/a;
s = c/a;
t = d/a;
p = s-(r*r)/3.0;
q = (2*r*r*r)/27.0-(r*s)/3.0+t;

double D, phi, R;
R = bgSign(q)*sqrt(fabs(p)/3.0);
D = pow(p/3.0,3)+pow(q/2,2);

if (p<0)
{
if (D<=0)
{
phi = acos(q/(2*R*R*R));
s1 = -2*R*cos(phi/3)-r/3;
s2 = -2*R*cos(phi/3+2*PI/3)-r/3;
s3 = -2*R*cos(phi/3+4*PI/3)-r/3;
return 3;
}
else
{
z = q/(2*R*R*R);
phi = log(z+sqrt(z*z-1));
s1 = -2*R*cosh(phi/3)-r/3;
return 1;
}
}
else
{
z = q/(2*R*R*R);
phi = log(z+sqrt(z*z+1));
s1 = -2*R*sinh(phi/3)-r/3;
return 1;
}

return 0;
}

inline int bgRound(double in_x)
{
return int(floor(in_x + 0.5));
}

inline int bgRoundSign(double in_x)
{
if (in_x>=0)
{
return ((int) (in_x + 0.5));
}
else
{
return ((int) (in_x - 0.5));
}
}

void bgSort(double* ra, int nVec)
{
unsigned long n, l, ir, i, j;
n = nVec;
double rra;

if (n<2)
return;

l = (n>>1)+1;
ir = n;
for (;;)
{
if (l>1)
{
rra = ra[(--l)-1];
}
else
{
rra = ra[ir-1];
ra[ir-1] = ra[1-1];
if (--ir==1)
{
ra[1-1] = rra;
break;
}
}
i = l;
j = l+l;
while (j<=ir)
{
if (j<ir && ra[j-1]<ra[j+1-1])
j++;
if (rra<ra[j-1])
{
ra[i-1] = ra[j-1];
i = j;
j <<= 1;
}
else
j = ir+1;
}
ra[i-1] = rra;
}
}

// rank in 0-1 range, 0 min, 1 max
// inplace sort vec
double bgMedian(double* vec, int nVec, double rank)
{
bgSort(vec, nVec);
int krank = int(floor(rank*nVec));
if (rank == 1)
krank = nVec-1;
return vec[krank];
}

double bgMedianToSigmaGaussian(double med)
{
return med * 1.482602219;
}

int write_pgm_image(const char *outfilename, unsigned char *image, int rows,
int cols, char *comment, int maxval)
{
FILE *fp;

/***************************************************************************
* Open the output image file for writing if a filename was given. If no
* filename was provided, set fp to write to standard output.
***************************************************************************/

if(outfilename == NULL) fp = stdout;
else{
if((fp = fopen(outfilename, "wb")) == NULL){
fprintf(stderr, "Error writing the file %s in write_pgm_image().\n",
outfilename);
return(0);
}
}

/***************************************************************************
* Write the header information to the PGM file.
***************************************************************************/

fprintf(fp, "P5\n%d %d\n", cols, rows);
if(comment != NULL)
if(strlen(comment) <= 70) fprintf(fp, "# %s\n", comment);
fprintf(fp, "%d\n", maxval);

/***************************************************************************
* Write the image data to the file.
***************************************************************************/

if(rows != fwrite(image, cols, rows, fp)){
fprintf(stderr, "Error writing the image data in write_pgm_image().\n");
if(fp != stdout) fclose(fp);
return(0);
}

if(fp != stdout) fclose(fp);
return(1);
}

void write_MATLAB_ASCII(char *filename, float *data, int rows, int cols)
{
FILE *fp	= fopen(filename, "wb");
int i,j;
for(i = 0; i < rows; i++)
{
for(j = 0; j < cols-1; j++)
{
fprintf(fp, "%10.6f ", data[i*rows+j]);
}
fprintf(fp, "%10.6f\n", data[i*rows+cols-1]);
}
fclose(fp);
}

/*
struct _timeb timestart;
struct _timeb timeend;
void timer_start()
{
_ftime( ×tart );
bgLog("timer start...\n");
}
void timer_stop()
{
_ftime( &timeend );

unsigned long seconds;
unsigned long milliseconds;
seconds = timeend.time - timestart.time;
long msdif;
msdif = timeend.millitm - timestart.millitm;
if (msdif > 0)
milliseconds = msdif;
else
{
seconds--;
milliseconds = (timeend.millitm + 1000) - timestart.millitm;
}

bgLog("timer stop, elapsed %d.%d seconds.\n", seconds, milliseconds);
}
*/
time_t timestart;
time_t timeend;
void timer_start()
{
timestart = clock();
bgLog("timer start...\n");
}
void timer_stop()
{
timeend = clock();
unsigned long seconds, milliseconds;
seconds = (timeend-timestart)/CLOCKS_PER_SEC;
milliseconds = ((100*(timeend-timestart))/CLOCKS_PER_SEC) - 100*seconds;
bgLog("timer stop, elapsed %d.%d seconds.\n", seconds, milliseconds);
}

/********************************************/
/*				Image Sampling				*/
/********************************************/

//zooms into an image
//pre :
//		- dest is the pre-allocated destination color image
//		- src is the (w x h) source color image
//		- zconst is an integer zoom constant from that is >= 1
//		- interpolate is a flag that determines if interpolation
//		  should occur
//post: the src image has been zoomed by (zconst)x and stored into dest
void bgZoomIn(unsigned char **dest, unsigned char *src, int w, int h, int zconst, bool interpolate)
{

//if dest or src is NULL or zconst is < 1 exit
if((!(*dest))||(!src)||(zconst < 1))
return;

//if zconst = 1 then copy the image contents and return
if(zconst == 1)
{
memcpy(*dest, src, 3*w*h*sizeof(unsigned char));
return;
}

//calculate new image dimension
w	*= zconst;
h	*= zconst;

//copy image data from source image to destination image

//******************************************************//

unsigned char *dptr	= (*dest);

int i, j, x, y, dp, offset, factor, index;
index = 0;
//zconst does not divide evenly into image width
if(factor = w%zconst)
{
for(j=0; j<(h-zconst); j+=zconst)
{
for(i=0; i<(w-zconst); i+=zconst)
{
dp	= 3*(j*w+i);
for(y=0; y<zconst; y++)
{
for(x=0; x<zconst; x++)
{
offset	= 3*(y*w+x);
dptr[dp+offset  ]	= src[index  ];
dptr[dp+offset+1]	= src[index+1];
dptr[dp+offset+2]	= src[index+2];
}
}

//next data point
index	+= 3;
}

dp	= 3*(j*w+i);
for(y=0; y<(zconst-factor-1); y++)
{
for(x=0; x<(zconst-factor-1); x++)
{
offset	= 3*(y*w+x);
dptr[dp+offset  ]	= src[index  ];
dptr[dp+offset+1]	= src[index+1];
dptr[dp+offset+2]	= src[index+2];
}
}

//next data point
index	+= 3;
}
}
//zconst does divide evenly into image width
else
{
for(j=0; j<(h-zconst); j+=zconst)
{
for(i=0; i<(w); i+=zconst)
{
dp	= 3*(j*w+i);
for(y=0; y<zconst; y++)
{
for(x=0; x<zconst; x++)
{
offset	= 3*(y*w+x);
dptr[dp+offset  ]	= src[index  ];
dptr[dp+offset+1]	= src[index+1];
dptr[dp+offset+2]	= src[index+2];
}
}

//next data point
index	+= 3;
}
}
}

//consider last row of image
factor	= h%zconst;
dp		= 3*(h-zconst)*(w);
for(i=0; i<(w); i+=zconst)
{
for(y=0; y<(zconst-factor); y++)
{
for(x=0; x<(zconst-factor); x++)
{
offset	= 3*(y*w+x);
dptr[dp+offset  ]	= src[index  ];
dptr[dp+offset+1]	= src[index+1];
dptr[dp+offset+2]	= src[index+2];
}
}
//next data point
dp		+= zconst*3;
index	+= 3;
}

//******************************************************//

//done.
return;

}

//zooms out of an image
//pre :
//		- dest is the pre-allocated destination color image
//		- src is the (w x h) source color image
//		- zconst is an integer zoom constant from that is >= 1
//		- interpolate is a flag that determines if interpolation
//		  should occur
//post: the src image has been zoomed by (1/zconst)x and stored into dest
void bgZoomOut(unsigned char **dest, unsigned char *src, int w, int h, int zconst, bool interpolate)
{

//if dest or src is NULL or zconst is <= 1 exit
if((!(*dest))||(!src)||(zconst <= 1))
return;

//copy image data from source image to destination image

//******************************************************//

unsigned char *dptr	= (*dest);

int i, j, dp, index;
index = 0;
for(j=0; j<h; j+=zconst)
{
for(i=0; i<w; i+=zconst)
{
dp	= 3*(j*w+i);
dptr[index  ]	= src[dp  ];
dptr[index+1]	= src[dp+1];
dptr[index+2]	= src[dp+2];

//next data point
index	+= 3;
}
}

//******************************************************//

//done.
return;

}

/************************************/
/*       Filename Manipulation      */
/************************************/

//adds an extension (label) to a filename
{
//allocate memory for new filename
char *new_filename	= new char [strlen(*filename) + strlen(label) + 1], ext[5];

//copy filename
strcpy(new_filename, *filename);

//get extension of filename (e.g. '.txt')
char *pdest = strchr(new_filename, '.');
strcpy(ext, pdest);

//place filename label at the end of the filename
//followed by extension...
strcpy(pdest, label);
strcat(new_filename, ext);

//delete old filename and replace it with new one...
delete *filename;
(*filename)	= new_filename;

//done.
return;
}

```