VIDEO1.C

Go to the documentation of this file.

/* --
OpenFX version 1.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 OpenFX Development Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

/* video1.c */

static void SetColour(long *colour, HWND parent){
 CHOOSECOLOR cc;
 static COLORREF CustColours[16]={
   RGB(255,255,255), RGB(239,239,239), RGB(223,223,223), RGB(207,207,207),
   RGB(191,191,191), RGB(175,175,175), RGB(159,159,159), RGB(143,143,143),
   RGB(127,127,127), RGB(111,111,111), RGB( 95, 95, 95), RGB( 79, 79, 79),
   RGB( 63, 63, 63), RGB( 47, 47, 47), RGB( 31, 31, 31), RGB( 15, 15, 15) };
 cc.lStructSize=sizeof(CHOOSECOLOR);
 cc.hwndOwner=parent;
 cc.rgbResult=RGB((BYTE)colour[0],(BYTE)colour[1],(BYTE)colour[2]);
 cc.lpCustColors=(LPDWORD)CustColours;
 cc.Flags= CC_FULLOPEN | CC_RGBINIT;
 cc.lCustData=(DWORD)0;
 if(ChooseColor(&cc)){
   colour[0]=(unsigned char)GetRValue(cc.rgbResult);
   colour[1]=(unsigned char)GetGValue(cc.rgbResult);
   colour[2]=(unsigned char)GetBValue(cc.rgbResult);
 }
}

/* h is 0->360  s and v are 0-1 */
void Hsv2Rgb(double h, double s, double v,
             unsigned char *r, unsigned char *g, unsigned char *b){
 double rr,gg,bb,hh,ss,vv,maxcol,mincol;
 hh=(double)h; ss=(double)s; vv=(double)v;
 mincol=vv*(1.0-ss);
 if(hh <= 120.0){bb=mincol;
   if(hh <=  60){rr=vv; gg=mincol+hh*(vv-mincol)/(120.0-hh);}
   else         {gg=vv; rr=mincol+(120.0-hh)*(vv-mincol)/hh;}
 }
 else if( hh <= 240){rr=mincol;
   if(hh <= 180){gg=vv; bb=mincol+(hh-120.0)*(vv-mincol)/(240.0-hh);}
   else         {bb=vv; gg=mincol+(240.0-hh)*(vv-mincol)/(hh-120.0);}
 }
 else {gg=mincol;
   if(hh <= 300){bb=vv; rr=mincol+(hh-240.0)*(vv-mincol)/(360.0-hh);}
   else         {rr=vv; bb=mincol+(360.0-hh)*(vv-mincol)/(hh-240.0);}
 }
 rr = rr*255.0; *r=(unsigned char)min(255,rr);
 gg = gg*255.0; *g=(unsigned char)min(255,gg);
 bb = bb*255.0; *b=(unsigned char)min(255,bb);
}

void Rgb2Hsv(unsigned char r, unsigned char g, unsigned char b,
             double *h, double *s, double *v){
 double rr,gg,bb,hh,ss,vv,maxcol,mincol;
 rr=(double)r; gg=(double)g; bb=(double)b;
 rr /= 255.0; gg /= 255.0; bb /= 255.0;
 maxcol=max(rr,max(gg,bb));
 mincol=min(rr,min(gg,bb));
 vv=maxcol;
 if(maxcol == mincol){ss=0; hh=0;}
 else{
  ss=(maxcol-mincol)/maxcol;
  if(mincol == bb)
    hh = 120.0*(gg-mincol)/(rr+gg-2.0*mincol);
  else if(mincol == rr)
    hh = 120.0*(1.0+(bb-mincol)/(bb+gg-2.0*mincol));
  else
    hh = 120.0*(2.0+(rr-mincol)/(rr+bb-2.0*mincol));
 }
  *h=hh;
  *s=ss;
  *v=vv;
}

#ifndef PI
#define PI   3.1415926
#endif
#define PI2  PI/2

typedef double vector[3];

#define VECCOPY(a,b)    { b[0] = a[0]; b[1] = a[1]; b[2] = a[2]; }
#define INVERT(a)       { a[0] = -a[0]; a[1] = -a[1]; a[2] = -a[2]; }
#define VECSUB(a,b,c)   { c[0]=a[0]-b[0]; c[1]=a[1]-b[1]; c[2]=a[2]-b[2];}
#define VECSUM(a,b,c)   { c[0]=a[0]+b[0]; c[1]=a[1]+b[1]; c[2]=a[2]+b[2];}
#define VECSCALE(a,b,c) { c[0]=(a)*b[0]; c[1]=(a)*b[1]; c[2]=(a)*b[2];}
#define DOT(a,b)        ( (a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]) )
#define CROSS(v1,v2,r)  { \
                          r[0] = (v1[1]*v2[2]) - (v2[1]*v1[2]);  \
                          r[1] = (v1[2]*v2[0]) - (v1[0]*v2[2]);  \
                          r[2] = (v1[0]*v2[1]) - (v2[0]*v1[1]);  \
                        }
