开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
plvAnalyze.cc
资源名称：scanalyze-1.0.3_source_code.rar　[点击查看]
上传用户：kellyonhid
上传日期：2013-10-12
资源大小：932k
文件大小：44k
源码类别：

3D图形编程

开发平台：

Visual C++

plvAnalyze.cc：源码内容
  1. //###############################################################
  2. // plvAnalyze.cc
  3. // Matt Ginzton, Lucas Pereira
  4. // Thu Jun 18 13:02:22 PDT 1998
  5. // 
  6. // Interface for reading points or groups of points from z buffer
  7. //###############################################################
  10. #include "plvGlobals.h"
  11. #include "plvDraw.h"
  12. #include "plvDrawCmds.h"
  13. #include "Trackball.h"
  14. #include "togl.h"
  15. #include "Pnt3.h"
  16. #include "defines.h"
  17. #include "sczRegCmds.h"
  18. #include "plvAnalyze.h"
  19. #include "ScanFactory.h"
  20. #include "DisplayMesh.h"
  21. #include "plvScene.h"
  22. #include "plvClipBoxCmds.h"
  23. #include "GenericScan.h"
  24. #include "Mesh.h"
  25. #include "DrawObj.h"
  26. #include "plvImageCmds.h"
  27. #include "ToglText.h"
  28. #include "Projector.h"
  31. #ifdef WIN32
  32. // don't have rint, just consider it a noop
  33. # define rint (int)
  34. #endif
  35. #ifdef linux
  36. #define MAXFLOAT FLT_MAX
  37. #endif
  39. // for determining background pixels in z buffer -- should be 0 to 1.0,
  40. // or 0x0 to 0xffffffff, but on IR's the range is somewhat different,
  41. // 0x7ffff to 0xffffff00
  42. unsigned int g_zbufferMinUI;
  43. unsigned int g_zbufferMaxUI;
  44. float g_zbufferMinF;
  45. float g_zbufferMaxF;
  47. #define ISBACKGROUND(zfloat) ((zfloat) >= g_zbufferMaxF)
  50. #ifndef MIN
  51. #define MIN(a,b)  ((a)<(b)?(a):(b))
  52. #endif
  53. #ifndef MAX
  54. #define MAX(a,b)  ((a)>(b)?(a):(b))
  55. #endif
  57. #define DEBUG 1
  59. static void readLinePixels (int x, int y, int w, int h,
  60.     GLenum component, GLenum type,
  61.     char* data, int dataSize);
  65. int
  66. WriteOrthoDepth(ClientData clientData, Tcl_Interp *interp,
  67.                 int argc, char *argv[])
  68. {
  69.    GLint viewport[4];
  70.    GLdouble projmatrix[16];
  71.    GLdouble idmatrix[16] = {1.0,0,0,0, 0,1.0,0,0, 0,0,1.0,0, 0,0,0,1.0};
  72.    GLdouble wx, wy, wz;
  73.    float *dvp;
  74.    double min_eye_z = 0.0, max_eye_z = -MAXFLOAT;
  75.    float zval;
  76.    int val;
  77.    int i, j;
  79.    if (argc != 2) {
  80.        Tcl_SetResult(interp, "Incorrect Num of Args", NULL);
  81.        return TCL_ERROR;
  82.    }
  84.    FILE *fd = fopen(argv[1], "w");
  85.    if (fd == NULL) {
  86.        Tcl_SetResult(interp, "Can't open file for writing", NULL);
  87.        return TCL_ERROR;
  88.    }
  90.    // Read the depth buffer values into a local data structure
  92.    int width = Togl_Width (toglCurrent);
  93.    int height = Togl_Height (toglCurrent);
  94.    float *depthvals = new float[width*height];
  96.    glReadBuffer(GL_FRONT);
  97.    glReadPixels(0, 0, width, height, GL_DEPTH_COMPONENT,
  98.                 GL_FLOAT, depthvals);
  100.    // Unproject the depth buffer values back to eye coordinates.
  102.    glGetIntegerv(GL_VIEWPORT, viewport);
  103.    glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);
  105.    for (i=0; i<height; ++i)
  106.        for (j=0; j<width; ++j) {
  107.             dvp = &(depthvals[i*width+j]);
  108.     if (ISBACKGROUND(*dvp))
  109.        *dvp = 1000.0;
  110.             else  {
  111.                gluUnProject((GLdouble) j, (GLdouble) i, (GLdouble) *dvp,
  112.                    idmatrix, projmatrix, viewport, &wx, &wy, &wz);
  113.                if (wz > max_eye_z)
  114.   max_eye_z = wz;
  115.                if (wz < min_eye_z)
  116.   min_eye_z = wz;
  117.                *dvp = wz;
  118.             }
  119.        }
  121.    // Write the scaled depth values out to a 16-bit .PPM format file.
  122.    // Pixel value 0 is used as a "no data" flag.
  124.    double dgap = max_eye_z - min_eye_z;
  125.    double dscale = dgap / 65534.0;
  126.    double dbias = -max_eye_z - dscale;
  128.    fprintf(fd, "P3n");
  129.    fprintf(fd, "# 16-bit .PPM format displacement map (via Scanalyze)n");
  130.    fprintf(fd, "# Image dimensions: ");
  131.    fprintf(fd, "width=%g height=%gn", 2/projmatrix[0], 2/projmatrix[5]);
  132.    fprintf(fd, "# Displacement resolution=%gn", dscale);
  133.    fprintf(fd, "# Pixel values of 0 (if any) correspond to missing datan");
  134.    fprintf(fd, "%d %d 65535n", width, height);
  136.    for (i=height-1; i>=0; i--)
  137.        for (j=0; j<width; ++j)  {
  138.            zval = depthvals[i*width + j];
  139.    if (zval > 0.0)
  140.        fprintf(fd, "0 0 0n");
  141.            else  {
  142.               val = (int) rint((-zval-dbias)/dscale);
  143.       fprintf(fd, "%d %d %dn", val, val, val);
  144.    }
  145.        }
  147.    delete[] depthvals;
  148.    fclose(fd);
  149.    return TCL_OK;
  150. }
  153. //////////////////////////////////////////////////////////////////////
  154. //
  155. // Point picking tools
  156. //
  157. //////////////////////////////////////////////////////////////////////
  160. //X and Tcl are upper left origin
  161. //GL is lower left..yah
  163. int
  164. WriteWorldDataFromScreen(ClientData clientData, Tcl_Interp *interp, 
  165.        int argc, char *argv[])
  166. {
  167.   Pnt3 pt;
  168.   int width = Togl_Width(toglCurrent);
  169.   int height = Togl_Height(toglCurrent);
  170.   //ScreenToWorldCoordinates assumes GL lower left origin
  171.   if(argc !=2)
  172.     {
  173.       Tcl_SetResult(interp, "Incorrect Num of Args", NULL);
  174.       return TCL_ERROR;
  175.     }
  176.   FILE *fd = fopen(argv[1], "w");
  177.   if(fd == NULL)
  178.     {
  179.       Tcl_SetResult(interp,
  180.     "Can't open file for writing", NULL);
  181.       return TCL_ERROR;
  182.     }
  183.   //fprintf(fd, "# format is u,v x,y,z u,v, is GL (lower left) originn");
  184.   fprintf(fd, "# format is u,v x,y,z   (u,v, is upper left origin)n");
  185.   fprintf(fd, "# next line is width, height of imagen");
  186.   fprintf(fd, "%d %dn",width,height);
  187.   for(int x=0; x<width;x++)
  188.     for(int y=0;y<height;y++)
  189.       {
  190. if(ScreenToWorldCoordinates(x,y,pt))
  191.   {
  192.     //this point is on the object.
  193.     fprintf(fd,"%d %d %f %f %fn",x,height-y,pt[0],pt[1],pt[2]);
  194.   }
  195.       }
  196.   fclose(fd);
  197.   return TCL_OK;
  198. }
  200. /*
  201. {
  202.   Pnt3 pt;
  203.   //get screen size
  204.   int width = Togl_Width (toglCurrent);
  205.   int height = Togl_Height (toglCurrent);
  206.   //fprintf(stderr, "plvAnalyze.cc:WriteWorldDataFromScreen "
  207.   //  "width,height is %d,%dn",width,height);
  209.   if(argc !=2)
  210.     {
  211.       Tcl_SetResult(interp, "Incorrect Num of Args", NULL);
  212.       return TCL_ERROR;
  213.     }
  214.   FILE *fd = fopen(argv[1], "w");
  215. #ifdef DEBUG
  216.   char buffer[1024];
  217.   sprintf(buffer, "%s.iv",argv[1]);
  218.   FILE *ivfile = fopen(buffer, "w");
  219.   fprintf(ivfile, "#Inventor V2.1 ascii#nn");
  220.   //new
  221.   fprintf(ivfile, "Separator {nCoordinate3 { n point [n");
  222. #endif
  223.   if(fd == NULL)
  224.     {
  225.       Tcl_SetResult(interp,
  226.     "Can't open file for writing", NULL);
  227.       return TCL_ERROR;
  228.     }
  229.   for(int w=0; w < width; w++)
  230.     for(int h=0; h <height; h++)
  231.       {
  232. ScreenToWorldCoordinates(w,h, pt);
  234. if(pt[0] != 0.0 || pt[1] != 0.0 ||
  235.    pt[2] != 0.0)
  236.   {
  237.     fprintf(fd, "%d %d %f %f %fn",w,h,pt[0],
  238.     pt[1],pt[2]);
  239. #ifdef DEBUG
  240.     fprintf(ivfile, "%f %f %f,n",pt[0],pt[1],pt[2]);
  241.     //     fprintf(ivfile, "Separator { n");
  242.     //fprintf(ivfile, "Translation { translation %f %f %f } n",
  243.     //     pt[0],pt[1],pt[2]);
  244.     //fprintf(ivfile, "Sphere { radius .0001 }n}n");
  246. #endif
  247.   }
  248.       }
  249. #ifdef DEBUG
  250.   //add last point again, w/o the comma
  251.   fprintf(ivfile, "%f %f %f ]n",pt[0],pt[1],pt[2]);
  252.   fprintf(ivfile, "}n}n");
  253.   fclose(ivfile);
  254. #endif
  255.   fclose(fd);
  257.   return TCL_OK;
  258.   //TCL_ERROR
  259. }
  260. */
  262. int
  263. ScreenToWorldCoordinates (int x, int y, Pnt3& ptWorld)
  264. {
  265.   // assumes GL coordinates (0,0 is lower left)
  266.   return ScreenToWorldCoordinatesExt (x, y, ptWorld, toglCurrent, tbView, 0);
  267. }
  270. int
  271. ScreenToWorldCoordinatesExt (int x, int y, Pnt3& ptWorld,
  272.      struct Togl* togl, Trackball* tb,
  273.      float fudgeFactor)
  274. {
  275.   // assumes GL coordinates (0,0 is lower left)
  277.   Togl_MakeCurrent (togl);
  278.   float pixdepth;
  279.   if (theRenderParams->polyMode == GL_FILL || theRenderParams->hiddenLine)
  280.   {
  281.     // have poly data (or hidden-line/point, also filled)
  282.     // read it from front buffer
  283.     glReadBuffer (GL_FRONT);
  284.     glReadPixels (x, y, 1, 1, GL_DEPTH_COMPONENT, 
  285.   GL_FLOAT, &pixdepth);
  286.     //printf("pixdepth (from front): %fn", pixdepth);
  287.   }
  288.   else {
  289.     // don't have poly data... need to get it
  290.     GLenum oldPolyMode = theRenderParams->polyMode;
  291.     bool oldHiddenLine = theRenderParams->hiddenLine;
  292.     theRenderParams->polyMode = GL_FILL;
  293.     theRenderParams->hiddenLine = FALSE;
  295.     if (togl == toglCurrent)
  296.       drawInToglBuffer (togl, GL_BACK);
  297.     else {
  298.       //hack warning -- assumes all togls except the main one have an
  299.       //AlignmentToglInfo; need to change this
  300.       DrawAlignmentMeshToBack (togl);
  301.     }
  303.     glReadBuffer (GL_BACK);
  304.     glReadPixels (x, y, 1, 1, GL_DEPTH_COMPONENT, 
  305.   GL_FLOAT, &pixdepth);
  306.     //printf("pixdepth (from back): %fn", pixdepth);
  308.     theRenderParams->polyMode = oldPolyMode;
  309.     theRenderParams->hiddenLine = oldHiddenLine;
  310.   }
  312.   // ok, at this point, pixdepth has the zbuffer value
  313.   // ignore z-depth of 1.0 because that's the background
  314.   if (ISBACKGROUND (pixdepth))
  315.     return FALSE;
  317.   pixdepth -= fudgeFactor;
  319.   // need to unproject z-buffer data to world coordinates
  320.   Unprojector unproject (tb);
  321.   ptWorld = unproject (x, y, pixdepth);
  323.   //printf("You selected world position: %.4f %.4f %.4fn", 
  324.   //   worldPos[0], worldPos[1], worldPos[2]);
  326.   return true;
  327. }
  330. //////////////////////////////////////////////////////////////////////
  331. //
  332. // Clip line analysis tools
  333. //
  334. //////////////////////////////////////////////////////////////////////
  337. class ClipLineData
  338. {
  339. public:
  340.   ClipLineData (int w);
  341.   ~ClipLineData();
  343.   GLfloat* pixels;          // z-buffer data
  344.   GLfloat* lines;           // z-buffer data from wireframe render
  345.   Pnt3*    objPt;           // unprojected object coordinates
  347.   vec3uc color;
  348.   DisplayableMesh *theMesh;
  349. };
  352. class ClipLineInfo
  353. {
  354. public:
  355.   ClipLineInfo (int w);
  356.   ~ClipLineInfo();
  358.   // data corresponding to multiple scans
  359.   vector<ClipLineData*> data;
  361.   // info pertaining to aggregate of data collection
  362.   int width;                //width of line, in pixels
  363.   GLdouble zMin, zMax;      //min, max values in objZ
  364.   GLdouble xMin, xMax;
  365.   int nFirstGood, nLastGood;//indices of first & last
  366.                             //non-background pixels in z-buffer
  368.   // UI settings
  369.   bool  bShowScale;
  370.   bool  bShowEdges;
  371.   bool  bShowFramebuffPts;
  372.   bool  bShowColor;
  373.   int   nScaleExp;
  374.   float zRescale;
  375. };
  378. ClipLineInfo::ClipLineInfo (int w)
  379. {
  380.   width = w;
  382.   bShowScale = true;
  383.   bShowEdges = false;
  384.   bShowFramebuffPts = false;
  385.   bShowColor = true;
  386.   nScaleExp = 0;
  387.   zRescale = 1;
  388. }
  391. ClipLineInfo::~ClipLineInfo()
  392. {
  393.   for (ClipLineData** iter = data.begin(); iter < data.end(); iter++)
  394.     delete *iter;
  395. }
  398. ClipLineData::ClipLineData (int w)
  399. {
  400.   pixels = new GLfloat [w];
  401.   lines = new GLfloat [w];
  402.   objPt = new Pnt3 [w];
  403. }
  406. ClipLineData::~ClipLineData()
  407. {
  408.   delete [] pixels;
  409.   delete [] lines;
  410.   delete [] objPt;
  411. }
  414. int
  415. PlvAnalyzeLineModeCmd(ClientData clientData, Tcl_Interp *interp, 
  416.       int argc, char *argv[])
  417. {
  418.   static float zsBase = 1;
  420.   // args: analyzeTogl [show linetype bool] | [scale n] | [level bool]
  421.   if (argc < 4) {
  422.     interp->result = "Bad args to PlvAnalyzeLineModeCmd";
  423.     return TCL_ERROR;
  424.   }
  426.   struct Togl* togl = toglHash.FindTogl (argv[1]);
  427.   if (!togl) {
  428.     interp->result = "Missing togl in PlvAnalyzeLineModeCmd";
  429.     return TCL_ERROR;
  430.   }
  431.   ClipLineInfo* cli = (ClipLineInfo*)Togl_GetClientData (togl);
  433.   if (!strcmp (argv[2], "show")) {
  434.     if (argc < 5)
  435.       return TCL_ERROR;
  436.     bool bShow = atoi (argv[4]);
  438.     if (!strcmp (argv[3], "scale"))
  439.       cli->bShowScale = bShow;
  440.     else if (!strcmp (argv[3], "edges"))
  441.       cli->bShowEdges = bShow;
  442.     else if (!strcmp (argv[3], "framebuff"))
  443.       cli->bShowFramebuffPts = bShow;
  444.     else if (!strcmp (argv[3], "color"))
  445.       cli->bShowColor = bShow;
  446.   } else if (!strcmp (argv[2], "scale")) {
  447.     cli->nScaleExp = atoi (argv[3]);
  448.   } else if (!strcmp (argv[2], "zscale")) {
  449.     int zs = atoi (argv[3]);
  450.     if (!strcmp (argv[4], "start")) {
  451.       zsBase = zs / cli->zRescale;
  452.     } else {
  453.       if (!strcmp (argv[4], "reset"))
  454. cli->zRescale = 1;
  455.       else
  456. cli->zRescale = MAX (1, zs / zsBase);
  457.       double zScale = (cli->zMax - cli->zMin) / cli->zRescale;
  458.       char buf[50];
  459.       sprintf (buf, "setAnalyzeZScale %s %g", argv[1], zScale);
  460.       Tcl_Eval (interp, buf);
  461.     }
  462.   } else {
  463.     interp->result = "Bad subcommand in PlvAnalyzeModeCmd";
  464.     return TCL_ERROR;
  465.   }
  467.   Togl_PostRedisplay (togl);
  469.   return TCL_OK;
  470. }
  473. int
  474. PlvExportGraphAsText(ClientData clientData, Tcl_Interp *interp, 
  475.      int argc, char *argv[]) 
  476. {
  477.   Togl *togl;
  478.   char *winName;
  479.   FILE *datafile, *ctlfile;
  480.   ClipLineInfo *cli;
  481.   char fileName[256];
  483.   if ( argc < 3 ) {
  484.     return TCL_ERROR;
  485.   }
  487.   char toglName[100];
  488.   sprintf (toglName, "%s.togl", argv[1]);
  490.   togl = toglHash.FindTogl(toglName);
  491.   winName = argv[2];
  493.   if ( togl == NULL ) {
  494.     interp->result = "PlvExportGraphAsText: Null togl pointer";
  495.     return TCL_ERROR;
  496.   }
  498.   // don't need to check, b/c tcl caller should do it
  499.   ctlfile = fopen(winName, "w");
  500.   // don't copy the extension, but remember to add terminator
  501.   strncpy(fileName, winName, strlen(winName) - 4);
  502.   fileName[(strlen(winName) - 4)] = '';
  504.   // comment title, set postscript output
  505.   fprintf(ctlfile, "# %snset term post p c s 12n", fileName);
  506.   fprintf(ctlfile, "set size .75, .75n");
  507.   // set ps output file, set title of graph
  508.   fprintf(ctlfile, "set output "%s.ps"nset title "%s"n", fileName, fileName);
  510.  
  511.   cli = (ClipLineInfo*)Togl_GetClientData(togl);
  512.   int nPix = cli->width;
  514.   //  int k = 0;
  515.   fprintf(ctlfile, "plot ");
  516.   for (ClipLineData** pcld = cli->data.begin(); 
  517.        pcld < cli->data.end(); pcld++) {
  518.     ClipLineData* cld = *pcld;
  520.     char buff[256];
  521.     //    sprintf(buff, "%s.%i.dat", winName, k);
  522.     sprintf(buff, "%s_%s.dat", fileName, cld->theMesh->getName());
  523.     //    sprintf(buff, "%s_%s.dat", fileName, cld->theMesh->displayName);
  525.     datafile = fopen(buff, "w");
  526.     if ( datafile == NULL ) {
  527.       printf ("can't open filen");
  528.     }
  529.     fprintf(ctlfile, "'%s' title '%s' with lines", buff, cld->theMesh->getName());
  530.     if ( pcld + 1 < cli->data.end() ) {
  531.       fprintf(ctlfile, ", ");
  532.     }
  534.     for (int x = 0; x < nPix; x++ ) {
  535.       if (!ISBACKGROUND(cld->pixels[x])) {
  536. fprintf(datafile, "n%f %f", cld->objPt[x][0], cld->objPt[x][2]);
  537.       }
  538.     }
  539.     //    k++;
  540.     fclose(datafile);
  541.   }
  542.   
  543.   fclose(ctlfile);
  544.   return TCL_OK;
  545. } // PlvExportGraphAsText
  548. void
  549. PlotLineDepth (struct Togl* togl)
  550. {
  551.   ClipLineInfo* cli = (ClipLineInfo*)Togl_GetClientData (togl);
  552.   int nPixels = cli->width;
  554.   int w = Togl_Width (togl);
  555.   int h = Togl_Height (togl);
  557.   //set child's togl as current
  558.   glViewport (0, 0, w, h);
  559.   glMatrixMode (GL_MODELVIEW);
  560.   glLoadIdentity();
  561.   glMatrixMode (GL_PROJECTION);
  562.   glLoadIdentity();
  564.   glClear (GL_COLOR_BUFFER_BIT);
  566.   //draw grid -- square only if correct aspect ratio
  567.   double scaleW = (cli->xMax - cli->xMin) * 
  568.    (cli->width / (double)(cli->nLastGood - cli->nFirstGood));
  569.   double scaleH = cli->zMax - cli->zMin;
  570.   float zRescaleRatio = (cli->zRescale - 1) / cli->zRescale;
  571.   gluOrtho2D (0, scaleW, zRescaleRatio * scaleH, scaleH);
  573.   double step = pow (10, cli->nScaleExp);
  575.   if (cli->bShowScale) {
  576.     glColor3f (.3, .2, 0);  // lucas brown
  578.     glBegin (GL_LINES);
  579.     for (double i = 0; i <= scaleH; i += step) {
  580.       glVertex2f (0, i);
  581.       glVertex2f (scaleW, i);
  582.     }
  583.     for (i = 0; i <= scaleW; i += step) {
  584.       glVertex2f (i, 0);
  585.       glVertex2f (i, scaleH);
  586.     }
  587.     glEnd();
  588.   }
  590.   glMatrixMode (GL_PROJECTION);
  591.   glLoadIdentity();
  592.   //xMin and xMax will be clamped around object, ignoring background -- we 
  593.   //want to show background -- pixel width of data is 0 to cli->width;
  594.   //pixel width of object w/o background is cli->nFirstGood to cli->nLastGood;
  595.   //xMin and xMax are in nFirstGood to nLastGood range and need to be scaled
  596.   //to 0 to nPixels range.
  597.   float scale = (cli->xMax - cli->xMin) / (cli->nLastGood - cli->nFirstGood);
  598.   float left = cli->xMin - (scale * cli->nFirstGood);
  599.   float right = cli->xMax + (scale * (cli->width - 1 - cli->nLastGood));
  600.   float bottom = cli->zMin + (cli->zMax - cli->zMin) * zRescaleRatio;
  601.   float top = cli->zMax;
  602.   gluOrtho2D (left, right, bottom, top);
  604.   //printf ("X: 0, %d, %d, %dn", cli->nFirstGood, cli->nLastGood, nPixels);
  605.   //printf ("   %g, %g, %g, %gn", left, cli->xMin, cli->xMax, right);
  606.   //printf ("Z: %g to %gn", bottom, top);
  607.   //fflush (stdout);
  609.   for (ClipLineData** pcld = cli->data.begin(); pcld < cli->data.end();
  610.        pcld++) {
  611.     ClipLineData* cld = *pcld;
  613.     //in background, draw mesh wireframe borders (yellow)
  614.     if (cli->bShowEdges) {
  615.       glColor4f (1, 1, 0, .7);
  616.       glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  617.       glEnable (GL_BLEND);
  618.       float zDiff = (cli->zMax - cli->zMin) / 20;
  619.       for (int x = 0; x < nPixels; x++) {
  620. if (cld->lines[x] > 0) {    //this is the luminance value
  621.   if ((x+1) < nPixels && (cld->lines[x+1] > 0)) {
  622.     // next one is a mesh crossing too -- because these are likely
  623.     // to have come from a single mesh crossing at an oblique angle,
  624.     // shade the whole area between them.
  625.     glBegin (GL_QUADS);
  626.     glVertex2f (cld->objPt[x  ][0], cld->objPt[x][2  ] - zDiff);
  627.     glVertex2f (cld->objPt[x  ][0], cld->objPt[x][2  ] + zDiff);
  628.     glVertex2f (cld->objPt[x+1][0], cld->objPt[x+1][2] + zDiff);
  629.     glVertex2f (cld->objPt[x+1][0], cld->objPt[x+1][2] - zDiff);
  630.     glEnd();
  631.   } else {
  632.     glBegin (GL_LINES);
  633.     glVertex2f (cld->objPt[x][0], cld->objPt[x][2] - zDiff);
  634.     glVertex2f (cld->objPt[x][0], cld->objPt[x][2] + zDiff);
  635.     glEnd();
  636.   }
  637. }
  638.       }
  639.       glDisable (GL_BLEND);
  640.     }
  641.     
  642.     //draw data points, connected by lines (mesh's false color)
  643.     if (cli->bShowColor)
  644.       glColor3ub (cld->color[0], cld->color[1], cld->color[2]);
  645.     else
  646.       glColor3f (1, 1, 1);
  648.     glBegin (GL_LINE_STRIP);
  649.     for (int x = 0; x < nPixels; x++) {
  650.       if (!ISBACKGROUND(cld->pixels[x])) {
  651. glVertex2f (cld->objPt[x][0], cld->objPt[x][2]);
  652.       } else {
  653. if (x > 0) {
  654.   glVertex2f (cld->objPt[x-1][0], cli->zMin - 1);
  655. }
  656. if (x + 1 < nPixels) {
  657.   glEnd();
  658.   glBegin (GL_LINE_STRIP);
  659.   glVertex2f (cld->objPt[x+1][0], cli->zMin - 1);
  660. }
  661.       }
  662.       //printf ("True coords: %g %g %g -- from %d, %fn",
  663.       //cld->objX[x], cld->objY[x], cld->objZ[x], x, cld->pixels[x]);
  664.     }
  665.     glEnd();
  666.     
  667.     //now draw individual data points (green)
  668.     if (cli->bShowFramebuffPts) {
  669.       glColor3f (0, 1, 0);
  670.       float ptSize = (float)MIN (w, h) / nPixels;
  671.       if (ptSize < 1.0)  //scale point size with window -- don't want to
  672. ptSize = 1.0;    //dominate white line, but want points visible
  673.       glPointSize (ptSize);
  674.       glBegin (GL_POINTS);
  675.       for (x = 0 ; x < nPixels; x++) {
  676. if (!ISBACKGROUND(cld->pixels[x]))
  677.   glVertex2f (cld->objPt[x][0], cld->objPt[x][2]);
  678.       }
  679.       glEnd();
  680.     }
  681.   }
  683.   char legend[200];
  684.   sprintf (legend, "x range: %g (%g occupied); z range: %g",
  685.    scaleW, cli->xMax - cli->xMin, scaleH / cli->zRescale);
  686.   glLoadIdentity();
  687.   gluOrtho2D (0, w, 0, h);
  688.   glColor3f (1, 1, 1);
  689.   glRasterPos2i (2, 2);
  690.   DrawText (togl, legend);
  692.   Togl_SwapBuffers (togl);
  693. }
  696. void
  697. FreeLineDepthInfo (struct Togl* togl)
  698. {
  699.   ClipLineInfo* cli = (ClipLineInfo*)Togl_GetClientData (togl);
  700.   delete cli;
  701. }
  704. int nAnalysis = 0;             //need to change window name each time so
  705.        //tcl doesn't get mad at us for creating
  706.        //multiple windows with same name
  709. int
  710. PlvAnalyzeClipLineDepth(ClientData clientData, Tcl_Interp *interp, 
  711. int argc, char *argv[])
  712. {
  713.   struct Togl* toglAnalyze;
  714.   bool bFoundAnyData = false;
  715.   char meshNames[1000] = "";
  717.   if (theSel.type != Selection::line) {
  718.     interp->result = "You must first select a line";
  719.     return TCL_ERROR;
  720.   }
  722.   int dx = theSel[1].x - theSel[0].x;
  723.   int dy = theSel[1].y - theSel[0].y;
  724.   int x = theSel[0].x;
  725.   int y = theSel[0].y;
  727.   // force plot to go left-to-right for readability
  728.   if (dx < 0) { // so if it's not, flip it
  729.     x += dx;   dx *= -1;
  730.     y += dy;   dy *= -1;
  731.   }
  733.   int nPixels = max (abs(dx), abs(dy));
  735.   if (nPixels == 0) {
  736.     interp->result = "You must first select a line";
  737.     return TCL_ERROR;
  738.   }
  739.   
  740.   ClipLineInfo* cli = new ClipLineInfo (nPixels);
  742.   //need to unproject z-buffer data with identity modelview
  743.   glMatrixMode (GL_MODELVIEW);
  744.   glPushMatrix();
  745.   glLoadIdentity();
  746.   Unprojector unproject;
  747.   glPopMatrix();
  749.   // have to render without boundSelection, or bbox will show up
  750.   PushRenderParams();
  751.   theRenderParams->boundSelection = false;
  753.   for (DisplayableMesh** pdm = theScene->meshSets.begin();
  754.        pdm < theScene->meshSets.end();
  755.        pdm++) {
  756.     if (!(*pdm)->getVisible())
  757.       continue;
  759.     ClipLineData* cld = new ClipLineData (nPixels);
  760.     // render hidden line to back buffer and read data
  761.     theRenderParams->polyMode = GL_LINE;
  762.     theRenderParams->hiddenLine = true;
  763.     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  764.     (*pdm)->drawSelf (false);
  765.     glReadBuffer (GL_BACK);
  766.     readLinePixels (x, y, dx, dy, GL_LUMINANCE, GL_FLOAT,
  767.     (char*)cld->lines, sizeof(cld->lines[0]));
  769.     // render polys to back buffer and read data
  770.     theRenderParams->polyMode = GL_FILL;
  771.     theRenderParams->hiddenLine = false;
  772.     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  773.     (*pdm)->drawSelf (false);
  774.     glReadBuffer (GL_BACK);
  775.     readLinePixels (x, y, dx, dy, GL_DEPTH_COMPONENT, GL_FLOAT,
  776.     (char*)cld->pixels, sizeof(cld->pixels[0]));
  778.     //unproject data, and calculate min/max bounds on z coords
  779.     bool bFoundThisData = false;
  780.     for (int i = 0; i < nPixels; i++) {
  781.       cld->objPt[i] = unproject (x + i, y, cld->pixels[i]);
  783.       //ignore 1.0 because that's the background
  784.       if (!ISBACKGROUND(cld->pixels[i])) {
  785. bFoundThisData = true;
  786. if (!bFoundAnyData) {
  787.   bFoundAnyData = true;
  788.   cli->zMin = cli->zMax = cld->objPt[i][2];
  789.   cli->xMin = cli->xMax = cld->objPt[i][0];
  790.   cli->nFirstGood = i;
  791.   cli->nLastGood = i;
  792. } else {
  793.   if (i < cli->nFirstGood)
  794.     cli->nFirstGood = i;
  795.   if (i > cli->nLastGood)
  796.     cli->nLastGood = i;
  798.   float z = cld->objPt[i][2];
  799.   if (z < cli->zMin)
  800.     cli->zMin = z;
  801.   if (z > cli->zMax)
  802.     cli->zMax = z;
  803.   
  804.   float x = cld->objPt[i][0];
  805.   if (x < cli->xMin)
  806.     cli->xMin = x;
  807.   if (x > cli->xMax)
  808.     cli->xMax = x;
  809. }
  810.       }
  811.     }
  813.     if (bFoundThisData) {
  814.       const vec3uc& color = (*pdm)->getFalseColor();
  815.       cld->color[0] = color[0];
  816.       cld->color[1] = color[1];
  817.       cld->color[2] = color[2];
  818.       cld->theMesh = *pdm; // wsh added this line to be able to get names...
  819.       cli->data.push_back (cld);
  821.       if (bFoundAnyData)
  822. strcat (meshNames, " ");
  823. // strcat(meshNames, "_");
  824.       strcat (meshNames, (*pdm)->getName());
  825.     }
  826.   }
  828.   PopRenderParams();
  830.   if (!bFoundAnyData) {
  831.     interp->result =
  832.       "No data found.  To do line analysis, draw a line selection,n"
  833.       "and make sure it intersects a scan!";
  834.     delete cli;
  835.     return TCL_ERROR;
  836.   }
  838.   if (ISBACKGROUND (1 - (cli->zMax - cli->zMin))) {
  839.     interp->result =
  840.       "Region under clip line is too uniform to analyze!";
  841.     delete cli;
  842.     return TCL_ERROR;
  843.   }
  844.   //else printf ("min/max: %f/%fn", cli->zMin, cli->zMax);
  846.   //create toplevel containing togl
  847.   //need to size window to w pixels wide, 60 pixels tall (arbitrary)
  848.   //instead of using a script here, could call Tk_CreateWindow,
  849.   //Tk_GeometryRequest, and Togl_Widget
  851.   double xScale = cli->xMax - cli->xMin;
  852.   double zScale = cli->zMax - cli->zMin;
  853.   int defScale = (int)log10 (min (xScale, zScale) / 10);
  854.   cli->nScaleExp = defScale;  // in case tcl is fickle and doesn't send message
  856.   char script[1000];
  857.   sprintf (script, "createAnalyzeWindow %d %d %g %g %g "%s" %d",
  858.    ++nAnalysis,
  859.    nPixels, xScale,
  860.    xScale * (cli->width / (double)(cli->nLastGood - cli->nFirstGood)),
  861.    zScale, meshNames, defScale);
  862.   if (TCL_OK != Tcl_Eval (interp, script)) {
  863.     delete cli;
  864.     return TCL_ERROR;
  865.   }
  867.   char toglName[100];
  868.   sprintf (toglName, ".analyze%d.togl", nAnalysis);
  869.   toglAnalyze = toglHash.FindTogl (toglName);
  870.   assert (toglAnalyze != NULL);
  871.   
  872.   Togl_SetClientData (toglAnalyze, cli);
  873.   Togl_SetDisplayFunc (toglAnalyze, PlotLineDepth);
  874.   Togl_SetDestroyFunc (toglAnalyze, FreeLineDepthInfo);
  876.   // eval of createAnalyzeWindow set interp->result to name of window
  877.   // created -- leave it that way
  878.   return TCL_OK;
  879. }
  882. // run this function once at startup time, when we don't care what's
  883. // onscreen since it clears it, to initialize some important variables
  885. void storeMinMaxZBufferValues (void)
  886. {
  887.   if (g_bNoUI)
  888.     return;
  890.   assert (toglCurrent != NULL);
  891.   Togl_MakeCurrent (toglCurrent);
  893.   // clear z-buffer to get background z-value
  894.   glClearDepth (0.0);
  895.   glClear (GL_DEPTH_BUFFER_BIT);
  896.   glReadPixels (0, 0, 1, 1,
  897. GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, &g_zbufferMinUI);
  898.   glReadPixels (0, 0, 1, 1,
  899. GL_DEPTH_COMPONENT, GL_FLOAT, &g_zbufferMinF);
  901.   glClearDepth (1.0);  // this leaves it back at the default state
  902.   glClear (GL_DEPTH_BUFFER_BIT);
  903.   glReadPixels (0, 0, 1, 1,
  904. GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, &g_zbufferMaxUI);
  905.   glReadPixels (0, 0, 1, 1,
  906. GL_DEPTH_COMPONENT, GL_FLOAT, &g_zbufferMaxF);
  908.   //fprintf (stderr, "Z buffer range: %08x to %08x (%g to %g)n",
  909.   //   g_zbufferMinUI, g_zbufferMaxUI,
  910.   //   g_zbufferMinF, g_zbufferMaxF);
  911. }
  914. static unsigned int* ReadZBufferRect (int x, int y, int w, int h,
  915.       bool bRedraw = true)
  916. {
  917.   unsigned int* data = new unsigned int [w * h];
  919.   if (bRedraw) {
  920.     // draw scene
  921.     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  922.     bool oldbs = theRenderParams->boundSelection;
  923.     theRenderParams->boundSelection = false;
  924.     drawInToglBuffer (toglCurrent, GL_BACK);
  925.     theRenderParams->boundSelection = oldbs;
  926.   }
  928.   // and collect z-buffer
  929.   glReadBuffer (GL_BACK);
  930.   glReadPixels (x, y, w, h, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, data);
  931.   if (glGetError()) {
  932.     delete[] data;
  933.     return NULL;
  934.   }
  936.   return data;
  937. }
  940. bool ReadZBufferArea (vector<Pnt3>& pts, const Selection& sel,
  941.       bool bIncludeBlanks, bool bRedraw,
  942.       bool bReverseBackground)
  943. {
  944.   Unprojector unproject (tbView);
  946.   if (sel.type == Selection::rect) {
  947.     int x = min (sel[0].x, sel[2].x);
  948.     int w = abs (sel[0].x - sel[2].x);
  949.     int y = min (sel[0].y, sel[2].y);
  950.     int h = abs (sel[0].y - sel[2].y);
  952.     unsigned int* data = ReadZBufferRect (x, y, w, h, bRedraw);
  953.     if (!data)
  954.       return false;
  956.     for (int iy = 0; iy < h; iy++) {
  957.       for (int ix = 0; ix < w; ix++) {
  958. int ofs = iy*w + ix;
  959. if (bReverseBackground ?
  960.     (data[ofs] > g_zbufferMinUI) :
  961.     (data[ofs] < g_zbufferMaxUI)) {
  962.   pts.push_back (unproject (x + ix, y + iy, data[ofs]));
  963. } else if (bIncludeBlanks) {
  964.   pts.push_back(Pnt3());
  965. }
  966.       }
  967.     }
  969.     delete[] data;
  970.     return true;
  972.   } else if (sel.type == Selection::shape) {
  973.     int width = theWidth;
  974.     int height = theHeight;
  975.     unsigned char* shapePix = filledPolyPixels (width, height, sel.pts);
  976.     if (!shapePix)
  977.       return false;
  978.     unsigned int* data = ReadZBufferRect (0, 0, width, height);
  979.     if (!data) {
  980.       delete[] shapePix;
  981.       return false;
  982.     }
  984.     // BUGBUG: does this need to obey bReverseBackground, bIncludeBlanks?
  985.     for (int x = 0; x < width; x++) {
  986.       for (int y = 0; y < height; y++) {
  987. int ofs = y*width + x;
  988. if (shapePix[ofs] != 0 && data[ofs] < g_zbufferMaxUI) {
  989.   pts.push_back (unproject (x, y, data[ofs]));
  990. }
  991.       }
  992.     }
  994.     delete[] shapePix;
  995.     delete[] data;
  996.     return true;
  997.   }
  999.   return false;
  1000. }
  1003. // from fitplane.cc
  1004. void fitPnt3Plane (const vector<Pnt3>& pts, Pnt3& n, float& d, Pnt3& outCentroid);
  1006. int
  1007. PlvAlignToMeshBoxCmd(ClientData clientData, Tcl_Interp *interp, 
  1008.      int argc, char *argv[])
  1009. {
  1010.   if (argc < 2) {
  1011.     interp->result = "Bad args to PlvAlignToMeshBoxCmd";
  1012.     return TCL_ERROR;
  1013.   }
  1015.   bool bDumpStats = false;
  1016.   bool bAlign = false;
  1017.   bool bCreatePlane = false;
  1019.   bool bMoveMesh = false;
  1020.   bool bDataSourceMesh = false;
  1022.   for (int i = 2; i < argc; i++) {
  1023.     if (!strcmp (argv[i], "align"))
  1024.       bAlign = true;
  1025.     else if (!strcmp (argv[i], "dumpstats"))
  1026.       bDumpStats = true;
  1027.     else if (!strcmp (argv[i], "createplane"))
  1028.       bCreatePlane = true;
  1029.     else if (!strcmp (argv[i], "movemesh"))
  1030.       bMoveMesh = true;
  1031.     else if (!strcmp (argv[i], "movecamera"))
  1032.       bMoveMesh = false;
  1033.     else if (!strcmp (argv[i], "data_mesh"))
  1034.       bDataSourceMesh = true;
  1035.     else if (!strcmp (argv[i], "data_zbuffer"))
  1036.       bDataSourceMesh = false;
  1037.     else if (!strcmp (argv[i], ""))
  1038. ; // ignore possible blank params
  1039.     else {
  1040.       char str[200];
  1041.       sprintf (str, "PlvAlignToMeshBoxCmd: unrecognized arg '%s'", argv[i]);
  1042.       Tcl_SetResult (interp, str, TCL_VOLATILE);
  1043.       return TCL_ERROR;
  1044.     }
  1045.   }
  1047.   if (!(bAlign || bDumpStats || bCreatePlane)) {
  1048.     interp->result = "PlvAlignToMeshBoxCmd: nothing to do";
  1049.     return TCL_ERROR;
  1050.   }
  1052.   DisplayableMesh* meshDisp = FindMeshDisplayInfo (argv[1]);
  1053.   if (!meshDisp) {
  1054.     interp->result = "PlvAlignToMeshBoxCmd: missing mesh";
  1055.     return TCL_ERROR;
  1056.   }
  1057.   RigidScan* meshFrom = meshDisp->getMeshData();
  1059.   vector<Pnt3> pts;
  1060.   if (bDataSourceMesh) {
  1061.     VertexFilter* filter = filterFromSelection (meshFrom, theSel);
  1062.     if (!filter) {
  1063.       interp->result = "You must first select an area.";
  1064.       return TCL_ERROR;
  1065.     }
  1067.     if (!meshFrom->filter_vertices (*filter, pts)) {
  1068.       interp->result = "This scan does not implement filter_vertices.";
  1069.       return TCL_ERROR;      
  1070.     }
  1072.     delete filter;
  1074.   } else {
  1075.     if (!ReadZBufferArea (pts, theSel)) {
  1076.       interp->result = "Z-Buffer read failed";
  1077.       return TCL_ERROR;
  1078.     }
  1080.     Xform<float> unxform = meshFrom->getXform();
  1081.     unxform.fast_invert();
  1082.     for_each (pts.begin(), pts.end(), unxform);
  1083.   }
  1085.   if (pts.size() == 0) {
  1086.     char* reason;
  1087.     if (bDataSourceMesh)
  1088.       reason = "there are no mesh vertices there";
  1089.     else
  1090.       reason = "the z-buffer read failed";
  1092.     char str[200];
  1093.     sprintf (str, "No data was found inside the clipping rect.  Perhaps %s?",
  1094.      reason);
  1095.     Tcl_SetResult (interp, str, TCL_VOLATILE);
  1096.     return TCL_ERROR;
  1097.   }
  1099.   Pnt3 norm;
  1100.   float dist;
  1101.   Pnt3 centroid;
  1102.   fitPnt3Plane (pts, norm, dist, centroid);
  1104.   // there are 3 relevant coordinate systems: the mesh coordinate system,
  1105.   // which after applying mesh xform yields camera coordinate system,
  1106.   // which after applying camera xform yields eye coordinate system.
  1107.   // We just fit a plane in the mesh coordinate system.
  1109.   if (bDumpStats) {
  1110.     cout << "Fit plane to " << pts.size() << " vertices" << endl;
  1111.     SHOW (norm);
  1112.     SHOW (dist);
  1113.   }
  1115.   Pnt3 cameraNorm = norm;
  1116.   Xform<float> xf = meshFrom->getXform();
  1117.   xf.removeTranslation();
  1118.   xf (cameraNorm);
  1119.   if (bDumpStats)
  1120.     SHOW (cameraNorm);
  1122.   Pnt3 eyeNorm = cameraNorm;
  1123.   float q[4], t[3];
  1124.   tbView->getXform (q, t);
  1126.   xf.fromQuaternion (q);
  1127.   xf (eyeNorm);
  1128.   if (bDumpStats)
  1129.     SHOW (eyeNorm);
  1131.   float err = 0;
  1132.   for (Pnt3* pt = pts.begin(); pt < pts.end(); pt++) {
  1133.     err += fabs (dot (*pt, norm) - dist);
  1134.   }
  1135.   float avgErr = err / pts.size();
  1136.   if (bDumpStats)
  1137.     SHOW (avgErr);
  1139.   if (bAlign) {
  1140.     // need to rotate such that eyeNorm points (0,0,1): at viewer
  1141.     Pnt3 target (0, 0, 1);
  1143.     // fitPnt3Plane seems to return +/- normals randomly.
  1144.     // Flip the normal if necessary, to make it point up the visible z axis.  
  1145.     // This will make our life easier later on....
  1146.     if (eyeNorm[2] < 0) {
  1147.       //alex commented this back in..the cout line
  1148.       cout << "flipping plane" << endl;
  1149.       target *= -1;
  1150.     }
  1152.     float cosTh = dot (eyeNorm, target);
  1153.     if (fabs (cosTh - 1.0) > 1.e-6) {
  1154.       Pnt3 axis = cross (eyeNorm, target);
  1155.       
  1156.       Pnt3 center;
  1157.       ScreenPnt sc (0, 0);
  1158.       int nPts = theSel.pts.size();
  1159.       for (int i = 0; i < nPts; i++) {
  1160. sc.x += theSel[i].x;
  1161. sc.y += theSel[i].y;
  1162.       }
  1163.       sc.x /= nPts; sc.y /= nPts;
  1164.       if (!findZBufferNeighbor (sc.x, sc.y, center, 5000)) {
  1165. center = pts[nPts / 2];
  1166. cerr << "Warning: center is guess" << endl;
  1167.       }
  1169.       if (bMoveMesh) {
  1170. tbView->newRotationCenter (center, meshFrom);
  1171. tbView->rotateAroundAxis (axis, acos(cosTh), meshFrom);
  1172. theScene->computeBBox();
  1173.       } else {
  1174. tbView->newRotationCenter (center);
  1175. tbView->rotateAroundAxis (axis, acos(cosTh));
  1176.       }
  1177.       
  1178.       redraw (true);
  1179.     } else {
  1180.       cout << "Scanalyze considers it futile to try to make this any flatter"
  1181.    << endl;
  1182.     }
  1183.   }
  1185.   if (bCreatePlane) {
  1186.     vector<Pnt3> vtx;
  1187.     const float sizeX = 500;   // TODO: would be nice to get these
  1188.     const float sizeY = 500;   // sizes from projection of clipping rect
  1189.     Pnt3 center = centroid;
  1190.     Pnt3 axisFake = norm;
  1191.     if (axisFake[0] != 0)
  1192.       axisFake[0] *= -1;
  1193.     else if (axisFake[1] != 0)
  1194.       axisFake[1] *= -1;
  1195.     else
  1196.       axisFake[2] *= -1;
  1197.     Pnt3 axis1 = cross (norm, axisFake);
  1198.     Pnt3 axis2 = cross (norm, axis1);
  1199.     vtx.push_back (center - sizeX * axis1);
  1200.     vtx.push_back (center - sizeY * axis2);
  1201.     vtx.push_back (center + sizeX * axis1);
  1202.     vtx.push_back (center + sizeY * axis2);
  1204.     vector<int> tris;
  1205.     tris.push_back (1);
  1206.     tris.push_back (0);
  1207.     tris.push_back (2);
  1208.     tris.push_back (2);
  1209.     tris.push_back (0);
  1210.     tris.push_back (3);
  1211.     RigidScan* scan = CreateScanFromGeometry (vtx, tris, "fit_plane");
  1212.     scan->setXform (meshFrom->getXform());
  1213.     DisplayableMesh* dm = theScene->addMeshSet (scan, false);
  1214.     Tcl_VarEval (interp, "addMeshToWindow ", dm->getName(), NULL);
  1215.   }
  1217.   return TCL_OK;
  1218. }
  1221. static void readLinePixels (int x, int y, int w, int h,
  1222.     GLenum component, GLenum type,
  1223.     char* data, int dataSize)
  1224. {
  1225.   // wrapper for glReadPixels, reads from (x,y) to (x+w, y+h) along
  1226.   // straight line
  1227.   if (abs(w) > abs(h)) { // step horizontal
  1228.     int dx = 1;
  1229.     if (w < 0) { dx *= -1; w *= -1; }
  1231.     float yy = y;
  1232.     float dy = (float)h / w;
  1234.     for (int i = 0; i < w; i++) {
  1235.       glReadPixels (x, (int)yy, 1, 1, component, type,
  1236.     (void*)data);
  1237.       x += dx;
  1238.       yy += dy;
  1239.       data += dataSize;
  1240.     }
  1241.   } else { // step vertical
  1242.     int dy = 1;
  1243.     if (h < 0) { dy *= -1; h *= -1; }
  1245.     float xx = x;
  1246.     float dx = (float)w / h;
  1248.     for (int i = 0; i < h; i++) {
  1249.       glReadPixels ((int)xx, y, 1, 1, component, type,
  1250.     (void*)data);
  1251.       y += dy;
  1252.       xx += dx;
  1253.       data += dataSize;
  1254.     }
  1255.   }
  1256. }
  1259. bool findZBufferNeighbor (int x, int y, Pnt3& neighbor, int kMaxTries)
  1260. {
  1261.   return findZBufferNeighborExt (x, y, neighbor,
  1262.  toglCurrent, tbView, kMaxTries);
  1263. }
  1266. bool findZBufferNeighborExt (int x, int y, Pnt3& neighbor,
  1267.      struct Togl* togl, Trackball* tb,
  1268.      int kMaxTries, Pnt3* rawPt, bool bRedraw,
  1269.      bool bReadExistingFromFront)
  1270. {
  1271.   // find the closest point to (x,y) (screen coordinates);
  1272.   // unproject it and return in world coordinates
  1273.   // assumes GL screen coordinates (0,0 is lower left)
  1274.   Togl_MakeCurrent (togl);
  1275.   int oldReadBuffer;
  1276.   glGetIntegerv (GL_READ_BUFFER, &oldReadBuffer);
  1278.   if (bRedraw) {
  1279.     PushRenderParams();
  1281.     if (togl == toglCurrent)
  1282.       drawInToglBuffer (togl, GL_BACK);
  1283.     else {
  1284.       //hack warning -- assumes all togls except the main one have an
  1285.       //AlignmentToglInfo; need to change this
  1286.       DrawAlignmentMeshToBack (togl);
  1287.     }
  1289.     PopRenderParams();
  1290.     glReadBuffer (GL_BACK);
  1291.   } else {
  1292.     if (bReadExistingFromFront)
  1293.       glReadBuffer (GL_FRONT);
  1294.     else
  1295.       glReadBuffer (GL_BACK);
  1296.   }
  1298.   int inX = x, inY = y;
  1299.   float z = 1.0;
  1300.   int nTries = 0;
  1301.   int dir = 0;
  1302.   int leftThisDir = 1;
  1303.   float leftNextDir = 1.0;
  1304.   int W = Togl_Width (togl);
  1305.   int H = Togl_Height (togl);
  1307.   while (nTries++ < kMaxTries) {
  1308.     // avoid testing offscreen pixels
  1309.     if (x >= 0 && y >= 0 && x < W && y < H) {
  1310.       glReadPixels (x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &z);
  1311.       if (!ISBACKGROUND (z))
  1312. break;
  1313.     }
  1315.     // need to go 1R, 1U, 2L, 2D, 3R, 3U, 4L, 4D, etc.
  1316.     switch (dir) {
  1317.     case 0: x++; break;
  1318.     case 1: y++; break;
  1319.     case 2: x--; break;
  1320.     case 3: y--; break;
  1321.     }
  1322.     if (--leftThisDir == 0) {
  1323.       dir = (dir+1) % 4;
  1324.       leftThisDir = (int)(leftNextDir += .5);
  1325.     }
  1326.   }
  1328.   glReadBuffer ((GLenum) oldReadBuffer);
  1330.   if (ISBACKGROUND (z)) {
  1331.     cerr << "findZBufferNeighbor: nothing found among nearest " <<
  1332.       kMaxTries << " pixels to " << inX << ", " << inY << endl;
  1333.     return false;
  1334.   }
  1336.   Unprojector unproject (tb);
  1337.   neighbor = unproject (x, y, z);
  1339.   if (rawPt != NULL)
  1340.     rawPt->set (x, y, z);
  1342.   return true;
  1343. }
  1345. int
  1346. wsh_WarpMesh(ClientData clientData, Tcl_Interp *interp, 
  1347.      int argc, char *argv[])
  1348. {
  1349.   Mesh *theMesh = new Mesh();
  1351.   if (argc < 2) {
  1352.     interp->result = "Bad file name";
  1353.     return TCL_ERROR;
  1354.   }
  1356.   if ( theMesh->readPlyFile(argv[1]) == 0 ) {
  1357.     return TCL_ERROR;
  1358.   }
  1360.   theMesh->Warp();
  1362.   char buff[1000];
  1364.   sprintf(buff, "%s_warp", argv[1]);
  1366.   theMesh->writePlyFile(buff, 1, 0);
  1368.   return TCL_OK;
  1369. }
  1373. void
  1374. GetPtMeshMap (int w, int h, vector<DisplayableMesh*>& ptMeshMap)
  1375. {
  1376.   ptMeshMap.clear();
  1377.   ptMeshMap.insert (ptMeshMap.begin(), w*h, NULL);
  1378.   if (!theScene->meshSets.size())
  1379.     return;
  1381.   Togl_MakeCurrent (toglCurrent);
  1382.   int scale = 16;   // unimportant as long as small -- cuts into range
  1383.   drawSceneIndexColored (scale);
  1384.   
  1385.   vector<uchar> rgb;
  1386.   rgb.reserve (w * h * 4);
  1388.   glReadBuffer (GL_BACK);
  1389.   glPixelStorei (GL_PACK_ALIGNMENT, 4);
  1390.   glReadPixels (0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, rgb.begin());
  1392.   int nErrors = 0;
  1393.   for (int y = 0; y < h; y++) {
  1394.     int yofs = y * w;
  1395.     for (int x = 0; x < w; x++) {
  1396.       int ofs = yofs + x;
  1397.       int ofs4 = 4 * ofs;
  1399.       uchar r = rgb[ofs4];
  1400.       uchar g = rgb[ofs4+1];
  1401.       uchar b = rgb[ofs4+2];
  1403.       int i = b * 1024 + g * 32 + r;
  1404.       i /= 8 * scale;
  1406.       i--; // since it's 0-based encoded in frame buffer, but really 0 is
  1407.       // background, and 1..n are meshes 0..n-1
  1408.       if (i < 0) {
  1409. // background, no mesh
  1410. ptMeshMap[ofs] = NULL;
  1411.       } else if (i >= 0 && i < theScene->meshSets.size()) {
  1412. //printf ("Found: %d,%d has mesh #%dn", x, y, i);
  1413. ptMeshMap[ofs] = theScene->meshSets[i];
  1414.       } else {
  1415. //printf ("Error: %d,%d has mesh #%d (rgb=%02x,%02x,%02x)n",
  1416. // x, y, i, (int)r, (int)g, (int)b);
  1417. ++nErrors;
  1418. ptMeshMap[ofs] = NULL;
  1419.       }
  1420.     }
  1421.   }
  1423.   if (nErrors)
  1424.     cerr << "Warning: " << nErrors << " pixels could not be read... "
  1425.  << "perhaps the rendering window is obscured?" << endl;
  1426. }
  1429. // Code stolen from GetPtMeshMap
  1430. // In this case we just want a list of the visible meshes in the
  1431. // current view. We return a vector of meshes. Set to NULL if the
  1432. // Mesh is invisible. Set to a pointer to the mesh, if it is visible.
  1433. void
  1434. GetPtMeshVector (int xstart, int ystart, int w, int h,
  1435.  int winwidth, int winheight,
  1436.  vector<DisplayableMesh*>& ptMeshMap)
  1437. {
  1438.   if (xstart < 0) xstart = 0;
  1439.   if (ystart < 0) ystart = 0;
  1440.   if (xstart+w > winwidth) w = winwidth-xstart;
  1441.   if (ystart+h > winheight) h = winheight-ystart;
  1443.   // printf ("%d %d %d %d %d %dn",xstart,ystart,w,h,winwidth,winheight);
  1444.   
  1445.   ptMeshMap.clear();
  1446.   // Set every mesh to NULL initially
  1447.   ptMeshMap.insert (ptMeshMap.begin(),theScene->meshSets.size(), NULL);
  1448.   if (!theScene->meshSets.size())
  1449.     return;
  1451.   Togl_MakeCurrent (toglCurrent);
  1452.   int scale = 16;   // unimportant as long as small -- cuts into range
  1453.   drawSceneIndexColored (scale);
  1454.   
  1455.   vector<uchar> rgb;
  1456.   rgb.reserve (winwidth * winheight * 4);
  1457.  
  1458.   glReadBuffer (GL_BACK);
  1459.   glPixelStorei (GL_PACK_ALIGNMENT, 4);
  1460.   glReadPixels (0, 0, winwidth, winheight, GL_RGBA, GL_UNSIGNED_BYTE, rgb.begin());
  1462.   // cerr << "Check In:" << xstart << " " << ystart << " " << w << " " << h << "n";
  1463.   int nErrors = 0;
  1464.   for (int y = ystart; y < h+ystart; y++) {
  1465.     int yofs = y * winwidth;
  1466.     for (int x = xstart; x < w+xstart; x++) {
  1467.       int ofs = yofs + x;
  1468.       int ofs4 = 4 * ofs;
  1470.       char r = rgb[ofs4];
  1471.       char g = rgb[ofs4+1];
  1472.       char b = rgb[ofs4+2];
  1474.       int i = b * 1024 + g * 32 + r;
  1475.       i /= 8 * scale;
  1477.       i--; // since it's 0-based encoded in frame buffer, but really 0 is
  1478.       // background, and 1..n are meshes 0..n-1
  1479.       if (i < 0) {
  1480. // background, no mesh
  1482.       } else if (i >= 0 && i < theScene->meshSets.size()) {
  1484. ptMeshMap[i] = theScene->meshSets[i];
  1485.       } else {
  1486. //printf ("Error: %d,%d has mesh #%d (rgb=%02x,%02x,%02x)n",
  1487. // x, y, i, (int)r, (int)g, (int)b);
  1488. ++nErrors;
  1489. ptMeshMap[ofs] = NULL;
  1490.       }
  1491.     }
  1492.   }
  1494.   if (nErrors)
  1495.     cerr << "Warning: " << nErrors << " pixels could not be read... "
  1496.  << "perhaps the rendering window is obscured?" << endl;
  1497. }
  1499. int wsh_AlignPointsToPlane(ClientData clientData, Tcl_Interp *interp, 
  1500.  int argc, char *argv[])
  1501. {
  1502.   if ( argc < 8 ) {
  1503.     interp->result = "wsh_AlignPointsToPlane: insufficient args";
  1504.     return TCL_ERROR;
  1505.   }
  1507.   DisplayableMesh* meshDisp = FindMeshDisplayInfo (argv[1]);
  1508.   if (!meshDisp) {
  1509.     interp->result = "wsh_AlignPointsToPlane: missing mesh";
  1510.     return TCL_ERROR;
  1511.   }
  1512.   RigidScan* meshFrom = meshDisp->getMeshData();  
  1514.   int x1 = atoi(argv[2]);
  1515.   int y1 = atoi(argv[3]);
  1516.   int x2 = atoi(argv[4]);
  1517.   int y2 = atoi(argv[5]);
  1518.   int x3 = atoi(argv[6]);
  1519.   int y3 = atoi(argv[7]);
  1520.   
  1521.   Pnt3 p1, p2, p3;
  1523.   printf("%i %i, %i %i, %i %in", x1, y1, x2, y2, x3, y3);
  1525.   findZBufferNeighbor(x1, y1, p1, 400);
  1526.   findZBufferNeighbor(x2, y2, p2, 400);
  1527.   findZBufferNeighbor(x3, y3, p3, 400);
  1529.   /*
  1530.   printf("%f %f %f, %f %f %f, %f %f %fn", p1[0], p1[1], p1[2],
  1531.  p2[0], p2[1], p2[2], p3[0], p3[1], p3[2]);
  1532.   */
  1534.   Pnt3 v1 = p1 - p3;
  1535.   Pnt3 v2 = p2 - p3;
  1537.   Pnt3 planeNorm = cross(v1, v2);
  1539.   planeNorm.normalize();
  1541.   Pnt3 target(0, 0, 1);
  1543.   if (planeNorm[2] < 0) {
  1544.     target *= -1;
  1545.   }
  1547.   float cosTh = dot(planeNorm, target);
  1548.   //  cout << cosTh << endl;
  1549.   Pnt3 axis = cross (planeNorm, target);  
  1550.   if (fabs (cosTh - 1.0) > 1.e-6) {
  1551.     //    axis.normalize();
  1552.     printf("z: %f %f %f, %fn", axis[0], axis[1], axis[2], cosTh);
  1554.     tbView->rotateAroundAxis (axis, acos(cosTh), meshFrom);
  1555.     theScene->computeBBox();
  1556.     redraw (true);
  1557.   } else {
  1558.     cout << "Scanalyze considers it futile to try to make this any flatter"
  1559.  << endl;
  1560.   }
  1562.   Xform<double> theXform;
  1563.   theXform.rot(acos(cosTh), axis[0], axis[1], axis[2]);
  1565.   Pnt3 tp1, tp2;
  1566.   theXform.apply(p1, tp1);
  1567.   theXform.apply(p2, tp2);
  1569.   Pnt3 planex = tp2 - tp1;
  1570.   planex.normalize();
  1571.   Pnt3 htarget(1, 0, 0);
  1573.   float hcosTh = dot(planex, htarget);
  1574.   if (fabs (hcosTh - 1.0) > 1.e-6) {
  1575.     Pnt3 haxis = cross (planex, htarget);
  1576.     
  1577.     printf("x: %f %f %f, %fn", haxis[0], haxis[1], haxis[2], hcosTh);
  1579.     tbView->rotateAroundAxis (haxis, acos(hcosTh), meshFrom);
  1580.     theScene->computeBBox();
  1581.     redraw (true);
  1582.   } else {
  1583.     cout << "Scanalyze considers it futile to try to make this any flatter"
  1584.  << endl;
  1585.   }  
  1587.   return TCL_OK;
  1588. } //wsh_AlignPointsToPlane
  1591. Auto_a_Line *lines_g = NULL;
  1593. int
  1594. PlvDrawAnalyzeLines(ClientData clientData, Tcl_Interp *interp, 
  1595.  int argc, char *argv[])
  1596. {
  1597.   if ( argc < 8 ) {
  1598.     interp->result = "wsh_DrawAnalyzeLines: incorrect number of args";
  1599.     return TCL_ERROR;
  1600.   }
  1602.   struct Togl *togl = toglHash.FindTogl(argv[1]);
  1603.   char axis = argv[2][0];
  1604.   int x0 = atoi(argv[3]);
  1605.   int y0 = atoi(argv[4]);
  1606.   int len = atoi(argv[5]);
  1607.   int space = atoi(argv[6]);
  1608.   int num = atoi(argv[7]);
  1610.   // output lines to rgb file
  1611.   lines_g = new Auto_a_Line(togl, axis, x0, y0, len, space, num);
  1612.   redraw(true);
  1614.   return TCL_OK;
  1615. }
  1617. // PlvClearAnalyzeLines
  1618. // a hack: the screen dump only seems to work correctly if called from tcl only
  1619. // but since the Auto_a_Line is created in C, I need to make a call to this 
  1620. // function to properly clean up.
  1621. int
  1622. PlvClearAnalyzeLines(ClientData clientData, Tcl_Interp *interp, 
  1623.  int argc, char *argv[])
  1624. {
  1625.   if ( lines_g != NULL ) {
  1626.     delete lines_g;
  1627.     lines_g = NULL;
  1628.     redraw(true);
  1629.     return TCL_OK;
  1630.   }
  1632.   interp->result = "Can't clear analyze lines because they are NULL";
  1633.   return TCL_ERROR;
  1634. }
  1636. // -------------------------------------
  1637. // Auto_a_Line
  1638. // the 2d lines that represent the cross sections made in
  1639. // auto-analysis
  1640. // -------------------------------------
  1641. extern DrawObjects draw_other_things;
  1643. Auto_a_Line::Auto_a_Line(Togl *_togl, char _axis, int _x0, int _y0, 
  1644.  int _len, int _space, int _num)
  1645. {
  1646.   togl = _togl;
  1647.   axis = _axis;
  1648.   x0 = _x0;
  1649.   y0 = _y0;
  1650.   len = _len;
  1651.   space = _space;
  1652.   num = _num;
  1655.   draw_other_things.add(this);
  1656. }
  1658. Auto_a_Line::~Auto_a_Line()
  1659. {
  1660.   draw_other_things.remove(this);
  1661. }
  1663. void
  1664. Auto_a_Line::drawthis()
  1665. {
  1666.   int width, height;
  1667.   
  1668.   width = Togl_Width (togl);
  1669.   height = Togl_Height (togl);
  1671.   glPushMatrix();
  1672.   
  1673.   glViewport(0, 0, width, height);
  1674.   glMatrixMode(GL_PROJECTION);
  1675.   glLoadIdentity();
  1676.   //  gluOrtho2D(-0.5, width+0.5, -0.5, height+0.5);
  1677.   gluOrtho2D(0, width, 0, height);
  1678.   
  1679.   glMatrixMode(GL_MODELVIEW);
  1680.   glLoadIdentity();
  1681.   
  1682.   glPushAttrib (GL_LIGHTING_BIT);
  1683.   glDisable (GL_LIGHTING);
  1685.   glColor3f(0, 1.0, 0);
  1686.   for ( int i = 0; i < num; i++ ) {
  1687.     glBegin(GL_LINES);
  1688.     if ( axis == 'y' ) { // 1 == y axis
  1689.       glVertex2i( x0, height - y0 - i*space );
  1690.       glVertex2i( x0 + len, height - y0 - i*space );
  1691.     } else { // x axis
  1692.       glVertex2i( x0 + i*space, y0);
  1693.       glVertex2i( x0 + i*space, y0 + len);
  1694.     }
  1695.     glEnd();
  1696.     printf("heren");
  1697.   }
  1698.   glPopAttrib();
  1699.   glPopMatrix();
  1701.   glFinish();
  1702. }