apps/ccam/vrml303.c

Go to the documentation of this file.

/*
 * vrml303.c
 *
 */
#include <fcntl.h>  /*open*/
#include <unistd.h> /* close */

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>           /* mmap */
#include <string.h>

#include <math.h>

#include "vrml303.h"
#include "zlib/zlib.h"
#include "gzio_compress.h"

#define D(x)

//#define DEBUG_CONT 1



#ifdef DEBUG_CONT
 #define DEBUG_TOP
 #define MD1(x) fprintf(stderr,"%s:%d:",__FILE__,__LINE__);x
#else
 #define MD1(x)
#endif

//#define MD2(x) fprintf(stderr,"%s:%d:",__FILE__,__LINE__);x
#define MD2(x)


//#define DEBUG_TOP
#ifdef DEBUG_TOP
 #define MD(x) fprintf(stderr,"%s:%d:",__FILE__,__LINE__);x
#else
 #define MD(x)
#endif


// should be less than SQRT(MYMAXINT/2)
#define MYMAXINT 0x7fffffff
#define EDGEFRACTMAX 16384
#define LINEWIDTH2BREAK 80
//returns pointer to a string of spaces n?(n+inc):0 character long (or shorter)
char * indentString(int n, int inc);
#define MAXCOLORS 32
// options - string of up to MAXCOLORS characters (and 0)
// 0,k,K - black
// 1,r,R - red
// 2,g,G - green
// 3,y,Y - yellow
// 4,b,B - blue
// 5,m,M - magengta
// 6,c,C - cyan
// 7,w,W - white
void initPseudoColor(const char * options); // will prepare arrays for up to MAXCOLORS colors.
// will produce color as "0.123 0.456 0.789" using (i.e "BR" ) color options string and value 0..MYMAXINT
char * pseudoColorStr(char * cs, int value);
//   MD(fprintf(stderr,"width- %d, height %d, quality - %d, contrast - %d, color - %d, orient - %d, depth - %d\r\n", ImageWidth,ImageHeight, Quality, Contrast, Color, bayerOrient, Depth));
//edArr[y][x][0] - horizontal edge (x,y) to (x+1,y)
//edArr[y][x][1] - vertical edge (x,y) to (x,y+1)
// value - "-1" - no intersections with current isoline, 0..EDGEFRACTMAX where does it intersect
// if one end equals level and the other is equal or less - no intersection
// vert[y][x] (and level) should be normalized to 0..MYMAXINT
// returns number of marked edges
int fillEdgesArray (int level,
                                        int x0, int y0, int x1, int y1, // window of interest 
                                        int vert[MAX_VERTEX_Y][MAX_VERTEX_X],
                                        short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]);
// edgeNum[0] - y,
// edgeNum[1] - x,
// edgeNum[2] - start edge orient (o - hor, 1 - vert),
// edgeNum[3] - dir (0 - up or right, 1 - down or left)
// returns 0 - did not found, 1 - found (result in edgeNum) on the boarder, 2 - found inside (result in edgeNum)
// edgeNum should be initialized by (x0,y0,0,ANY) before the first call
int findStartEdge  (int * edgeNum,      // 4-element integer array - y,x,orient(0,1),dir(0,1)
                                        int x0, int y0, int x1, int y1, // window of interest 
                                        short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]);
//returns 0 - did not found, 1 - found. Will modify *edgeNum elements
// modify to orient i.e. right hand is always higher?
int findNextEdge   (int * edgeNum,      // 4-element integer array - y,x,orient(0,1),dir(0,1)
                                        int x0, int y0, int x1, int y1, // window of interest 
                                        short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]);

// returns number of coordinates exported (closed lines should start and end with index 0)
int exportIsolineCoord (int closed,     // 1 - closed line, 0 -opened
                                          int scaleX,   // multiply x by scaleX to get pixels
                                          int scaleY,   // multiply y by scaleY to get pixels
                                          int dcm,              // 1/10(should match format)
                                          int indent,   // indentation
                                          const char * frmt, // output format as "     %d.%01d 123.4 -%d.%01d"
                                          int * edgeNumS,       // 4-element integer array - will not be modified!
                                          int x0, int y0, int x1, int y1, // window of interest 
                                          short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]);

int exportIsolineNode  (int level,
                                          int scaleX,   // multiply x by scaleX to get pixels
                                          int scaleY,   // multiply y by scaleY to get pixels
                                          int dcm,              // 1/10(should match format)
                                          int indent, //if 0 - all will be 0, else - 1 per level
                                          const char * charZ,   // string representation of z (VRML-y) of the isoline (0 or level)
                                          const char * Appearance,      // name of appearance to use (should be defined earlier)
                                          int x0, int y0, int x1, int y1, // window of interest
                                          int vert[MAX_VERTEX_Y][MAX_VERTEX_X],
                                          short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]);
void exportVRMLStart(int level);
void exportVRMLViewpoints(int width, int height, int elev);

//returns <0 - errror, (vertNum_x & 0xfff)+((vertNum_y & 0xfff) << 12) if OK
int initVertexArray ( const char * dmaFileName,
                                          int   width,
                                          int height,
                                          int maxpixel, // maximal pixel (full scale -= 1024, 0 - auto normalize)
                                          int decimate_x,       // rectangle width to be combined in one vertex
                                          int decimate_y,       // rectangle height to be combined in one vertex
                                          int vert[MAX_VERTEX_Y][MAX_VERTEX_X] // vertex array
                                          );

void exportFacesAppearance(const char * aname, const char * mname, double transparency);
void exportIsolinesAppearance(const char * prefix, int numLev);
void exportCoordinateSet(const char * name,
                                                 int width, int height, // number of vertexes is (width+1)*(height+1) !!
                                                 int elev,
                                                 int scale_X, int scale_Y,
                                                 int dcp,       // 0 or 1 only
                                                 int indent,
                                                 int vert[MAX_VERTEX_Y][MAX_VERTEX_X]);
void exportColorSet(const char * name,
                                        int width, int height,
                                        int indent,
                                        int vert[MAX_VERTEX_Y][MAX_VERTEX_X]);
void exportSwitchStart(const char * name, const char * suffics, int * ind);
void exportSwitchEnd(int * ind);
void exportTransformStart(const char * name, const char * suffics, int * ind);
void exportTransformEnd(int * ind);

void exportIFSStart       (const char * app,                       // name of Appearance to use
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) ;                                    // address of indent value

void exportILSStart (const char * app,     // name of Appearance to use (may be NULL)
                     const char * coord,   // name of Coordinate to use (may NOT be NULL)
                     const char * color,   // name of Color to use      (may be NULL)
                     int * ind) ;          // address of indent value

void exportIFLSEnd        (int * ind) ;                                    // address of indent value

void exportTopFaces   (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * app,                           // name of Appearance to use
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) ;                                    // address of indent value   

void exportBottomFaces(int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * app,                           // name of Appearance to use
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) ;                                    // address of indent value   

void exportSideFaces  (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * app,                           // name of Appearance to use
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                       int wallNum,                                        // wall number (0..3)
                                           int * ind) ;                                    // address of indent value   

void exportTopEdges   (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) ;                                    // address of indent value   

void exportBottomEdges(int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) ;                                    // address of indent value   


void exportSideEdges   (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                       int wallNum,                                        // wall number (0..3)        
                                           int * ind) ;                                    // address of indent value   


 
//table for nextEdge calculation
int nextEdgeTable[][2][3][4]= //[orient][dir][choice(0..2)](dy,dx,new_orient,new_dir)
                {
                 {                                       // orient==0
                  {                              // dir==0
                   { 0, 1, 1, 0},        // choice==0
                   { 1, 0, 0, 0},        // choice==1
                   { 0, 0, 1, 1}},       // choice==2
                  {                              // dir==1
                   {-1, 0, 1, 1},        // choice==0
                   {-1, 0, 0, 1},        // choice==1
                   {-1, 1, 1, 0}}},      // choice==2
                 {                                       // orient==1
                  {                              // dir==0
                   { 0, 0, 0, 1},        // choice==0
                   { 0, 1, 1, 0},        // choice==1
                   { 1, 0, 0, 0}},       // choice==2
                  {                              // dir==1
                   { 1,-1, 0, 0},        // choice==0
                   { 0,-1, 1, 1},        // choice==1
                   { 0,-1, 0, 1}}}}; // choice==2
char indentS[]="                                                                                     ";
struct  {
  int numcolors;
  int coeff;
  int red[MAXCOLORS];
  int green[MAXCOLORS];
  int blue[MAXCOLORS];
} colorTab;
//******************************************************************
// compressed file
    gzFile gzfile;



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

#ifdef DEBUG_CONT
void printEdgesArray (int nx, int ny, short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]) {
  int x,y;
  MD1(fprintf(stderr,"printEdgesArray(%d, %d, edArr)\r\n",nx,ny));
  for (y=0;y<ny;y++) {
    fprintf(stderr,"y= %02d ",y);
    for (x=0;x<nx;x++) {
      fprintf(stderr,"[%5d %5d] ",(int) edArr[y][x][0],(int) edArr[y][x][1]);
    }
    fprintf(stderr,"\r\n");
  }
}
#endif