#define TOL 0.1

double hitpoint(vector n, vector x, vector y, vector pb, vector pf,
                double * a, double * b){
vector v1,p;
double mu,det,ve1,ve2,ve3,vp1,vp2,vp3,p1,p2,p3;
VECSUB(pb,pf,v1)
mu=DOT(n,v1);
VECSCALE(mu,n,v1)
VECSUM(pf,v1,p)
ve1=x[0]; ve2=x[1]; ve3=x[2];
vp1=y[0]; vp2=y[1]; vp3=y[2];
p1=p[0]-pb[0];
p2=p[1]-pb[1];
p3=p[2]-pb[2];
det=ve1*vp2-vp1*ve2 ;
if(det > TOL || det < -TOL)  /* e-10 appears not to work */
  {  *a=( vp2*p1-vp1*p2)/det;
     *b=(-ve2*p1+ve1*p2)/det;
     goto HIT;
  }
det=ve1*vp3-vp1*ve3 ;
if(det > TOL || det < -TOL)
  {  *a=( vp3*p1-vp1*p3)/det;
     *b=(-ve3*p1+ve1*p3)/det;
     goto HIT;
  }
det=ve2*vp3-vp2*ve3 ;
if(det > TOL || det < -TOL)
  {  *a=( vp3*p2-vp2*p3)/det;
     *b=(-ve3*p2+ve2*p3)/det;
     goto HIT;
  }
*a = *b = 0.0;
HIT:
return mu;
}

long MapFrom(vector p,
             vector Mp, vector Mdx, vector Mdy, vector Mn,
             fullscreenbuffer *S,
             long Xmax, long Ymax,
             double *red,double *green,double *blue){
 long  ialpha,ibeta,i,j,k,kl,kr,kt,kb,pixel;
 double alpha,beta,a,b,cc0,cc1,cc2,cl0,cl1,cl2,
           cr0,cr1,cr2,ct0,ct1,ct2,cb0,cb1,cb2;
 unsigned char *pP,*pR,*pG,*pB;
 j=Xmax;
 hitpoint(Mn,Mdx,Mdy,Mp,p,&alpha,&beta);
 if(alpha < -0.01 || alpha > 1.01)return -1;
 if(beta  < -0.02 || beta  > 1.02)return -1;
 alpha=Xmax*alpha;
 beta =Ymax*beta;
 ialpha = (long)alpha; alpha -= (double)ialpha;
 ibeta  = (long)beta;  beta  -= (double)ibeta;
 if(ialpha < 0 || ialpha >= Xmax)return 0;
 if(ibeta  < 0 || ibeta  >= Ymax)return 0;
 k =ibeta*j+ialpha;
 if(ialpha <   1)kl=k; else kl=k-1;
 if(ialpha > j-2)kr=k; else kr=k+1;
 if(ibeta  <   1)kb=k; else kb=k-j;
 if(ibeta  > Ymax-2)kt=k; else kt=k+j;
 cc0 = (double)S[k].R;  cc1 = (double)S[k].G;  cc2 = (double)S[k].B;
 cl0 = (double)S[kl].R; cl1 = (double)S[kl].G; cl2 = (double)S[kl].B;
 cr0 = (double)S[kr].R; cr1 = (double)S[kr].G; cr2 = (double)S[kr].B;
 ct0 = (double)S[kt].R; ct1 = (double)S[kt].G; ct2 = (double)S[kt].B;
 cb0 = (double)S[kb].R; cb1 = (double)S[kb].G; cb2 = (double)S[kb].B;
 if(alpha > 0.5){
   alpha = alpha-0.5;
   if(beta > 0.5){
     beta = beta-0.5;
     *red   = (cr0-cc0)*alpha+(ct0-cc0)*beta+cc0;
     *green = (cr1-cc1)*alpha+(ct1-cc1)*beta+cc1;
     *blue  = (cr2-cc2)*alpha+(ct2-cc2)*beta+cc2;
   }
   else{
     beta = 0.5-beta;
     *red   = (cr0-cc0)*alpha+(cb0-cc0)*beta+cc0;
     *green = (cr1-cc1)*alpha+(cb1-cc1)*beta+cc1;
     *blue  = (cr2-cc2)*alpha+(cb2-cc2)*beta+cc2;
   }
 }
 else{
   alpha = 0.5-alpha;
   if(beta > 0.5){
     beta = beta-0.5;
     *red   = (cl0-cc0)*alpha+(ct0-cc0)*beta+cc0;
     *green = (cl1-cc1)*alpha+(ct1-cc1)*beta+cc1;
     *blue  = (cl2-cc2)*alpha+(ct2-cc2)*beta+cc2;
   }
   else{
     beta = 0.5-beta;
     *red   = (cl0-cc0)*alpha+(cb0-cc0)*beta+cc0;
     *green = (cl1-cc1)*alpha+(cb1-cc1)*beta+cc1;
     *blue  = (cl2-cc2)*alpha+(cb2-cc2)*beta+cc2;
   }
 }
 return 1;
}

