Return to taka_jv.rr CVS log

Up to [local] / OpenXM / src / asir-contrib / packages / src

taka_jv_tabledata_to_jvdata() generates JavaView obj file
from a data of the format
  [[x0,y0,z0],
   [x1,y1,z1],
   [x2,y2,z2],
   ....
   ....
  ]
(x,y) must run over a squre.

/* $OpenXM: OpenXM/src/asir-contrib/packages/src/taka_jv.rr,v 1.2 2003/04/19 01:43:03 takayama Exp $ */
/* cf. misc-2002/03/RisaCon-ohp */
#define jv_adapted_to_fixed(A,B,C,D) taka_jv_adapted_to_fixed(A,B,C,D)
#define jv_ij_to_n(I,J,M) taka_jv_ij_to_n(I,J,M)
#define jv_put_line(Fp,S) taka_jv_put_line(Fp,S) 
#define jv_gen_obj(Fname,Data) taka_jv_gen_obj(Fname,Data) 
#define jv_adapted_y_to_obj(Data,Yrange,Hy) taka_jv_adapted_y_to_obj(Data,Yrange,Hy) 
#define jvtest1() taka_jv_test1()
/*
taka_jv_plot3d(F,Xrange,Yrange)
taka_jv_tabledata_to_jvdata(Table)
*/

extern Taka_jv_BIG $
Taka_jv_BIG = 10000 $
def jv_adapted_to_fixed(Data,X0,X1,H) {
  if (X0 >= X1) {
    error("taka_jv_adapted_to_fixed: X0 >= X1");
  }
  N = length(Data);
  F = [];
  for (I=0; I<N-1; I++) {
    P = Data[I];
    PP = Data[I+1];
    if (I==0) Range=[-Taka_jv_BIG,Data[1][0]];
    else if (I==(N-2)) Range=[Data[I][0],Taka_jv_BIG];
    else Range=[Data[I][0],Data[I+1][0]];
    if (PP[0]-P[0] != 0) {
      L = (x-P[0])*(PP[1]-P[1])/(PP[0]-P[0]) + P[1];
      F = cons([Range,L],F);
    }
  }
  F = reverse(F);
  N = length(F);
  V = [];
  I = 0;
  for (X=X0; X<=X1; X += H) {
    while (I<N) {
     Range = F[I][0];
     if ((X >= Range[0]) && (X <= Range[1])) break;
     I++;
    }
    V=cons([X,subst(F[I][1],x,X)],V);
  }
  return reverse(V);
}


def jv_ij_to_n(I,J,M) {
  return (1+I+J*M);
}

def jv_put_line(Fp,S) {
  S = strtoascii(S);
  for (I=0; I<length(S); I++) {
    put_byte(Fp,S[I]);
  }
  put_byte(Fp,10);
}

def jv_gen_obj(Fname,Data) {
  Fp = open_file(Fname,"w");
  N = length(Data[0]);
  for (I=0; I<N; I++) {
    V = Data[0][I];
    S = "v "+rtostr(V[0])+" "+rtostr(V[1])+" "+rtostr(V[2]);
    jv_put_line(Fp,S);
  }
  N = length(Data[1]);
  for (I=0; I<N; I++) {
    V = Data[1][I];
    jv_put_line(Fp,V);
  }
  close_file(Fp);
}

def jv_adapted_y_to_obj(Data,Yrange,Hy) {
  Opt = getopt();
  Interporate = 1;
  for (I=0; I<length(Opt); I++)   {
   if (Opt[I][0] == "interporation") {
    if (Opt[I][1] == "no") {
      Interporate = 0;
    }
   }
  }
  M = length(Data);
  N = number_ceiling((Yrange[1]-Yrange[0])/Hy);
  Ftable = newmat(M,N);
  XYtable = newmat(M,N);
  for (I=0; I<M; I++) {
   DataY = Data[I][0];
   X = Data[I][1];
   if (Interporate) 
     DataY = jv_adapted_to_fixed(DataY,Yrange[0],Yrange[1],Hy);
   for (J=0; J<N; J++) {
     XYtable[I][J] = [X,DataY[J][0]];
     Ftable[I][J]  = DataY[J][1];
   }
  }
  
  /* Vertex coordinates V */
  V = [];
  for (J=0; J<N; J++) {
   for (I=0; I<M; I++) {
     V = cons([XYtable[I][J][0],XYtable[I][J][1],Ftable[I][J]],V);
   }
  }
  V = reverse(V);

  /* Normal vector Nv */
  /* We do not necessary need it */
  

  /* Faces */
  Face = [];
  for (J=0; J<N-1; J++) {
   for (I=0; I<M-1; I++) {
     S = "f "+ rtostr(jv_ij_to_n(I,J,M))+"/"+rtostr(jv_ij_to_n(I,J,M))+" "
             + rtostr(jv_ij_to_n(I+1,J+1,M))+"/"+rtostr(jv_ij_to_n(I+1,J+1,M))+" "
             + rtostr(jv_ij_to_n(I,J+1,M))+"/"+rtostr(jv_ij_to_n(I,J+1,M))+" ";
     Face = cons(S,Face);
     S = "f "+ rtostr(jv_ij_to_n(I,J,M))+"/"+rtostr(jv_ij_to_n(I,J,M))+" "
             + rtostr(jv_ij_to_n(I+1,J,M))+"/"+rtostr(jv_ij_to_n(I+1,J,M))+" "
             + rtostr(jv_ij_to_n(I+1,J+1,M))+"/"+rtostr(jv_ij_to_n(I+1,J+1,M))+" ";
     Face = cons(S,Face);
   }
  }
  Face = reverse(Face);

  return [V,Face];  
  
}