// options - string of up to MAXCOLORS characters (and 0)
// 0,k,K - black
// 1,r,R - red
// 2,g,G - green
// 3,y,Y - yellow
// 4,b,B - blue
// 5,m,M - magengta
// 6,c,C - cyan
// 7,w,W - white
void initPseudoColor(const char * options){ // will prepare arrays for up to MAXCOLORS colors.
 int i;
 char s1[]="WW";
 const char * cp=options;
// char tmp[20];
// int tmpv; 
 if ((!options) || (strlen(options)==0)) cp=(const char *) s1;
 else if (strlen(options)==1) {
   s1[0]='0';
   s1[1]=options[0];
   cp=(const char *) s1;
 }
 colorTab.numcolors=strlen(cp);
 if (colorTab.numcolors>MAXCOLORS) colorTab.numcolors=MAXCOLORS;
 colorTab.coeff=((1000*(colorTab.numcolors-1))<<16)/(MYMAXINT>>16);

 for (i=0;i<colorTab.numcolors;i++) switch (cp[i] ) {
  case '0':
  case 'k':
  case 'K':
          {colorTab.red[i]=0;colorTab.green[i]=0;colorTab.blue[i]=0;break;}
  case '1':
  case 'r':
  case 'R':
          {colorTab.red[i]=1;colorTab.green[i]=0;colorTab.blue[i]=0;break;}
  case '2':
  case 'g':
  case 'G':
          {colorTab.red[i]=0;colorTab.green[i]=1;colorTab.blue[i]=0;break;}
  case '3':
  case 'y':
  case 'Y':
          {colorTab.red[i]=1;colorTab.green[i]=1;colorTab.blue[i]=0;break;}
  case '4':
  case 'b':
  case 'B':
          {colorTab.red[i]=0;colorTab.green[i]=0;colorTab.blue[i]=1;break;}
  case '5':
  case 'm':
  case 'M':
          {colorTab.red[i]=1;colorTab.green[i]=0;colorTab.blue[i]=1;break;}
  case '6':
  case 'c':
  case 'C':
          {colorTab.red[i]=0;colorTab.green[i]=1;colorTab.blue[i]=1;break;}
  case '7':
  case 'w':
  case 'W':
          {colorTab.red[i]=1;colorTab.green[i]=1;colorTab.blue[i]=1;break;}
  default:
          {colorTab.red[i]=1;colorTab.green[i]=1;colorTab.blue[i]=1;break;}
 }
#if 0
 fprintf(stderr,"initPseudoColor (%s), colorTab.numcolors=%d, coeff=%d\n",cp,colorTab.numcolors,colorTab.coeff);
 fprintf(stderr,"colorTab.red= %d %d %d %d\n",colorTab.red[0],colorTab.red[1],colorTab.red[2],colorTab.red[3]);
 fprintf(stderr,"colorTab.green= %d %d %d %d\n",colorTab.green[0],colorTab.green[1],colorTab.green[2],colorTab.green[3]);
 fprintf(stderr,"colorTab.blue= %d %d %d %d\n",colorTab.blue[0],colorTab.blue[1],colorTab.red[2],colorTab.blue[3]);
 tmpv=0;fprintf(stderr,"pseudoColorStr(%x)= %s\n",tmpv,pseudoColorStr(tmp,tmpv));
   tmpv=((tmpv>>16)*colorTab.coeff)>>16;  fprintf(stderr,"value= %x\n",tmpv);
 tmpv=0x10000000;fprintf(stderr,"pseudoColorStr(%x)= %s\n",tmpv,pseudoColorStr(tmp,tmpv));
   tmpv=((tmpv>>16)*colorTab.coeff)>>16;  fprintf(stderr,"value= %x\n",tmpv);
 tmpv=0x20000000;fprintf(stderr,"pseudoColorStr(%x)= %s\n",tmpv,pseudoColorStr(tmp,tmpv));
   tmpv=((tmpv>>16)*colorTab.coeff)>>16;  fprintf(stderr,"value= %x\n",tmpv);
 tmpv=0x40000000;fprintf(stderr,"pseudoColorStr(%x)= %s\n",tmpv,pseudoColorStr(tmp,tmpv));
   tmpv=((tmpv>>16)*colorTab.coeff)>>16;  fprintf(stderr,"value= %x\n",tmpv);
 tmpv=0x7fffffff;fprintf(stderr,"pseudoColorStr(%x)= %s\n",tmpv,pseudoColorStr(tmp,tmpv));
   tmpv=((tmpv>>16)*colorTab.coeff)>>16;  fprintf(stderr,"value= %x\n",tmpv);
#endif

}

// will produce color as "0.123 0.456 0.789" value 0..MYMAXINT
// 
char * pseudoColorStr(char * cs, int value) {
  int ci,cf;
  int r,g,b;
  value=((value>>16)*colorTab.coeff)>>16; //value is expected to be in the range 0..MYMAXINT (0x7ffffff)
  ci=value/1000;
  if (ci>=colorTab.numcolors) ci=colorTab.numcolors;
  cf=value-1000*ci;
  if (cf>999) cf=999;
  if (colorTab.red[ci]==colorTab.red[ci+1]) r=colorTab.red[ci]?1000:0;
  else if (colorTab.red[ci]) r=1000-cf;
  else r=cf;
  if (colorTab.green[ci]==colorTab.green[ci+1]) g=colorTab.green[ci]?1000:0;
  else if (colorTab.green[ci]) g=1000-cf;
  else g=cf;
  if (colorTab.blue[ci]==colorTab.blue[ci+1]) b=colorTab.blue[ci]?1000:0;
  else if (colorTab.blue[ci]) b=1000-cf;
  else b=cf;
  sprintf(cs,"%d.%03d %d.%03d %d.%03d",(r==1000),(r==1000)?0:r,
                                                                           (g==1000),(g==1000)?0:g,
                                                                           (b==1000),(b==1000)?0:b);
  return cs;
}


//returns pointer to a string of spaces n?(n+inc):0 character long (or shorter)
char * indentString(int n, int inc) {
  n= (n>=0)?(n+inc):0;
  if (n>=sizeof(indentS)) n=sizeof(indentS)-1;
  if (n<0) n=0;
  return &indentS[(sizeof(indentS)-1)-n];
}