static void scal(double t[4][4], double sx, double sy, double sz){
 long i,j;
 for(i=0;i<4;i++) for(j=0;j<4;j++) t[i][j]=0.0;
 t[0][0]=sx; t[1][1]=sy; t[2][2]=sz; t[3][3]=1;
 return;
}

static void rotz(double tr[4][4], double ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][1]=-sin(ang);
  tr[1][0]= sin(ang);
  tr[1][1]= cos(ang);
  return;
}

static void roty(double tr[4][4], double ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][2]=-sin(ang);
  tr[2][0]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

static void rotx(double tr[4][4], double ang){
 long i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[1][1]= cos(ang);
  tr[1][2]=-sin(ang);
  tr[2][1]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

static void tram(double t[4][4], double dx, double dy, double dz){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  t[i][j]=0.0;
  if(i == j)t[i][j]=1.0;
 }
 t[0][3]=dx;
 t[1][3]=dy;
 t[2][3]=dz;
 t[3][3]=1;
 return;
}

static void m4by4(double t1[4][4], double t2[4][4], double tr[4][4]){
 short n=4,i,j,k;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  for(k=0;k<4;k++)tr[i][j]=tr[i][j]+t1[i][k]*t2[k][j];
 }
 return;
}

static void m4by1(double t4[4][4], vector v, vector vv){
 vv[0]=t4[0][0]*v[0]+t4[0][1]*v[1]+t4[0][2]*v[2]+t4[0][3];
 vv[1]=t4[1][0]*v[0]+t4[1][1]*v[1]+t4[1][2]*v[2]+t4[1][3];
 vv[2]=t4[2][0]*v[0]+t4[2][1]*v[1]+t4[2][2]*v[2]+t4[2][3];
 return;
}

static void c4to4(double tin[4][4], double tout[4][4]){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 tout[i][j]=tin[i][j];
}

static void null_transform(double t[4][4]){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 if(i == j)t[i][j]=1.0;
 else      t[i][j]=0.0;
}

static void rotate_round_vector(double angle, vector v, double t[4][4]){
  double dx,dy,dz,phi,theta,dxy;
  double t1[4][4],t2[4][4],t3[4][4];
  angle *= PI/180.0;
  dx=v[0]; dy=v[1]; dz=v[2];
  dxy=dx*dx+dy*dy;
  if(dxy < 0.00001){ /* vertical so just rotate about z  and return */
    if(dz > 0.0)rotz(t, angle);
    else        rotz(t,-angle);
    return;
  }
  dxy=sqrt(dxy);
  if     (dx == 0.0 && dy > 0.0)phi =  PI2;
  else if(dx == 0.0 && dy < 0.0)phi = -PI2;
  else phi = atan2(dy,dx);
  theta = atan2(dz,dxy);
  rotz(t3, -phi);
  roty(t2, -theta);
  m4by4(t2,t3,t1);
  rotx(t2, angle);
  m4by4(t2,t1,t3);
  roty(t2,theta);
  m4by4(t2,t3,t1);
  rotz(t2,phi);
  m4by4(t2,t1,t);
}

static BOOL normalise(vector v){
  double n,nn;
  n= (double)((v[0]*v[0]) + (v[1]*v[1]) + (v[2]*v[2]));
  if(n < 1.e-10)return FALSE;
  nn=sqrt(n);
  n = 1.0 / nn;
  VECSCALE(n,v,v)
  return TRUE;
}

