// Arithmetic routines
double *camAllocateVector(int nl, int nh)
{
double *v;
v=(double *)malloc((unsigned)(nh - nl + 1) * sizeof(double));
if (!v) {
camError("camAllocateVector", "Memory allocation failure");
return NULL;
}
return v-nl;
}
// Binary images processing
// camMonadicArithm1U : source is n bits, dest is one bit
int camMonadicArithm1U(CamImage *source, CamImage *dest, CamArithmParams *params)
{
int x,y;
int width,height;
CAM_PIXEL *srcptr,*cpsrcptr;
CAM_BIT_BLOCK *dstptr,*cpdstptr;
CAM_BIT_BLOCK bit_block,eol_block;
int sol_offset,bit_offset;
int c1=params->c1;
int c2=params->c2;
int c3=params->c3;
CamInternalROIPolicyStruct iROI;
CAM_CHECK_ARGS(camMonadicArithm,(source->depth&CAM_DEPTH_MASK)<=(sizeof(CAM_PIXEL)*8));
CAM_CHECK_ARGS(camMonadicArithm,(source->depth&CAM_DEPTH_MASK)>=8);
// ROI (Region Of Interest) management
CAM_CHECK(camMonadicArithm,camInternalROIPolicy(source, dest, &iROI, 0));
srcptr=(CAM_PIXEL*)iROI.srcptr;
width=iROI.srcroi.width;
height=iROI.srcroi.height;
if (dest->roi) {
sol_offset=dest->roi->xOffset%CAM_BIT_BLOCK_SIZE;
dstptr=(CAM_BIT_BLOCK*)(dest->imageData+dest->roi->yOffset*dest->widthStep)+(dest->roi->xOffset/CAM_BIT_BLOCK_SIZE);
} else {
sol_offset=0;
dstptr=(CAM_BIT_BLOCK*)dest->imageData;
}
switch(params->operation) {
case CAM_ARITHM_ABS:
camError("camMonadicArithm","CAM_ARITHM_ABS operation is not possible on binary images");
break;
case CAM_ARITHM_SELECT:
if (c2) {
FOREACH_PIXEL {
STORE_BIT((int)(*srcptr==c1));
} END_FOREACH_PIXEL
} else {
FOREACH_PIXEL {
STORE_BIT((int)(*srcptr!=c1));
} END_FOREACH_PIXEL
}
break;
case CAM_ARITHM_THRESHOLD:
if (c2) {
FOREACH_PIXEL {
STORE_BIT((int)(*srcptr<c1));
} END_FOREACH_PIXEL
} else {
int camSVD(double **a, int m, int n, double w[], double **v)
{
int flag, i, its, j, jj, k, l, nm;
double anorm, c, f, g, h, s, scale, x, y, z, *rv1;
int camMinTmp1, camMinTmp2;
double camMaxTmp1, camMaxTmp2;
rv1=camAllocateVector(1,n);
g=scale=anorm=0.0;
for (i=1;i<=n;i++) {
l=i+1;
rv1[i]=scale*g;
g=s=scale=0.0;
if (i <= m) {
for (k=i;k<=m;k++) scale += fabs(a[k][i]);
if (scale) {
for (k=i;k<=m;k++) {
a[k][i] /= scale;
s += a[k][i]*a[k][i];
}
f=a[i][i];
g = -CAM_SIGN(sqrt(s),f);
h=f*g-s;
a[i][i]=f-g;
for (j=l;j<=n;j++) {
for (s=0.0,k=i;k<=m;k++) s += a[k][i]*a[k][j];
f=s/h;
for (k=i;k<=m;k++) a[k][j] += f*a[k][i];
}
for (k=i;k<=m;k++) a[k][i] *= scale;
}
}
w[i]=scale*g;
g=s=scale=0.0;
if (i <= m && i != n) {
for (k=l;k<=n;k++) scale += fabs(a[i][k]);
if (scale) {
for (k=l;k<=n;k++) {
a[i][k] /= scale;
s += a[i][k]*a[i][k];
}
f=a[i][l];
g = -CAM_SIGN(sqrt(s),f);
h=f*g-s;
a[i][l]=f-g;
for (k=l;k<=n;k++) rv1[k]=a[i][k]/h;
for (j=l;j<=m;j++) {
for (s=0.0,k=l;k<=n;k++) s += a[j][k]*a[i][k];
for (k=l;k<=n;k++) a[j][k] += s*rv1[k];
}
for (k=l;k<=n;k++) a[i][k] *= scale;
}
}
anorm=CAM_DMAX(anorm,(fabs(w[i])+fabs(rv1[i])));
}
for (i=n;i>=1;i--) {
if (i < n) {
if (g) {
for (j=l;j<=n;j++) v[j][i]=(a[i][j]/a[i][l])/g;
for (j=l;j<=n;j++) {
for (s=0.0,k=l;k<=n;k++) s += a[i][k]*v[k][j];
for (k=l;k<=n;k++) v[k][j] += s*v[k][i];
}
}
for (j=l;j<=n;j++) v[i][j]=v[j][i]=0.0;
}
v[i][i]=1.0;
g=rv1[i];
l=i;
}
for (i=CAM_IMIN(m,n);i>=1;i--) {
l=i+1;
g=w[i];
for (j=l;j<=n;j++) a[i][j]=0.0;
if (g) {
g=1.0/g;
for (j=l;j<=n;j++) {
for (s=0.0,k=l;k<=m;k++) s += a[k][i]*a[k][j];
f=(s/a[i][i])*g;
for (k=i;k<=m;k++) a[k][j] += f*a[k][i];
}
for (j=i;j<=m;j++) a[j][i] *= g;
} else for (j=i;j<=m;j++) a[j][i]=0.0;
++a[i][i];
}
for (k=n;k>=1;k--) {
for (its=1;its<=30;its++) {
flag=1;
for (l=k;l>=1;l--) {
nm=l-1;
if ((double)(fabs(rv1[l])+anorm) == anorm) {
flag=0;
break;
}
if ((double)(fabs(w[nm])+anorm) == anorm) break;
}
if (flag) {
c=0.0;
s=1.0;
for (i=l;i<=k;i++) {
f=s*rv1[i];
rv1[i]=c*rv1[i];
if ((double)(fabs(f)+anorm) == anorm) break;
g=w[i];
h=camPythag(f,g);
w[i]=h;
h=1.0/h;
c=g*h;
s = -f*h;
for (j=1;j<=m;j++) {
y=a[j][nm];
z=a[j][i];
a[j][nm]=y*c+z*s;
a[j][i]=z*c-y*s;
}
}
}
z=w[k];
if (l == k) {
if (z < 0.0) {
w[k] = -z;
for (j=1;j<=n;j++) v[j][k] = -v[j][k];
}
break;
}
if (its == 100) {
camError("camSVD", "No convergence after 100 iterations");
return 0;
}
x=w[l];
nm=k-1;
y=w[nm];
g=rv1[nm];
h=rv1[k];
f=((y-z)*(y+z)+(g-h)*(g+h))/(2.0*h*y);
g=camPythag(f,1.0);
f=((x-z)*(x+z)+h*((y/(f+CAM_SIGN(g,f)))-h))/x;
c=s=1.0;
for (j=l;j<=nm;j++) {
i=j+1;
g=rv1[i];
y=w[i];
h=s*g;
g=c*g;
z=camPythag(f,h);
rv1[j]=z;
c=f/z;
s=h/z;
f=x*c+g*s;
g = g*c-x*s;
h=y*s;
y *= c;
for (jj=1;jj<=n;jj++) {
x=v[jj][j];
z=v[jj][i];
v[jj][j]=x*c+z*s;
v[jj][i]=z*c-x*s;
}
z=camPythag(f,h);
w[j]=z;
if (z) {
z=1.0/z;
c=f*z;
s=h*z;
}
f=c*g+s*y;
x=c*y-s*g;
for (jj=1;jj<=m;jj++) {
y=a[jj][j];
z=a[jj][i];
a[jj][j]=y*c+z*s;
a[jj][i]=z*c-y*s;
}
}
rv1[l]=0.0;
rv1[k]=f;
w[k]=x;
}
}
camFreeVector(rv1,1,n);
return 1;
}
int camLoadBitmapFont(CamBitmapFont *font, char *filename)
{
CamImage bitmap;
CamROI roi;
int delimiter_color,x,i,px;
unsigned char *ptr;
CamTable clusters,LUT;
CamRLEImage temp;
char s[256];
if (!camLoadBMP(&bitmap,filename)) {
sprintf(s,"Couldn't load bitmap file %s.",filename);
camError("camBitmapFontLoad",s);
return 0;
}
font->height=bitmap.height-1;
// Try to figure out how many letters are there in this font image
font->nb_chars=0;
font->first_char=33;
#define GET_COLOR_PIXEL(ptr) (((int)*(ptr))+(((int)*((ptr)+1))<<8)+(((int)*((ptr)+2))<<16))
ptr=bitmap.imageData;
delimiter_color=GET_COLOR_PIXEL(ptr);
for (x=0;x<bitmap.width;x++,ptr+=3) {
if (GET_COLOR_PIXEL(ptr)==delimiter_color) font->nb_chars++;
}
// OK, now we can allocate memory for these
font->masks=(CamRLEImage*)malloc(sizeof(CamRLEImage)*font->nb_chars);
font->letters=(CamImage*)malloc(sizeof(CamImage)*font->nb_chars);
// Let's prepare the data for font loading
ptr=bitmap.imageData;
px=0;
roi.coi=0;
bitmap.roi=&roi;
clusters.size=12;
for (i=0;i<6;i++) clusters.t[i*2]=clusters.t[i*2+1]=*(ptr+i);
i=0;
LUT.size=3;
LUT.t[0]=1; LUT.t[1]=0; LUT.t[2]=0;
camRLEAllocate(&temp,10000);
// Ready. Let's go for all the characters
for (x=1,ptr+=3;x<bitmap.width;x++,ptr+=3) {
if (GET_COLOR_PIXEL(ptr)==delimiter_color) {
// We've found the next character
camRLEAllocate(&font->masks[i],(x-px)*font->height+2);
camAllocateRGBImage(&font->letters[i],x-px,font->height);
roi.xOffset=px; roi.yOffset=1;
roi.width=x-px;
roi.height=font->height;
camCopy(&bitmap,&font->letters[i]);
camRLEEncodeColor(&bitmap,&temp,&clusters);
camRLEApplyLUT(&temp,&font->masks[i],&LUT);
px=x;
i++;
}
}
// We've found the last character
camRLEAllocate(&font->masks[i],(x-px)*font->height+2);
camAllocateRGBImage(&font->letters[i],x-px,font->height);
roi.xOffset=px; roi.yOffset=1;
roi.width=x-px;
roi.height=font->height;
camCopy(&bitmap,&font->letters[i]);
camRLEEncodeColor(&bitmap,&temp,&clusters);
camRLEApplyLUT(&temp,&font->masks[i],&LUT);
// Set the masks to all letters
for (i=0;i<font->nb_chars;i++) {
font->letters[i].mask=&font->masks[i];
}
camDeallocateImage(&bitmap);
camRLEDeallocate(&temp);
return 1;
}