int fillEdgesArray (int level,
                                        int x0, int y0, int x1, int y1, // window of interest 
                                        int vert[MAX_VERTEX_Y][MAX_VERTEX_X],
                                        short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]) {
  int numis=0;
  int x,y,d;

  MD1(fprintf(stderr,"fillEdgesArray: level=%d, x0=%d, y0=%d, x1=%d, y1=%d\r\n", level, x0, y0, x1, y1));
  MD1(fprintf(stderr,"sizeof(edArr)=%d\r\n", sizeof(edArr)));
//  memset (edArr, -1,(MAX_VERTEX_Y+1)*(MAX_VERTEX_X+1)*sizeof(edArr)); // all "1"-s - is -1
  memset (edArr, -1,(MAX_VERTEX_Y+1)*(MAX_VERTEX_X+1)*2*2); // all "1"-s - is -1
#ifdef DEBUG_CONT
  printEdgesArray (x1+1,y1+1, edArr);
#endif

// check x0,x1,y0,y1?
  for (y=y0;y<=y1;y++)
   for (x=x0; x<x1; x++)
    if (((vert[y][x] >level) || (vert[y][x+1]> level)) &&
            ((vert[y][x]<=level) || (vert[y][x+1]<=level))) {
                if              (vert[y][x]   == level) edArr[y][x][0]=0;
                else if (vert[y][x+1] == level) edArr[y][x][0]=EDGEFRACTMAX;
                else {
                  d=(vert[y][x+1]-vert[y][x])/EDGEFRACTMAX;
                  if (d==0) d=(vert[y][x+1]>vert[y][x])?1:-1; 
                  edArr[y][x][0]= (level-vert[y][x])/d;
                  if (edArr[y][x][0]<1) edArr[y][x][0]=1;
                  else if (edArr[y][x][0]>(EDGEFRACTMAX-1))     edArr[y][x][0]=EDGEFRACTMAX-1;
                }
                numis++;
  }

  for (x=x0;x<=x1;x++)
   for (y=y0; y<y1; y++)
    if (((vert[y][x] >level) || (vert[y+1][x]> level)) &&
            ((vert[y][x]<=level) || (vert[y+1][x]<=level))) {
                if              (vert[y][x]   == level) edArr[y][x][1]=0;
                else if (vert[y+1][x] == level) edArr[y][x][1]=EDGEFRACTMAX;
                else {
                  d=(vert[y+1][x]-vert[y][x])/EDGEFRACTMAX;
                  if (d==0) d=(vert[y+1][x]>vert[y][x])?1:-1; 
                  edArr[y][x][1]= (level-vert[y][x])/d;
                  if (edArr[y][x][1]<1) edArr[y][x][1]=1;
                  else if (edArr[y][x][1]>(EDGEFRACTMAX-1))     edArr[y][x][1]=EDGEFRACTMAX-1;
                }
                numis++;
  }
  if (numis==0) return 0; // no intersections at all
// filter out all single-point lines
// internal
  for (y=y0+1;y<y1;y++)
   for (x=x0;x<x1;x++)
    if ((edArr[y][x][0]==    EDGEFRACTMAX) &&
            (edArr[y-1][x+1][1]==EDGEFRACTMAX) &&
                (edArr[y][x+1][0]==  0) &&
                (edArr[y][x+1][1]==  0)) {
          edArr[y][x][0]=-1;
          edArr[y-1][x+1][1]=-1;
          edArr[y][x+1][0]=-1;
          edArr[y][x+1][1]=-1;
          numis-=4;
        }
 // x=x0;
  for (y=y0+1;y<y1;y++)
    if ((edArr[y][x0][0]==  0) &&
                (edArr[y][x0][1]==  0) &&
            (edArr[y-1][x0][1]==EDGEFRACTMAX)) {
          edArr[y][x0][0]=-1;
          edArr[y][x0][1]=-1;
          edArr[y-1][x0][1]=-1;
          numis-=3;
        }
 // x=x1;
  for (y=y0+1;y<y1;y++)
    if ((edArr[y][x1-1][0]==EDGEFRACTMAX) &&
                (edArr[y][x1][1]==  0) &&
            (edArr[y-1][x1][1]==EDGEFRACTMAX)) {
          edArr[y][x1-1][0]=-1;
          edArr[y][x1][1]=-1;
          edArr[y-1][x1][1]=-1;
          numis-=3;
        }
 // y=y0;
  for (x=x0+1;x<x1;x++)
    if ((edArr[y0][x][1]==  0) &&
                (edArr[y0][x-1][0]==EDGEFRACTMAX) &&
            (edArr[y0][x][0]==  0)) {
          edArr[y0][x][1]=-1;
          edArr[y0][x-1][0]=-1;
          edArr[y0][x][0]=-1;
          numis-=3;
        }
 // y=y1;
  for (x=x0+1;x<x1;x++)
    if ((edArr[y1-1][x][1]==EDGEFRACTMAX) &&
                (edArr[y1][x-1][0]==EDGEFRACTMAX) &&
            (edArr[y1][x][0]==  0)) {
          edArr[y1-1][x][1]=-1;
          edArr[y1][x-1][0]=-1;
          edArr[y1][x][0]=-1;
          numis-=3;
        }
 // corners
  if ((edArr[y0][x0][0]==  0) &&
          (edArr[y0][x0][1]==  0)) {
        edArr[y0][x0][0]=-1;
        edArr[y0][x0][1]=-1;
        numis-=2;
  }
  if ((edArr[y0][x1-1][0]==EDGEFRACTMAX) &&
          (edArr[y0][x1][1]==  0)) {
        edArr[y0][x1-1][0]=-1;
        edArr[y0][x1][1]=-1;
        numis-=2;
  }
  if ((edArr[y1-1][x1][1]==EDGEFRACTMAX) &&
          (edArr[y1][x1-1][0]==EDGEFRACTMAX)) {
        edArr[y1-1][x1][1]=-1;
        edArr[y1][x1-1][0]=-1;
        numis-=2;
  }
  if ((edArr[y1-1][x0][1]==EDGEFRACTMAX) &&
          (edArr[y1][x0][0]==0)) {
        edArr[y1-1][x0][1]=-1;
        edArr[y1][x0][0]=-1;
        numis-=2;
  }

  return numis;
}

// edgeNum[0] - y,
// edgeNum[1] - x,
// edgeNum[2] - start edge orient (o - hor, 1 - vert),
// edgeNum[3] - dir (+1 - up or right, -1 - down or left)
// returns 0 - did not found, 1 - found (result in edgeNum) on the boarder, 2 - found inside (result in edgeNum)
// edgeNum should be initialized by (x0,y0,0,ANY) before the first call
int findStartEdge  (int * edgeNum,      // 4-element integer array - y,x,orient(0,1),dir(+1,-1)
                                        int x0, int y0, int x1, int y1, // window of interest 
                                        short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]) {
  int x,y;
// try on y=y0 (last_x+1-->x1)
  if ((edgeNum[0]==y0) && (edgeNum[2]==0)) {
   for (x=edgeNum[1]+(edgeNum[1]>x0);x<x1;x++)
    if (edArr[y0][x][0]>=0) {
          edgeNum[0]=y0;
          edgeNum[1]=x;
          edgeNum[2]=0;
          edgeNum[3]=0;
          return 1;
   }
   edgeNum[0]=y0-1;
   edgeNum[1]=x1;
   edgeNum[2]=1;
  }
// try on x=x1 (last_y+1-->y1)
  if ((edgeNum[1]==x1) && (edgeNum[2]==1)) {
   for (y=edgeNum[0]+1;y<y1;y++)
    if (edArr[y][x1][1]>=0) {
          edgeNum[0]=y;
          edgeNum[1]=x1;
          edgeNum[2]=1;
          edgeNum[3]=1;
          return 1;
   }
   edgeNum[0]=y1;
   edgeNum[1]=x1;
   edgeNum[2]=0;
  }
// try on y=y1 (last_x-1-->x0)
  if ((edgeNum[0]==y1) && (edgeNum[2]==0)) {
   for (x=edgeNum[1]-1;x>=x0;x--)
    if (edArr[y1][x][0]>=0) {
          edgeNum[0]=y1;
          edgeNum[1]=x;
          edgeNum[2]=0;
          edgeNum[3]=1;
          return 1;
   }
   edgeNum[0]=y1;
   edgeNum[1]=x0;
   edgeNum[2]=1;
  }
// try on x=x0 (last_y1-->y0)
  if ((edgeNum[1]==x0) && (edgeNum[2]==1)) {
   for (y=edgeNum[0]-1;y>=y0;y--)
    if (edArr[y][x0][1]>=0) {
          edgeNum[0]=y;
          edgeNum[1]=x0;
          edgeNum[2]=1;
          edgeNum[3]=0;
          return 1;
   }
   edgeNum[0]=y0;
   edgeNum[1]=x0;
   edgeNum[2]=1;
  }

// look inside - only vertical edges OK
  edgeNum[2]=1;
  edgeNum[3]=0;
  y=edgeNum[0];
  x=edgeNum[1]+1;
  if (x>=x1) {
    y++;
        x=x0+1;
  } 
  while (y<y1) {
    if (edArr[y][x][1]>=0) {
      edgeNum[0]=y;
      edgeNum[1]=x;
          return 2;
        }
    if ((++x)>=x1) {
      y++;
          x=x0+1;
    } 
  }
  return 0;     // nothing found
}
// can see 0,1 or 3 intersections. If 3 - will look for a nearest one (rare case)
//int nextEdgeTable[][2][3][4]= //[orient][dir][choice(0..2)](dy,dx,new_orient,new_dir)
int findNextEdge  (int * edgeNum,       // 4-element integer array - y,x,orient(0,1),dir(+1,-1)
                                        int x0, int y0, int x1, int y1, // window of interest 
                                        short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]) {
  int i;
  int choice=-1;
  int n=0;
  int neib[4];
  MD1(fprintf(stderr,"findNextEdge: edgeNum=[%d %d %d %d], x0=%d, y0=%d, x1=%d, y1=%d\r\n", edgeNum[0], edgeNum[1], edgeNum[2], edgeNum[3], x0, y0, x1, y1));

// supposed we are not on the boarder looking outwards - will check later
// supposed initial edge is in range 0..EDGEFRACTMAX
  for (i=0;i<3;i++){ 
    neib[i]=edArr[edgeNum[0]+nextEdgeTable[edgeNum[2]][edgeNum[3]][i][0]] //y
                 [edgeNum[1]+nextEdgeTable[edgeNum[2]][edgeNum[3]][i][1]] //x
                 [           nextEdgeTable[edgeNum[2]][edgeNum[3]][i][2]];//orient
        if (neib[i]>=0) {
          n++; //
          choice=i;
        }
  }
  MD1(fprintf(stderr,"findNextEdge: n=%d, choice=%d\r\n", n, choice));

  if (n==0) return 0;
  if (n==3) { // resolve "saddle" -- find nearest
    neib[3]=edArr[edgeNum[0]][edgeNum[1]][edgeNum[2]];
// orient all neib elements to point counterclockwise
    if (edgeNum[2]==0) {
      if (edgeNum[3]==0) {
            neib[1]= EDGEFRACTMAX-neib[1];
            neib[2]= EDGEFRACTMAX-neib[2];
          } else { // if (edgeNum[3]==0)
            neib[0]= EDGEFRACTMAX-neib[0];
            neib[3]= EDGEFRACTMAX-neib[3];
          } // if (edgeNum[3]==0)
    } else { // if (edgeNum[2]==0)
      if (edgeNum[3]==0) {
            neib[2]= EDGEFRACTMAX-neib[2];
            neib[3]= EDGEFRACTMAX-neib[3];
          } else { // if (edgeNum[3]==0)
            neib[0]= EDGEFRACTMAX-neib[0];
            neib[1]= EDGEFRACTMAX-neib[1];
          } // if (edgeNum[3]==0)
    } // if (edgeNum[2]==0)
//replace neib[0..2] with lengths^2;
    neib[0]= (EDGEFRACTMAX-neib[3])*(EDGEFRACTMAX-neib[3]) + neib[0]*neib[0];
    neib[1]= (neib[3]+neib[1]-EDGEFRACTMAX)*(neib[3]+neib[1]-EDGEFRACTMAX) + EDGEFRACTMAX*EDGEFRACTMAX;
    neib[2]= neib[3]*neib[3] + (EDGEFRACTMAX-neib[2])*(EDGEFRACTMAX-neib[2]);
// now find the shortest one (chose right-hand if equal)
    choice=(neib[0]>neib[2])?((neib[1]>neib[2])? 2 : 1 ):((neib[0]>neib[1])? 1 : 0);
  }//if (n==3)
  edgeNum[0]+=nextEdgeTable[edgeNum[2]][edgeNum[3]][choice][0]; //y
  edgeNum[1]+=nextEdgeTable[edgeNum[2]][edgeNum[3]][choice][1]; //x
  i          =nextEdgeTable[edgeNum[2]][edgeNum[3]][choice][2]; //orient
  edgeNum[3] =nextEdgeTable[edgeNum[2]][edgeNum[3]][choice][3]; //direction
  edgeNum[2] =i;
  return 1;
}