fullscreenbuffer *ScaleImageMap(unsigned char *ImagePixels, int x, int y,
                             long X, long Y){
 vector p,Mn={0.0,0.0,1.0},Mx,My,Mp;
 double r,g,b;
 fullscreenbuffer *S,*s,*T,*t;
 unsigned char *px;
 long i,j;
 if((T=(fullscreenbuffer *)X__Malloc(x*y*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return NULL;
 }
 px=ImagePixels; t=T;
 for(j=0;j<y;j++)for(i=0;i<x;i++){
   t->R = *px++;
   t->G = *px++;
   t->B = *px++;
   t++;
 }
 if((S=(fullscreenbuffer *)X__Malloc(X*Y*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   X__Free(T);
   return NULL;
 }
 memset(S,0,X*Y*sizeof(fullscreenbuffer));
 Mp[0]=Mp[1]=Mp[2]=Mx[2]=My[2]=p[2]=0.0;
 Mx[1]=0.0; My[0]=0.0;
 Mx[0]=(double)X;
 My[1]=(double)Y;
 s=S;
 for(i=0;i<Y;i++)for(j=0;j<X;j++){
   p[0]=(double)j;
   p[1]=(double)i;
   if(MapFrom(p,Mp,Mx,My,Mn,T,x,y,&r,&g,&b) > 0){
     s->R=(unsigned char)r;
     s->G=(unsigned char)g;
     s->B=(unsigned char)b;
   }
   s++;
 }
 X__Free(T);
 return S;
}

static void GetAnimFileName(char *fsurf, char *tempstr, long frame,
                       long firstframe, long lastframe, long framestep){
 long thisframe;
 char *cp1,*cp2;
 cp1=strchr(fsurf,'0');
 cp2=strchr(fsurf,'.');
 if(cp1 == NULL || cp2 == NULL){
   sprintf(tempstr,"dummy.evi");
 }
 else{
   int ln;
   char *cp,extn[16],fmat[16];
   strcpy(extn,cp2);
   ln=0; cp=cp1; while(cp != cp2){ln++; cp++; if(ln > 8)break;}
   *cp1='\0';
   framestep=min(1,framestep);
   thisframe=firstframe-1+frame/framestep;
   while(thisframe > lastframe)thisframe -= lastframe;
   sprintf(fmat,"%%s%%0%ldld%%s",ln);
   sprintf(tempstr,fmat,fsurf,thisframe,extn);
 }
 strcpy(fsurf,tempstr);
}

BOOL Bilinear(double alpha, double beta,
             fullscreenbuffer *S,
             long Xmax, long Ymax,
             double *red,double *green,double *blue){
 long  ialpha,ibeta,i,j,k,kl,kr,kt,kb,pixel;
 double a,b,cc0,cc1,cc2,cl0,cl1,cl2,
        cr0,cr1,cr2,ct0,ct1,ct2,cb0,cb1,cb2;
 unsigned char *pP,*pR,*pG,*pB;
 j=Xmax;
 ialpha = (long)alpha; alpha -= (double)ialpha;
 ibeta  = (long)beta;  beta  -= (double)ibeta;
 if(ialpha < 0 || ialpha >= Xmax)return FALSE;
 if(ibeta  < 0 || ibeta  >= Ymax)return FALSE;
 k =ibeta*j+ialpha;
 if(ialpha <   1)kl=k; else kl=k-1;
 if(ialpha > j-2)kr=k; else kr=k+1;
 if(ibeta  <   1)kb=k; else kb=k-j;
 if(ibeta  > Ymax-2)kt=k; else kt=k+j;
 cc0 = (double)S[k].R;  cc1 = (double)S[k].G;  cc2 = (double)S[k].B;
 cl0 = (double)S[kl].R; cl1 = (double)S[kl].G; cl2 = (double)S[kl].B;
 cr0 = (double)S[kr].R; cr1 = (double)S[kr].G; cr2 = (double)S[kr].B;
 ct0 = (double)S[kt].R; ct1 = (double)S[kt].G; ct2 = (double)S[kt].B;
 cb0 = (double)S[kb].R; cb1 = (double)S[kb].G; cb2 = (double)S[kb].B;
 if(alpha > 0.5){
   alpha = alpha-0.5;
   if(beta > 0.5){
     beta = beta-0.5;
     *red   = (cr0-cc0)*alpha+(ct0-cc0)*beta+cc0;
     *green = (cr1-cc1)*alpha+(ct1-cc1)*beta+cc1;
     *blue  = (cr2-cc2)*alpha+(ct2-cc2)*beta+cc2;
   }
   else{
     beta = 0.5-beta;
     *red   = (cr0-cc0)*alpha+(cb0-cc0)*beta+cc0;
     *green = (cr1-cc1)*alpha+(cb1-cc1)*beta+cc1;
     *blue  = (cr2-cc2)*alpha+(cb2-cc2)*beta+cc2;
   }
 }
 else{
   alpha = 0.5-alpha;
   if(beta > 0.5){
     beta = beta-0.5;
     *red   = (cl0-cc0)*alpha+(ct0-cc0)*beta+cc0;
     *green = (cl1-cc1)*alpha+(ct1-cc1)*beta+cc1;
     *blue  = (cl2-cc2)*alpha+(ct2-cc2)*beta+cc2;
   }
   else{
     beta = 0.5-beta;
     *red   = (cl0-cc0)*alpha+(cb0-cc0)*beta+cc0;
     *green = (cl1-cc1)*alpha+(cb1-cc1)*beta+cc1;
     *blue  = (cl2-cc2)*alpha+(cb2-cc2)*beta+cc2;
   }
 }
 return TRUE;
}