def jvtest1() {
  Data = [ ];
  for (X=-3; X<3; X += 0.3) {
    D = [];
    for (I=-3; I<3; I += deval(random()/10/(2^32-1))+0.1) {
      D = cons([I,eval(sin(I)*cos(X))],D);
    }
    D = reverse(D);
    D2 = jv_adapted_to_fixed(D,-3,3,0.3);
    /* taka_plot_auto(D2); */
    Data = cons([D2,X],Data);
  }
  Data = reverse(Data);
  print(Data);
  Jdata = taka_jv_adapted_y_to_obj(Data,[-3,3],0.3);
  jv_gen_obj("taka_jv_test.obj",Jdata);
  return Jdata;
}

def taka_jv_plot3d(F,Xrange,Yrange) {
  Opt = getopt();
  /* Set default values */
  DX = eval(exp(0)*(Xrange[1]-Xrange[0])/20);
  DY = eval(exp(0)*(Yrange[1]-Yrange[0])/20);
  V1 = x; V2 = y;
  /* 
    Todo:  get DX and DY 
  */
  Data = [ ];
  for (X=Xrange[0]; X<Xrange[1]; X += DX) {
    D = [];
    for (Y=Yrange[0]; Y<Yrange[1]; Y += DY) {
      D = cons([Y,eval(base_replace(F,[[V1,X],[V2,Y]]))],D);
    }
    D = reverse(D);
    D2 = jv_adapted_to_fixed(D,Yrange[0],Yrange[1],DY);
    Data = cons([D2,X],Data);
  }
  Data = reverse(Data);
  /* print(Data); */
  Jdata = taka_jv_adapted_y_to_obj(Data,[Xrange[0],Xrange[1]],DX);
  return Jdata;
}
/*
  taka_jv_gen_obj("taka_jv_test.obj",Jdata);
*/

/* Table data is in the form
  [ [x0, y0, z0],
    [x1, y1, z1],
    ....
  ]
*/
/*
#define DEBUG
*/
def taka_jv_tabledata_to_jvdata(Table) {
  Opt = getopt();

  N = length(Table);
  if (N < 1) return [];
  Xmax = Xmin = Table[0][0];
  Ymax = Ymin = Table[0][1];
  Zmax = Zmin = Table[0][2];
  Xsum = 0; Ysum = 0; Zsum = 0;
  for (I=0; I<N; I++) {
    if (Table[I][0] > Xmax) Xmax = Table[I][0];
    if (Table[I][0] < Xmin) Xmin = Table[I][0];
    Xsum += Table[I][0];
    if (Table[I][1] > Ymax) Ymax = Table[I][1];
    if (Table[I][1] < Ymin) Ymin = Table[I][1];
    Ysum += Table[I][1];
    if (Table[I][2] > Zmax) Zmax = Table[I][2];
    if (Table[I][2] < Zmin) Zmin = Table[I][2];
    Zsum += Table[I][2];
  }
  /* Set default values */
#define DEFAULT_MESH_SIZE 10
  DX = eval(exp(0)*(Xmax-Xmin)/DEFAULT_MESH_SIZE);
  DY = eval(exp(0)*(Ymax-Ymin)/DEFAULT_MESH_SIZE);

  Xepsilon = DX/4; /* It has not yet been used. */
  XsamplePoints = [];
  for (I=0; I<N; I++) {
    XsamplePoints = cons(Table[I][0],XsamplePoints);
  }
  XsamplePoints = newvect(length(XsamplePoints),XsamplePoints);
  qsort(XsamplePoints);

  XsamplePoints2 = [];
  J = -1;
  for (I=0; I<N; I++) {
    if (J<0) {
       XsamplePoints2 = cons(XsamplePoints[I],XsamplePoints2);
       J++;
    } else if (XsamplePoints2[0] != XsamplePoints[I]) {
       XsamplePoints2 = cons(XsamplePoints[I],XsamplePoints2);
    }
  }
  XsamplePoints = reverse(XsamplePoints2);

  Data = [ ];
  for (X=car(XsamplePoints); XsamplePoints != []; 
                             XsamplePoints = cdr(XsamplePoints)) {
    X = car(XsamplePoints);
    D = [];
    for (I=0; I<N; I++) {
      if (Table[I][0] == X) {
        D = cons([Table[I][1],Table[I][2]],D);
      }
    }
    D = qsort(newvect(length(D),D));
    D = vtol(D);
#ifdef DEBUG
    print([X,D]);
#endif
    /* (x,y) domain is assumed to be a square!! */
    D2 = jv_adapted_to_fixed(D,Ymin,Ymax,DY);
    Data = cons([D2,X],Data);
  }
  Data = reverse(Data);
#ifdef DEBUG
  print(Data);
#endif

  /* BUG: there is a bug in the linear interporation code. */
  Jdata = taka_jv_adapted_y_to_obj(Data,[Xmin,Xmax],DX|interporation="no");

#ifdef DEBUG
  return [Data,Jdata];
#else
  return Jdata;
#endif
}

def taka_jv_test2() {
  Data = [];
  for (X=0; X<2; X += 0.2) {
   for (Y=0; Y<1; Y += 0.2) {
     Data = cons([X,Y,eval(sin(X*2)*cos(Y*4))],Data);
   }
  } 
  Jv = taka_jv_tabledata_to_jvdata(Data);
  jv_gen_obj("taka_jv_test2.obj",Jv);
  return Jv;
}

end$