// returns number of coordinates exported (closed lines should start and end with index 0)
// supports integer (dcm==1,frmt has 2 fields) and fractional output (dcm=10, frmt has 4 fields)
// will export just data, no "[" or "]"
// edgeNum is supposed to point to starting edge/direction (after findStartEdge)
// relies on "closed" - all open lines should be processed first.
int exportIsolineCoord (int closed,     // 1 - closed line, 0 -opened
                                          int scaleX,   // multiply x by scaleX to get pixels
                                          int scaleY,   // multiply y by scaleY to get pixels
                                          int dcm,              // 1/10/100/1000 (should match format)
                                          int indent,   // indentation
                                          const char * frmt, // output format as "%d.%01d 123.4 -%d.%01d"
                                          int * edgeNumS,       // 4-element integer array - y,x,orient(0,1),dir(0,1)
                                          int x0, int y0, int x1, int y1, // window of interest 
                                          short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]) {
  int yp=     -1;
  int xp=     -1;
  int x,y;
  int nOutPoints=0;
  int nPoints=0;
  int edgeNum[4];
  int edgeNumP[4];
  int found;
  MD1(fprintf(stderr,"exportIsolineCoord:lclosed= %x scaleX=%d, scaleY=%d, dcm=%d, indent=%d, frmt=%s, edgeNumS=[%d %d %d %d], x0=%d, y0=%d, x1=%d, y1=%d\r\n",closed, scaleX, scaleY, dcm, indent, frmt, edgeNumS[0], edgeNumS[1], edgeNumS[2], edgeNumS[3], x0, y0, x1, y1));


  memcpy( edgeNum, edgeNumS, sizeof(edgeNum)); // copy start edge
  MD1(fprintf(stderr," -- exportIsolineCoord: edgeNum=[%d %d %d %d]\r\n", edgeNum[0], edgeNum[1], edgeNum[2], edgeNum[3]));

  while(1) {
//    calculate coordinates to output
    x=edgeNum[1]*scaleX*dcm + ((edgeNum[2]==0)?((edArr[edgeNum[0]][edgeNum[1]][0]*scaleX*dcm)/EDGEFRACTMAX):0);
    y=edgeNum[0]*scaleY*dcm + ((edgeNum[2]==1)?((edArr[edgeNum[0]][edgeNum[1]][1]*scaleY*dcm)/EDGEFRACTMAX):0);
  MD1(fprintf(stderr,"edgeNum=[%d %d %d %d], scaleX=%d, scaleY=%d, dcm=%d\r\n", edgeNum[0], edgeNum[1], edgeNum[2], edgeNum[3], scaleX, scaleY, dcm));
  MD1(fprintf(stderr,"x=%d, y=%d, xp=%d, yp=%d, nPoints=%d\r\n", x, y, xp, yp, nPoints));

        if ((x!=xp) || (y!=yp) || (nPoints==0)) {
      if (nOutPoints) gzprintf(gzfile,",\n");
          gzprintf(gzfile,indentString(indent,0));
          if (dcm==1) gzprintf(gzfile,frmt,x,y);
          else gzprintf(gzfile,frmt,x/dcm,x%dcm,y/dcm,y%dcm);
          xp=x;
          yp=y;
          nOutPoints++;
        } // if ((x!=xp) || (y!=yp) || (npoints==0))
// break here if nowhere to go in "open" mode
    if (!closed) {
          if (edgeNum[2]) {
            if (edgeNum[3]) {
                   if (edgeNum[1]== x0) break;
                } else { // if (edgeNum[3])
                   if (edgeNum[1]== x1) break;
                } // if (edgeNum[3])
          } else { // if (edgeNum[2])
            if (edgeNum[3]) {
                   if (edgeNum[0]== y0) break;
                } else { // if (edgeNum[3])
                   if (edgeNum[0]== y1) break;
                } // if (edgeNum[3])
          } // if (edgeNum[2])
        }
    
//      find next point
        memcpy( edgeNumP, edgeNum, sizeof(edgeNumP)); // save previous edge
  MD1(fprintf(stderr," --- exportIsolineCoord: edgeNum=[%d %d %d %d]\r\n", edgeNum[0], edgeNum[1], edgeNum[2], edgeNum[3]));

        found= findNextEdge  (edgeNum, x0, y0, x1, y1, edArr);
  MD1(fprintf(stderr,"findNextEdge () returned %d, edgeNum=[%d %d %d %d]\r\n",found, edgeNum[0], edgeNum[1], edgeNum[2], edgeNum[3]));

// erase previous edge (if not first in closed mode)
    if ((nPoints) || !closed) edArr[edgeNumP[0]][edgeNumP[1]][edgeNumP[2]]=-1;
// break here in "closed" mode if new edge is the same as the starting one
    if (closed && (edgeNum[0]==edgeNumS[0]) && (edgeNum[1]==edgeNumS[1]) && (edgeNum[2]==edgeNumS[2]))  break;
        nPoints++;
  }// while (1)
  MD1(fprintf(stderr," ---- exportIsolineCoord: edgeNum=[%d %d %d %d]\r\n", edgeNum[0], edgeNum[1], edgeNum[2], edgeNum[3]));

  edArr[edgeNum[0]][edgeNum[1]][edgeNum[2]]=-1; // erase start point in closed mode, last - in open
  return nOutPoints;
}

// will rely on DEF of Appearance
int exportIsolineNode  (int level,
                                          int scaleX,   // multiply x by scaleX to get pixels
                                          int scaleY,   // multiply y by scaleY to get pixels
                                          int dcm,              // 1/10
                                          int indent, //if 0 - all will be 0, else - 1 per level
                                          const char * charZ,   // string representation of z (VRML-y) of the countour (0 or level)
                                          const char * Appearance,      // name of appearance to use (should be defined earlier)
                                          int x0, int y0, int x1, int y1, // window of interest
                                          int vert[MAX_VERTEX_Y][MAX_VERTEX_X],
                                          short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2]) {
  int edgeNum[]={0,0,0,0};
  int nIsolines=0;
  int found;
  int nl,i;
  char frmt[40];
  char ddi[]="%d";
  char ddf[]= "%d.%0";
  int printPos,printPosInc;
  edgeNum[0]=y0;
  edgeNum[1]=x0;
  MD1(fprintf(stderr,"exportIsolineNode:level= %x scaleX=%d, scaleY=%d, dcm=%d, indent=%d, charZ=%s, Appearance=%s, x0=%d, y0=%d, x1=%d, y1=%d\r\n",level, scaleX, scaleY, dcm, indent, charZ, Appearance, x0, y0, x1, y1));

// prepare edges array, see if there is any Isoline
  i=fillEdgesArray (level, x0,  y0, x1,  y1, vert, edArr);
  MD1(fprintf(stderr,"fillEdgesArray returned %d\r\n",i));
#ifdef DEBUG_CONT
  printEdgesArray (x1+1,y1+1, edArr);
#endif
  if   (i==0) return 0;
  gzprintf(gzfile,"%sGroup {\n"
            "%schildren [\n",indentString(indent,0),indentString(indent,1));
  while ((found= findStartEdge  (edgeNum, x0, y0, x1, y1, edArr))) { // found=1 -"open", 2 - "closed"
    MD1(fprintf(stderr,"findStartEdge ([%d %d %d %d],...) returned %d\r\n",edgeNum[0],edgeNum[1],edgeNum[2],edgeNum[3],found));

    nIsolines++;
    gzprintf(gzfile,"%sShape {\n"
             "%sappearance USE %s\n"
             "%sgeometry IndexedLineSet {\n"
              "%scoord Coordinate { point [\n",
                indentString(indent,2),
                indentString(indent,3),Appearance,
                indentString(indent,3),
                indentString(indent,4));
// prepare frmt;
    switch (dcm) {
      case 10:   {i=1;break;}
      case 100:  {i=2;break;} // not supported
      case 1000: {i=3;break;} // not supported
          default: {
            i=0;
            dcm=1;
          }
    }
    if (dcm==1) sprintf(frmt,"%s %s -%s", ddi, charZ, ddi);
    else                sprintf(frmt,"%s%dd %s -%s%dd", ddf, i, charZ, ddf, i);
    nl=exportIsolineCoord ((found==2), scaleX, scaleY,
                                  dcm,          // 1/10/100/1000 (should match format)
                                          (indent>=0)?(indent+5):-1,    // indentation
                                          frmt, // output format as "%d.%01d 123.4 -%d.%01d"
                                          edgeNum,      // will not be modified
                                          x0, y0, x1, y1, edArr);
    MD1(fprintf(stderr,"exportIsolineCoord (...) returned %d\r\n",nl));
        gzprintf(gzfile,"]\n%s}\n",indentString(indent,4));
    if (nl) { // export coordindex
      gzprintf(gzfile,"%scoordIndex [%n", indentString(indent,4),&printPos);
          for (i=0;i<nl;i++) {
        if (printPos>LINEWIDTH2BREAK) gzprintf(gzfile,"\n%s%n", indentString(indent,5),&printPos); // limit long lines
        gzprintf(gzfile,"%d,%n",i,&printPosInc);
        printPos+=printPosInc;
          }
          if (found==2) gzprintf(gzfile,"0,");
          gzprintf(gzfile,"-1]\n");
        }
        gzprintf(gzfile,"%s}\n%s}\n", indentString(indent,3), indentString(indent,2)); // close IndexedLineSet, Shape

  } // while ((found= findStartEdge  (edgeNumS, x0, y0, x1, y1, edArr)))
  gzprintf(gzfile,"%s]}\n",indentString(indent,0));  // close children, Group
  return nIsolines;
}
void exportVRMLStart(int level) { // compression level - 0..9 (o - plain text)
// Start VRML file, output constant portions
  char mode[3];
  if (level<0) level=0;
  if (level>9) level=9;
  sprintf(mode,"w%d",level);
  MD2(fprintf(stderr,"exportVRMLStart level= %d mode=%s\r\n",level, mode));

  printf("Content-Type: x-world/x-vrml\n\n"); // 2 new lines!
// now start the compressor
    gzfile = gz_useFile (stdout, mode); // modified to shortcut gzprintf to printf if "w0"
    if (gzfile == NULL) {
        fprintf(stderr, "gzdopen error\n");
        exit(1);
    }
    gzprintf(gzfile,"#VRML V2.0 utf8\n" \
                 "# generated by Elphel Model 303 camera, http://www.elphel.com\n" \
                 "\n" \
                 "NavigationInfo {\n" \
                 "      type       [\"EXAMINE\", \"ANY\"]" \
                 "      avatarSize [2.5, 16, 7.5]\n" \
                 "      speed      100.0\n" \
                 "      headlight  TRUE\n" \
                 "}\n" );

}
void exportVRMLViewpoints(int width, int height, int elev) {

// output 4 corner viewpoints and two top ones
  int camheight=elev>>1;
  gzprintf(gzfile,"DEF VP00 Viewpoint {\n" \
                 "  fieldOfView 0.75\n"\
                 "  orientation 0 1 0 -0.785398\n" \
                 "  position %d %d %d\n" \
                 "  description \"View from x- y-\"\n" \
                 "}\n",-width,camheight,height);
  gzprintf(gzfile,"DEF VP10 Viewpoint {\n" \
                 "  fieldOfView 0.75\n"\
                 "  orientation 0 1 0 0.785398\n" \
                 "  position %d %d %d\n" \
                 "  description \"View from x+ y-\"\n" \
                 "}\n",width+width,camheight,height);
  gzprintf(gzfile,"DEF VP11 Viewpoint {\n" \
                 "  fieldOfView 0.75\n"\
                 "  orientation 0 1 0 2.356194\n" \
                 "  position %d %d %d\n" \
                 "  description \"View from x+ y+\"\n" \
                 "}\n",width+width,camheight,-height-height);
  gzprintf(gzfile,"DEF VP01 Viewpoint {\n" \
                 "  fieldOfView 0.75\n"\
                 "  orientation 0 1 0 -2.356194\n" \
                 "  position %d %d %d\n" \
                 "  description \"View from x- y+\"\n" \
                 "}\n",-width,camheight,-height-height);
  gzprintf(gzfile,"DEF VPTOP Viewpoint {\n" \
                 "  fieldOfView 0.75\n"\
                 "  orientation 1 0 0 -1.570796\n" \
                 "  position %d %d %d\n" \
                 "  description \"Top view\"\n" \
                 "}\n",width>>1,elev*2,-(height>>1));
  gzprintf(gzfile,"DEF VPTOPFAR Viewpoint {\n" \
                 "  fieldOfView 0.025\n"\
                 "  orientation 1 0 0 -1.570796\n" \
                 "  position %d %d %d\n" \
                 "  description \"Far top view\"\n" \
                 "}\n",width>>1,elev*60,-(height>>1));
}



// ****************************************************
//returns <0 - errror, (vertNum_x & 0xfff) | ((vertNum_y & 0xfff) << 12) if OK
int initVertexArray (const char * dmaFileName,
                                        int     width,
                                        int height,
                                        int maxpixel,   // maximal pixel (full scale -= 1024, 0 - auto normalize)
                                        int decimate_x, // rectangle width to be combined in one vertex
                                        int decimate_y, // rectangle height to be combined in one vertex
                                        int vert[MAX_VERTEX_Y][MAX_VERTEX_X] // vertex array
                                        ) {
//#define MAX_VERTEX_X 161
//#define MAX_VERTEX_Y 129
   int   vertNum_x;
   int   vertNum_y;
   int i,DMALongsPerRow,data_fd;
   unsigned long        * DMAData;  // opened through mmap
   int y,iy,x,ix,l,d,k;


   if ( (width>MAX_IMAGE_WIDTH) ||
        (width<=0) ||
            (height>MAX_IMAGE_HEIGHT) ||
        (height<=0) ) return -1;
   vertNum_x=   width/decimate_x;
   if (vertNum_x > MAX_VERTEX_X) {
     decimate_x=  width/MAX_VERTEX_X;
         if (decimate_x==0) decimate_x=1;
         if ((width/decimate_x) > MAX_VERTEX_X) decimate_x++;
         vertNum_x=     width/decimate_x;
   }

   vertNum_y=   height/decimate_y;
   if (vertNum_y > MAX_VERTEX_Y) {
     decimate_y=  height/MAX_VERTEX_Y;
         if (decimate_y==0) decimate_y=1;
         if ((height/decimate_y) > MAX_VERTEX_Y) decimate_y++;
         vertNum_y=     height/decimate_y;
   }

   i=width/3;
   DMALongsPerRow = (3*i == width)? i: i+1;
//try open dmaFileName
   if ((data_fd = open(dmaFileName, O_RDONLY))==-1) return -2; // file open error
 MD(fprintf(stderr,"\r\n"));
        DMAData = (unsigned long *) mmap(0, (DMALongsPerRow*height)<<2, PROT_READ, MAP_OPTIONS, data_fd, 0);
   MD(fprintf(stderr,"vertNum_x - %d, vertNum_y -  %d, decimate_x - %d, decimate_y - %d\n",\
        vertNum_x, vertNum_y, decimate_x, decimate_y));

        if((int)(DMAData) == -1) { // Error in mmap
                close(data_fd);
                return -3;
        }
   MD(fprintf(stderr,"sizeof(vert) = %x\n",sizeof(vert)));
// now prepare the integer vertex array
    memset (vert, 0,MAX_VERTEX_Y*MAX_VERTEX_X*4);

        for (y=0;y<vertNum_y;y++) {
          for (iy=0;iy<decimate_y;iy++){

            l=DMALongsPerRow*((vertNum_y-y-1)*decimate_y+iy);
            d=DMAData[l++];
            k=0;
            for (x=0;x<vertNum_x;x++) {
//    if ((iy==0) &&(vert[y][x])) {
//   MD(fprintf(stderr,"vert[%d][%d]= %d\n",y, x, vert[y][x]));
//    }
              for (ix=0;ix<decimate_x;ix++){
                vert[y][x]+=(d>>k)&0x3ff;
                if ((k+=10)>20) {
                     k=0;
                     d=DMAData[l++];
                    }
                  }

            }
          }
        }
// adjust maxpixel
  if (maxpixel >0) {
    if (maxpixel > 1024) maxpixel=1024;
        maxpixel=maxpixel*decimate_x*decimate_y;
  } else {
// find maximum
        maxpixel=decimate_x*decimate_y;//to protect from 0-s
        for (y=0;y<vertNum_y;y++)
          for (x=0;x<vertNum_x;x++)
            if (vert[y][x] > maxpixel) maxpixel= vert[y][x];
  }
//  normalize vert[y][x] to MYMAXINT
  i=0;
  while (maxpixel>0xffff) {
    maxpixel >>=1;
    i++;
  }
  k= MYMAXINT/maxpixel;
        for (y=0;y<vertNum_y;y++)
          for (x=0;x<vertNum_x;x++)
            vert[y][x]= k*(vert[y][x]>>i);

// maximum height will be equal to maximum of 2 dimensions - change here if needed
   MD(fprintf(stderr,"vertNum_x - %d, vertNum_y -  %d, decimate_x - %d, decimate_y - %d\n",\
        vertNum_x, vertNum_y, decimate_x, decimate_y));

  return (vertNum_x & 0xfff) | ((vertNum_y & 0xfff) << 12);

}


void exportFacesAppearance(const char * aname, const char * mname, double transparency) {
  gzprintf(gzfile,"DEF %s Appearance {\n" \
                 " material DEF %s Material     {\n" \
                 "  transparency %f\n" \
                 " }\n" \
                 "}\n", aname, mname, transparency);
}

void exportIsolinesAppearance(const char * prefix, int numLev) {
 int i,l;
 char cs[20];
 gzprintf(gzfile,"DEF %s Group  {children [\n",prefix); 
 for (i=0;i<numLev;i++) {
   l=(2*i+1)*(MYMAXINT/(numLev<<1));
   gzprintf(gzfile," DEF %s_%d Appearance { material Material { emissiveColor %s }}\n",prefix,i,pseudoColorStr(cs,l));
 }
 gzprintf(gzfile,"]}\n"); 
}
void exportCoordinateSet(const char * name,
                                                 int width, int height, // number of vertexes is (width+1)*(height+1) !!
                                                 int elev,
                                                 int scale_X, int scale_Y,
                                                 int dcp,       // 0 or 1 only
                                                 int indent,
                                                 int vert[MAX_VERTEX_Y][MAX_VERTEX_X]) {
 int x,y,sx,sy,k;
 int zi,zf;

 if (dcp) {
    dcp=1;
        elev=10*elev;
 }
 k=(elev<<16)/(MYMAXINT>>16);
 gzprintf(gzfile,"DEF %s        Coordinate { point [\n",name);
 for (y=0;y<=height;y++) {
   sy=y*scale_Y;
   for (x=0;x<=width;x++) {
     sx=x*scale_X;
         zf=((vert[y][x]>>16)*k)>>16;
         if (dcp) {
           zi=zf/10;zf-=10*zi;
           gzprintf(gzfile,"%s%d 0 %d, %d %d.%01d %d",indentString(indent,1),sx,-sy,sx,zi,zf,-sy);
         } else { // if (dcp)
           gzprintf(gzfile,"%s%d 0 %d, %d %d %d",indentString(indent,1),sx,-sy,sx,zf,-sy);
         }  // if (dcp)
         if (x<width) gzprintf(gzfile,",\n");
   }
   if (y<height) gzprintf(gzfile,",\n");
 }
 gzprintf(gzfile,"]}\n");
}
void exportColorSet(const char * name,
                                        int width, int height,
                                        int indent,
                                        int vert[MAX_VERTEX_Y][MAX_VERTEX_X]) {
 int x,y;
 char bottomColor[20];
 char topColor[20];
 pseudoColorStr(bottomColor,0);
        
 gzprintf(gzfile,"DEF %s        Color {color[\n",name);
 for (y=0;y<=height;y++) {
   for (x=0;x<=width;x++) {
         gzprintf(gzfile,"%s%s, %s",indentString(indent,1), bottomColor, pseudoColorStr(topColor,vert[y][x]));
         if (x<width) gzprintf(gzfile,",\n");
   }
   if (y<height) gzprintf(gzfile,",\n");
 }
 gzprintf(gzfile,"]}\n");
}

void exportSwitchStart(const char * name, const char * suffics, int * ind) {
   gzprintf(gzfile,"%sDEF %s%s Switch {\n"
          "%swhichChoice 0\n"
          "%schoice [ Group {  children [\n",indentString(*ind,0),name, suffics,
                                                                                 indentString(*ind,1),
                                                                                 indentString(*ind,1));
  if (*ind>=0) *ind+=2;
}

void exportSwitchEnd(int * ind) {
  if (*ind>=0) *ind-=2;
   gzprintf(gzfile,"%s]}]\n"
          "%s}\n",indentString(*ind,1),
                                 indentString(*ind,0));
}

void exportTransformStart(const char * name, const char * suffics, int * ind) {
   if ((name) && (strlen(name)>0)) {
     gzprintf(gzfile,"%sDEF %s",indentString(*ind,0),name);
     if ((suffics) && (strlen(suffics)>0))      gzprintf(gzfile,"%s", suffics);
     gzprintf(gzfile," ");
   } else  gzprintf(gzfile,"%s",indentString(*ind,0));
   gzprintf(gzfile,"Transform {\n"
          "%sscale      1 1 1\n"
          "%schildren [\n", indentString(*ind,1),
                            indentString(*ind,1));
  if (*ind>=0) *ind+=2;
}
void exportTransformEnd(int * ind) {
  if (*ind>=0) *ind-=2;
   gzprintf(gzfile,"%s]\n"
          "%s}\n",indentString(*ind,1),
                  indentString(*ind,0));
}


void exportIFSStart       (const char * app,                       // name of Appearance to use (may be NULL)
                       const char * coord,                         // name of Coordinate to use (may NOT be NULL)
                                           const char * color,                     // name of Color to use              (may be NULL)
                                           int * ind) {                                    // address of indent value
   gzprintf(gzfile,"%sShape {\n",indentString(*ind,0));
   if (app) gzprintf(gzfile,"%sappearance USE %s\n",indentString(*ind,1),app);
   gzprintf(gzfile,"%sgeometry IndexedFaceSet {\n"
          "%sccw TRUE\n"
          "%ssolid TRUE\n"
          "%sconvex FALSE\n"
          "%scoord USE %s\n",indentString(*ind,1),
                                                 indentString(*ind,2),
                                                 indentString(*ind,2),
                                                 indentString(*ind,2),
                                                 indentString(*ind,2),coord);
   if (color) gzprintf(gzfile,"%scolor USE %s\n",indentString(*ind,2),color);
   gzprintf(gzfile,"%scoordIndex [\n",indentString(*ind,2));

  if (*ind>=0) *ind+=3;
}

void exportILSStart (const char * app,     // name of Appearance to use (may be NULL)
                     const char * coord,   // name of Coordinate to use (may NOT be NULL)
                     const char * color,   // name of Color to use      (may be NULL)
                     int * ind) {                                          // address of indent value
   gzprintf(gzfile,"%sShape {\n",indentString(*ind,0));
   if (app) gzprintf(gzfile,"%sappearance USE %s\n",indentString(*ind,1),app);
   gzprintf(gzfile,"%sgeometry IndexedLineSet {\n"
          "%scoord USE %s\n",indentString(*ind,1),
                                                 indentString(*ind,2),coord);
   if (color) gzprintf(gzfile,"%scolor USE %s\n",indentString(*ind,2),color);
   gzprintf(gzfile,"%scoordIndex [\n",indentString(*ind,2));

  if (*ind>=0) *ind+=3;
}

void exportIFLSEnd        (int * ind) {                                    // address of indent value
  if (*ind>=0) *ind-=3;
   gzprintf(gzfile,"]\n"
          "%s}\n"
          "%s}\n",indentString(*ind,1),
                   indentString(*ind,0));
}


void exportTopFaces   (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * app,                           // name of Appearance to use
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) {                                    // address of indent value
  int x,y,i,j,d;
  exportIFSStart (app, coord, color,ind);
  d=rowLen<<1;
  for (y=y0;y<y1;y++) {
    i=((rowLen*y)<<1)+1;
    for (x=x0;x<x1;x++) {
#if 0
// "square" faces
      gzprintf(gzfile,"%s%d,%d,%d,%d,%d,-1",
                                   indentString(*ind,0),
                                   (j=(i+(x<<1))),
                                   j+2,
                                   j+2+d,
                                   j+d,
                                   j);
#else
// triangular faces
      gzprintf(gzfile,"%s%d,%d,%d,%d,-1,%d,%d,%d,%d,-1",
                                   indentString(*ind,0),
                                   (j=(i+(x<<1))),
                                   j+2,
                                   j+2+d,
                                   j,
                                   j,
                                   j+2+d,
                                   j+d,
                                   j);
#endif

          if (x<(x1-1)) gzprintf(gzfile,",\n");
    } // for (x=x0;x<x1;x++)
        if (y<(y1-1)) gzprintf(gzfile,",\n");
  } // for (y=y0;y<y1;y++)
  exportIFLSEnd  (ind);
}

void exportBottomFaces(int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * app,                           // name of Appearance to use
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) {                                    // address of indent value
  exportIFSStart (app, coord, color,ind);
  gzprintf(gzfile,"%s%d,%d,%d,%d,%d,-1",
                              indentString(*ind,0),
                              (rowLen*y0+x0)<<1,
                              (rowLen*y1+x0)<<1,
                              (rowLen*y1+x1)<<1,
                              (rowLen*y0+x1)<<1,
                              (rowLen*y0+x0)<<1);
  exportIFLSEnd  (ind);
}

void exportSideFaces  (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * app,                           // name of Appearance to use
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                       int wallNum,                                        // wall number (0..3)
                                           int * ind) {                                    // address of indent value
  int i0,i1,di,n,j,i;
  int printPos,printPosInc;
  exportIFSStart (app, coord, color,ind);
  if ((wallNum>=0)  && (wallNum <=3)) {
    switch (wallNum) {
      case 0: {
            i0=(rowLen*y0+x0)<<1;
            i1=(rowLen*y0+x1)<<1;
            di=-2;
            n=x1-x0;
            break;}
      case 1: {
            i0=(rowLen*y0+x1)<<1;
            i1=(rowLen*y1+x1)<<1;
            di=-((rowLen)<<1);
            n=y1-y0;
            break;}
      case 2: {
            i0=(rowLen*y1+x1)<<1;
            i1=(rowLen*y1+x0)<<1;
            di=2;
            n=x1-x0;
            break;}
//     case 3: {
      default: {
            i0=(rowLen*y1+x0)<<1;
            i1=(rowLen*y0+x0)<<1;
            di=(rowLen)<<1;
            n=y1-y0;
            break;}
    }
//    gzprintf(gzfile,"%s%d,%d", indentString(*ind,0), i0,i1);
    gzprintf(gzfile,"%s%d,%d,%n", indentString(*ind,0), i0,i1,&printPos);
    i=i1+1;
    for (j=0; j<=n; j++) {
//      if (!(j&0x3f)) gzprintf(gzfile,"\n%s", indentString(*ind,1)); // limit long lines
        if (printPos>LINEWIDTH2BREAK) gzprintf(gzfile,"\n%s%n", indentString(*ind,1),&printPos); // limit long lines
//      gzprintf(gzfile,"%d,",i+=di);
//      gzprintf(gzfile,"%d,",i); i+=di;
      gzprintf(gzfile,"%d,%n",i,&printPosInc);
      printPos+=printPosInc;
      i+=di;
    }
    gzprintf(gzfile,"%d,-1", i0);
  } // if ((wallNum>=0)  && (wallNum <=3))
  exportIFLSEnd  (ind);
}

void exportTopEdges   (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) {                                    // address of indent value
  int x,y,i,j,di;
  int printPos,printPosInc;

  exportILSStart   (NULL, coord, color,ind);
  for (y=y0;y<=y1;y++) {
    i=((rowLen*y+x0)<<1)+1;
    gzprintf(gzfile,"\n%s%n", indentString(*ind,0), &printPos);
    for (j=1;j<=(x1-x0+1);j++) {
      if (printPos>LINEWIDTH2BREAK) gzprintf(gzfile,"\n%s%n", indentString(*ind,1),&printPos); // limit long lines
      gzprintf(gzfile,"%d,%n",i,&printPosInc);
      printPos+=printPosInc;
      i+=2;
        }
        gzprintf(gzfile,"-1");
  }

  di=rowLen<<1;
  for (x=x0;x<=x1;x++) {
    i=((rowLen*y0+x)<<1)+1;
    gzprintf(gzfile,"\n%s%n", indentString(*ind,0), &printPos);
    for (j=1;j<=(y1-y0+1);j++) {
      if (printPos>LINEWIDTH2BREAK) gzprintf(gzfile,"\n%s%n", indentString(*ind,1),&printPos); // limit long lines
      gzprintf(gzfile,"%d,%n",i,&printPosInc);
      printPos+=printPosInc;
      i+=di;
        }
        gzprintf(gzfile,"-1");
  }
  exportIFLSEnd  (ind);
}
void exportBottomEdges(int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                                           int * ind) {                                    // address of indent value
  exportILSStart (NULL, coord, color,ind);
  gzprintf(gzfile,"%s%d,%d,%d,%d,%d,-1",
                                   indentString(*ind,0),
                                                           (rowLen*y0+x0)<<1,
                                                           (rowLen*y1+x0)<<1,
                                                           (rowLen*y1+x1)<<1,
                                                           (rowLen*y0+x1)<<1,
                                                           (rowLen*y0+x0)<<1);
  exportIFLSEnd  (ind);
}

void exportSideEdges   (int x0, int y0, int x1,int y1,  // window parameters
                       int rowLen,                                         // number of vertexes in a row
                       const char * coord,                         // name of Coordinate to use
                                           const char * color,                     // name of Color to use
                       int wallNum,                                        // wall number (0..3)        
                                           int * ind) {                                    // address of indent value   
  int i,di,n,j;                                         
  exportILSStart (NULL, coord, color,ind);

  if ((wallNum>=0)  && (wallNum <=3)) {
    switch (wallNum) {
      case 0: {
            i=(rowLen*y0+x0)<<1;
            di=2;
            n=x1-x0;
            break;}
      case 1: {
            i=(rowLen*y0+x1)<<1;
            di=((rowLen)<<1);
            n=y1-y0;
            break;}
      case 2: {
            i=(rowLen*y1+x1)<<1;
            di=-2;
            n=x1-x0;
            break;}
//      case 3: {
      default: {
            i=(rowLen*y1+x0)<<1;
            di=-((rowLen)<<1);
            n=y1-y0;
            break;}
    }
    for (j=0; j<n; j++) {
      gzprintf(gzfile,"%s%d,%d,-1,\n", indentString(*ind,0), i, (i+=di)+1);
        }
    gzprintf(gzfile,  "%s%d,%d,-1", indentString(*ind,0), i, i+1);
  } // if ((wallNum>=0)  && (wallNum <=3))
  exportIFLSEnd  (ind);
}


//**********************************************
int export_vrml (const char * dmaFileName,
                 int width,
                 int height,
                 int maxpixel,       // maximal pixel (full scale -= 1024, 0 - auto normalize)
                 int decimate_x,     // rectangle width to be combined in one vertex
                 int decimate_y,     // rectangle height to be combined in one vertex
                 int blocks_x,       // number of separate blocks in x direction
                 int blocks_y,       // number of separate blocks in y direction
                 int indent,         // VRML text indentation (0/1)
                 int dcp,            // number of coordinate digits after "." - 0,1,2,3
                 int nIsolines,      // number of isolines to build
                 int genFlatIso,     // 0/1, generate flat isolines with Z=0
                 int genElevIso,     // 0/1, generate elevated isolines with Z matching intensity
                 const char * colors, // string of pseudocolors, i.e "BR" or "mbcgyr" or "546231" 
                 int compressionLevel // gzip compression level for VRML file (0 - plain text out)
                 ) {
   
//#define MAX_VERTEX_X 161
//#define MAX_VERTEX_Y 129
   int   vert[MAX_VERTEX_Y][MAX_VERTEX_X];
   short edArr[MAX_VERTEX_Y+1][MAX_VERTEX_X+1][2];

   char s[256];
   char s1[256];
   int   elev,i,j,l,level;

   int   vertNum_x;
   int   vertNum_y;
   int   x0,x1,y0,y1,zf,zi;

   MD(fprintf(stderr,"&vert[0][0] = %x, &edArr[0][0][0] = %x\r\n", (int) &vert[0][0], (int) &edArr[0][0][0]));


// change indent 0(no) ->-1, >0(yes)->0
   indent=indent?0:-1;
// set nIsolines=0 if none are selected
   if (!genFlatIso && !genElevIso) nIsolines=0;
   if (nIsolines==0) {genFlatIso=0; genElevIso=0;}
   MD(fprintf(stderr,"dmaFileName- %s, width - %d, height -  %d, decimate_x - %d, decimate_y - %d, blocks_x - %d, blocks_y - %d\r\n",\
                                        dmaFileName,width,height,decimate_x, decimate_y, blocks_x, blocks_y));
// fix decimation/number of blocks
   if (decimate_x <1) decimate_x=1;
   if (decimate_y <1) decimate_y=1;
   if (blocks_x    <1) blocks_x=   1;
   if (blocks_y    <1) blocks_y=   1;
// build vertex array normalized to MYMAXINT, return if error
//returns <0 - errror, (vertNum_x & 0xfff) | ((vertNum_y & 0xfff) << 12) if OK
   if ((i= initVertexArray (dmaFileName,        width, height, maxpixel, decimate_x,  decimate_y, vert))<0) return i;
   vertNum_x= i & 0xfff;
   vertNum_y= (i>>12) & 0xfff;

// adjust height and width to get rid of partial rectangles (after DMALongsPerRow calculation)
   width= (vertNum_x-1)*decimate_x;
   height=(vertNum_y-1)*decimate_y;

// maximum height will be equal to maximum of 2 dimensions - change here if needed
   elev=(height>width)?height:width;
   MD(fprintf(stderr,"vertNum_x - %d, vertNum_y -  %d, decimate_x - %d, decimate_y - %d\n",\
        vertNum_x, vertNum_y, decimate_x, decimate_y));
// init pseudo color structure
  initPseudoColor(colors);
// Start VRML file, output constant part
  exportVRMLStart(compressionLevel); // gzip compression level for VRML file (0 - plain text out)
// output WorldInfo
 gzprintf(gzfile,"DEF WORLDINFO WorldInfo {\n" \
        " title  \"Elphel Model 303 3D visualization\"\n" \
                " info [\n" \
                "  \"width=     %4d\", # number of image pixels used (x direction)\n" \
                "  \"height=    %4d\", # number of image pixels used (y direction)\n" \
                "  \"maxpixel=  %4d\", # maximal pixel (full scale -= 1024, 0 - auto normalize)\n" \
                "  \"decimate_x=%4d\", # rectangle width to be combined in one vertex\n" \
                "  \"decimate_y=%4d\", # rectangle height to be combined in one vertex\n" \
                "  \"blocks_x=  %4d\", # number of separate blocks in x direction\n" \
                "  \"blocks_y=  %4d\", # number of separate blocks in y direction\n" \
                "  \"indent=    %4d\", # VRML text indentation (0/1)\n" \
                "  \"dcp=       %4d\", # number of coordinate digits after \".\" - 0,1(,2,3)\n" \
                "  \"nIsolines= %4d\", # number of isolines to build\n" \
                "  \"genFlatIso=%4d\", # generate flat isolines with Z=0\n" \
                "  \"genElevIso=%4d\", # generate elevated isolines lines with Z matching intensity\n" \
                "  \"colors=    %s\", # string of pseudocolors, i.e \"BR\" or \"mbcgyr\" or \"546231\"\n" \
                "  \"vertNum_x= %4d\", # model grid X size\n" \
                "  \"vertNum_y= %4d\"  # model grid Y size\n" \
                " ]\n}\n",
                  width,
                  height,
                  maxpixel,
                  decimate_x,
                  decimate_y,
                  blocks_x,
                  blocks_y,
                  indent,
                  dcp,
                  nIsolines,
                  genFlatIso,
                  genElevIso,
                  colors,
                  vertNum_x,
                  vertNum_y
                );


// output viewpoints
  exportVRMLViewpoints(width, height, elev);
  exportFacesAppearance("APP_FACES","MAT_FACES",0.2);
  if (nIsolines>0) exportIsolinesAppearance("APP_ISO", nIsolines);
  exportCoordinateSet("COORD_SET", vertNum_x-1, vertNum_y-1, elev, decimate_x, decimate_y, dcp, indent, vert);
  exportColorSet     ("COLOR_SET", vertNum_x-1, vertNum_y-1, indent, vert);
// enclose all geometry in "Transform" node to allow scaling everything
  exportTransformStart("ALL_GEOMETRY","", &indent);
// start switch that will allow to turn off all but isolines geometry
  exportSwitchStart("BLOCKS","", &indent);
// now iterate through all blocks
  for (i=0;i<blocks_y;i++) for (j=0;j<blocks_x;j++){
// overlapping corners of the blocks
    y0=(i*    (vertNum_y-1))/blocks_y;
        y1=((i+1)*(vertNum_y-1))/blocks_y;
    x0=(j*    (vertNum_x-1))/blocks_x;
        x1=((j+1)*(vertNum_x-1))/blocks_x;
        sprintf(s,"BLOCK_%d_%d",i,j);
    exportSwitchStart(s, "",&indent); // "BLOCK_yy_xx"
// export top geometry
      exportSwitchStart(s, "_TOP",&indent); // "BLOCK_yy_xx_TOP"
           exportTopFaces(x0,y0,x1,y1,vertNum_x,"APP_FACES","COORD_SET","COLOR_SET",&indent);
           exportTopEdges(x0,y0,x1,y1,vertNum_x,"COORD_SET","COLOR_SET",&indent);
      exportSwitchEnd( &indent); // "BLOCK_yy_xx_TOP"
// export bottom geometry
      exportSwitchStart(s, "_BOTTOM",&indent); // "BLOCK_yy_xx_BOTTOM"
           exportBottomFaces(x0,y0,x1,y1,vertNum_x,"APP_FACES","COORD_SET","COLOR_SET",&indent);
           exportBottomEdges(x0,y0,x1,y1,vertNum_x,"COORD_SET","COLOR_SET",&indent);
      exportSwitchEnd( &indent); // "BLOCK_yy_xx_BOTTOM"
// export side walls
      exportSwitchStart(s, "_Y0",&indent); // "BLOCK_yy_xx_Y0"
           exportSideFaces(x0,y0,x1,y1,vertNum_x,"APP_FACES","COORD_SET","COLOR_SET",0,&indent);
           exportSideEdges(x0,y0,x1,y1,vertNum_x,"COORD_SET","COLOR_SET",0,&indent);
      exportSwitchEnd( &indent); // "BLOCK_yy_xx_Y0"

      exportSwitchStart(s, "_X1",&indent); // "BLOCK_yy_xx_X1"
           exportSideFaces(x0,y0,x1,y1,vertNum_x,"APP_FACES","COORD_SET","COLOR_SET",1,&indent);
           exportSideEdges(x0,y0,x1,y1,vertNum_x,"COORD_SET","COLOR_SET",1,&indent);
      exportSwitchEnd( &indent); // "BLOCK_yy_xx_X1"

      exportSwitchStart(s, "_Y1",&indent); // "BLOCK_yy_xx_Y1"
           exportSideFaces(x0,y0,x1,y1,vertNum_x,"APP_FACES","COORD_SET","COLOR_SET",2,&indent);
           exportSideEdges(x0,y0,x1,y1,vertNum_x,"COORD_SET","COLOR_SET",2,&indent);
      exportSwitchEnd( &indent); // "BLOCK_yy_xx_Y1"

      exportSwitchStart(s, "_X0",&indent); // "BLOCK_yy_xx_X0"
           exportSideFaces(x0,y0,x1,y1,vertNum_x,"APP_FACES","COORD_SET","COLOR_SET",3,&indent);
           exportSideEdges(x0,y0,x1,y1,vertNum_x,"COORD_SET","COLOR_SET",3,&indent);
      exportSwitchEnd( &indent); // "BLOCK_yy_xx_X0"
    exportSwitchEnd( &indent); // "BLOCK_yy_xx"
  } // for (i=0;i<blocks_y;i++) for (j=0;j<blocks_x;j++)
  exportSwitchEnd( &indent); // "BLOCKS"

/*
 int genFlatIso, // 0/1, generate flat isolines with Z=0
 int genElevIso, // 0/1, generate elevated isolines with Z matching intensity

*/
  if (genFlatIso) {
    MD(fprintf(stderr,"export_vrml: flat isolines\r\n"));
    exportSwitchStart("ISO_FLAT", "",&indent); // "ISO_FLAT"
    for (i=0;i<blocks_y;i++) for (j=0;j<blocks_x;j++){
// overlapping corners of the blocks
      y0=(i*    (vertNum_y-1))/blocks_y;
          y1=((i+1)*(vertNum_y-1))/blocks_y;
      x0=(j*    (vertNum_x-1))/blocks_x;
          x1=((j+1)*(vertNum_x-1))/blocks_x;
          sprintf(s,"ISO_FLAT_%d_%d",i,j);
      exportSwitchStart(s, "",&indent); // "ISO_FLAT_yy_xx"
          for (l=0;l<nIsolines;l++) {
        level=(2*l+1)*(MYMAXINT/(nIsolines<<1));
                sprintf(s,"APP_ISO_%d",l);
        exportIsolineNode  (level,
                                                  decimate_x, decimate_y,
                                              dcp?10:0,                                 // 1/10
                                              indent,                                   // if -1 - all will be 0, else - 1 per level
                                              "0",                                              // string representation of z (VRML-y) of the countour (0 or level)
                                              s,                                                // name of appearance to use (should be defined earlier)
                                              x0, y0, x1, y1,                   // window of interest
                                              vert,                                             // array of vertex Z values
                                              edArr);
          }
      exportSwitchEnd( &indent); // "ISO_FLAT_yy_xx"
    } // for (i=0;i<blocks_y;i++) for (j=0;j<blocks_x;j++)
    exportSwitchEnd( &indent); // "ISO_FLAT"
  } // if (genFlatIso)
  if (genElevIso) {
    MD(fprintf(stderr,"export_vrml: elevated isolines\r\n"));
    exportSwitchStart("ISO_ELEV", "",&indent); // "ISO_ELEV"
    for (i=0;i<blocks_y;i++) for (j=0;j<blocks_x;j++){
// overlapping corners of the blocks
      y0=(i*    (vertNum_y-1))/blocks_y;
          y1=((i+1)*(vertNum_y-1))/blocks_y;
      x0=(j*    (vertNum_x-1))/blocks_x;
          x1=((j+1)*(vertNum_x-1))/blocks_x;
          sprintf(s,"ISO_ELEV_%d_%d",i,j);
      exportSwitchStart(s, "",&indent); // "ISO_ELEV_yy_xx"
          for (l=0;l<nIsolines;l++) {
        level=(2*l+1)*(MYMAXINT/(nIsolines<<1));
                sprintf(s,"APP_ISO_%d",l);
                if (dcp) {
                  zf=((level>>16)*(((elev*10)<<16)/(MYMAXINT>>16)))>>16;
              zi=zf/10;
              zf-=10*zi;
                  sprintf(s1,"%d.%01d",zi,zf); 
                } else { // if (dcp)
                  zf=((level>>16)*(( elev    <<16)/(MYMAXINT>>16)))>>16;
                  sprintf(s1,"%d",zf); 
                } // if (dcp)
        exportIsolineNode  (level,
                                                  decimate_x, decimate_y,
                                              dcp?10:0,                                 // 1/10
                                              indent,                                   // if -1 - all will be 0, else - 1 per level
                                              s1,                                               // string representation of z (VRML-y) of the countour (0 or level)
                                              s,                                                // name of appearance to use (should be defined earlier)
                                              x0, y0, x1, y1,                   // window of interest
                                              vert,                                             // array of vertex Z values
                                              edArr);
          }
      exportSwitchEnd( &indent); // "ISO_ELEV_yy_xx"
    } // for (i=0;i<blocks_y;i++) for (j=0;j<blocks_x;j++)

    exportSwitchEnd( &indent); // "ISO_ELEV"
  } // if (genElevIso)
  exportTransformEnd( &indent); // "ALL_GEOMETRY"
  gzclose(gzfile);

  return 0; // all OK
}

---