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

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

3D图形编程

开发平台：

Visual C++

plvViewerCmds.cc：源码内容
  1. #include <iostream.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4. #include "plvGlobals.h"
  5. #include "plvDraw.h"
  6. #include "plvViewerCmds.h"
  7. #include "plvMeshCmds.h"
  8. #include "plvDrawCmds.h"
  9. #include "togl.h"
  10. #include "RigidScan.h"
  11. #include "DisplayMesh.h"
  12. #include "plvAnalyze.h"
  13. #include "VolCarve.h"
  14. #include "Timer.h"
  15. #include "ToglCache.h"
  16. #include "ScanFactory.h"
  17. #include "plvClipBoxCmds.h"
  18. #include "VertexFilter.h"
  19. #include "cmdassert.h"
  20. #include "TclCmdUtils.h"
  21. #include "plvScene.h"
  22. #include "GroupScan.h"
  25. static bool s_bManipulatingLocked = false;
  26. static bool s_bForceOnscreen = false;
  27. static crope s_autoResetScript;
  28. static int  s_iAutoResetTime;
  29. static void rescheduleAutoReset (void);
  32. static void lastActionTrackball (void)
  33. {
  34.   if (toglCurrent)
  35.     Tcl_Eval (Togl_Interp (toglCurrent), "autoClearSelection");
  36. }
  39. int
  40. PlvSelectScanCmd(ClientData clientData, Tcl_Interp *interp, 
  41.  int argc, char *argv[])
  42. {
  43.   if (argc < 2) {
  44.     interp->result = "Wrong number of args";
  45.     return TCL_ERROR;
  46.   }
  48.   // if argv[1] == "", the viewer is active
  49.   DisplayableMesh* scan = FindMeshDisplayInfo (argv[1]);
  51.   if (strlen(argv[1]) && scan == NULL) {
  52.     interp->result = "Could not find mesh";
  53.     return TCL_ERROR;
  54.   }
  56.   DisplayableMesh* oldActiveScan = theActiveScan;
  57.   if (argc > 2 && !strcmp (argv[2], "manipulate")) {
  58.     theActiveScan = scan;
  59.   } else {
  60.     theSelectedScan = scan;
  61.   }
  63.   if (!g_bNoUI) {
  64.     if (theActiveScan != oldActiveScan
  65. || theRenderParams->colorMode == registrationColor) {
  66.       redraw (true);
  67.     }
  68.   }
  70.   return TCL_OK;
  71. }
  73. int
  74. PlvSetVisibleCmd(ClientData clientData, Tcl_Interp *interp, 
  75.      int argc, char *argv[])
  76. {
  77.   if (argc < 3) {
  78.     interp->result = "Wrong number of args";
  79.     return TCL_ERROR;
  80.   }
  82.   DisplayableMesh *meshSet = FindMeshDisplayInfo (argv[1]);
  84.   if (meshSet == NULL) {
  85.     interp->result = "Could not find mesh";
  86.     return TCL_ERROR;
  87.   }
  89.   bool bVisible;
  90.   SetBoolFromArgIndex (2, bVisible);
  91.   meshSet->setVisible (bVisible);
  92.   
  93.   theScene->computeBBox();
  94.   redraw (true);
  95.   
  96.   return TCL_OK;
  97. }
  99. int
  100. PlvGetVisibleCmd(ClientData clientData, Tcl_Interp *interp, 
  101.  int argc, char *argv[])
  102. {
  103.   if (argc < 2) {
  104.     interp->result = "Wrong number of args";
  105.     return TCL_ERROR;
  106.   }
  108.   DisplayableMesh *meshSet = FindMeshDisplayInfo (argv[1]);
  110.   if (meshSet == NULL) {
  111.     interp->result = "Could not find mesh";
  112.     return TCL_ERROR;
  113.   }
  115.   interp->result = meshSet->getVisible() ? "1" : "0";
  116.   return TCL_OK;
  117. }
  119. static void
  120. PlvListScansHelper (Tcl_Interp *interp, vector<DisplayableMesh*> meshes, bool bLeaf);
  121. // NEW! IMPROVED!!
  122. int
  123. PlvListScansCmd(ClientData clientData, Tcl_Interp *interp, 
  124. int argc, char *argv[])
  125. {
  126.   // options:
  127.   // default,roots = only meshes with no parent
  128.   // leaves = all meshes with no children
  129.   // groups = all groups (i.e. "meshes" with children)
  130.   
  131.   bool bRoot = false;
  132.   bool bLeaf = false;
  134.   if (argc > 2) {
  135.     interp->result = "Too many arguments to PlvListScansCmd";
  136.     return TCL_ERROR;
  137.   }
  138.   
  139.   if (argc == 1) bRoot = true; // i.e. default mode
  141.   else {
  142.     if (!strcmp (argv[1], "root"))
  143.       bRoot = true;
  144.     else if (!strcmp (argv[1], "leaves"))
  145.       bLeaf = true;
  146.     else if (!strcmp (argv[1], "groups"))
  147.       bLeaf = false;
  148.     else {
  149.       interp->result = "Bad option to PlvListScansCmd";
  150.       return TCL_ERROR;
  151.     }
  152.   }
  153.   
  154.   if (bRoot) {
  155.     for (DisplayableMesh** pdm = theScene->meshSets.begin();
  156.  pdm < theScene->meshSets.end(); pdm++) {
  157.       
  158.       // Thus, since theScene->meshSets only stores the roots,
  159.       // all we need to do by default is append
  160.       Tcl_AppendElement (interp, (char*)(*pdm)->getName());
  161.     }
  162.   } else 
  163.     PlvListScansHelper (interp, theScene->meshSets, bLeaf);
  164.   return TCL_OK;
  165. }
  167. static void
  168. PlvListScansHelper (Tcl_Interp *interp, vector<DisplayableMesh*> meshes, bool bLeaf) 
  169. {
  170.   for (DisplayableMesh** pdm = meshes.begin(); pdm < meshes.end(); pdm++) {
  171.     vector<DisplayableMesh*>children;
  172.     
  173.     GroupScan *gp = dynamic_cast<GroupScan*>((*pdm)->getMeshData());
  174.     if (gp) {
  175.       bool bGroup = gp->get_children_for_display(children);
  176.       assert (bGroup);
  177.       if (!bLeaf) Tcl_AppendElement(interp, (char*) (*pdm)->getName());
  178.       PlvListScansHelper(interp, children, bLeaf);
  179.     } else {
  180.       if (bLeaf) Tcl_AppendElement(interp, (char*) (*pdm)->getName());
  181.       //      else PlvListScansHelper(interp, children, bLeaf);
  182.     }
  183.   }
  184. }
  187. int
  188. PlvLightCmd(ClientData clientData, Tcl_Interp *interp, 
  189.     int argc, char *argv[])
  190. {
  191.     char result[PATH_MAX];
  193.     if (argc != 1 && argc != 4) {
  194. interp->result = "Wrong number of args";
  195. return TCL_ERROR;
  196.     }
  198.     if (argc == 4) {
  199. theRenderParams->lightPosition[0] = atof(argv[1]);
  200. theRenderParams->lightPosition[1] = atof(argv[2]);
  201. theRenderParams->lightPosition[2] = atof(argv[3]);
  202.     } else {
  203. sprintf(result, "plv_light %f %f %f",
  204. theRenderParams->lightPosition[0],
  205. theRenderParams->lightPosition[1],
  206. theRenderParams->lightPosition[2]);
  207. Tcl_SetResult(interp, result, TCL_VOLATILE);
  208.     }
  210.     return TCL_OK;
  211. }
  214. int
  215. PlvRotateLightCmd(ClientData clientData, Tcl_Interp *interp, 
  216.    int argc, char *argv[])
  217. {
  218.   float x, y, z;
  220.   // project rectangular coordinates onto hemisphere
  221.   x = (2 * atoi(argv[2]) / (float)theWidth) - 1;
  222.   y = (-2 *atoi(argv[3]) / (float)theHeight) + 1;
  224.   if (x < -1) x = -1; else if (x > 1) x = 1;
  225.   if (y < -1) y = -1; else if (y > 1) y = 1;
  227.   z = (1 - x*x - y*y);
  228.   if (z < 0)
  229.     z = -sqrt (-z);
  230.   else if (z != 0)    // avoid sqrt(0)
  231.     z = sqrt (z);
  233.   // set theRenderParams->lightPosition
  234.   theRenderParams->lightPosition[0] = x;
  235.   theRenderParams->lightPosition[1] = y;
  236.   theRenderParams->lightPosition[2] = z;
  238.   rescheduleAutoReset();
  239.   redraw (true);
  241.   return TCL_OK;
  242. }
  245. int
  246. PlvOrthographicCmd(ClientData clientData, Tcl_Interp *interp, 
  247.    int argc, char *argv[])
  248. {
  249.   tbView->setOrthographic (true);
  250.   redraw (true);
  252.   return TCL_OK;
  253. }
  257. int
  258. PlvPerspectiveCmd(ClientData clientData, Tcl_Interp *interp, 
  259.   int argc, char *argv[])
  260. {
  261.   tbView->setOrthographic (false);
  262.   redraw (true);
  264.   return TCL_OK;
  265. }
  268. int
  269. PlvZoomAngleCmd(ClientData clientData, Tcl_Interp *interp, 
  270. int argc, char *argv[])
  271. {
  272.   tbView->changeFOV(atof(argv[1]));
  273.   redraw (true);
  275.   return TCL_OK;
  276. }
  279. int
  280. PlvObliqueCameraCmd(ClientData clientData, Tcl_Interp *interp, 
  281. int argc, char *argv[])
  282. {
  283.   if (argc > 2)
  284.    tbView->setObliqueCamera(atof(argv[1]), atof(argv[2]));
  285.   redraw (true);
  287.   return TCL_OK;
  288. }
  292. int
  293. PlvViewAllCmd(ClientData clientData, Tcl_Interp *interp, 
  294.       int argc, char *argv[])
  295. {
  296.   redraw (true);
  297.   return TCL_OK;
  298. }
  301. int
  302. PlvResetXformCmd(ClientData clientData, Tcl_Interp *interp, 
  303.  int argc, char *argv[])
  304. {
  305.   DisplayableMesh* meshDisp = NULL;
  306.   bool bMeshesOnly = false;
  307.   bool bAllMeshes = false;
  309.   if (argc > 1) {
  310.     if (!strcmp (argv[1], "all")) {
  311.       bAllMeshes = true;
  312.     } else if (!strcmp (argv[1], "allmesh")) {
  313.       bMeshesOnly = true; bAllMeshes = true;
  314.     }
  315.     
  316.     if (bAllMeshes) {
  317.       for (int i = 0; i < theScene->meshSets.size(); i++)
  318. theScene->meshSets[i]->getMeshData()->resetXform();
  319.     } else {
  320.       meshDisp = FindMeshDisplayInfo (argv[1]);
  321.     }
  322.   }
  324.   if (meshDisp != NULL)
  325.     meshDisp->getMeshData()->resetXform();
  326.   else {
  327.     if (!bMeshesOnly) {
  328.       theScene->computeBBox();
  329.       theScene->centerCamera();
  330.     }
  331.   }
  332.   
  333.   redraw (true);  
  334.   return TCL_OK;
  335. }
  338. // give me GL (lower-left origin) screen coordinates!
  340. static void
  341. resetTranslationScale (int x, int y)
  342. {
  343.   Pnt3 clickWorld, clickScreen;
  344.   if (findZBufferNeighborExt (x, y, clickWorld, toglCurrent, tbView,
  345.       100, &clickScreen, false)) {
  346.     tbView->setTransScale (clickScreen);
  347.   } else {
  348.     // do we want to fall back on old method (average-case guess for
  349.     // transScale) or keep using the last intelligently computed
  350.     // transScale?
  351.     tbView->setTransScale();
  352.     //cerr << "resetting scale" << endl;
  353.   }
  354. }
  357. static Pnt3
  358. screenRotationCenter (void)
  359. {
  360.   int x = theWidth / 2;
  361.   int y = theHeight / 2;
  363.   Pnt3 clickWorld, clickScreen;
  364.   if (!findZBufferNeighborExt (x, y, clickWorld,
  365.        toglCurrent, tbView, 100)) {
  366.     // force unproject of (x, y, z) where z is middle of scene depth
  367.     Unprojector unproject (tbView);
  369.     Pnt3 nearz = unproject.forward (theScene->worldBbox().min());
  370.     Pnt3 farz = unproject.forward (theScene->worldBbox().max());
  371.     clickWorld = unproject (x, y, (nearz[2] + farz[2]) / 2);
  372.   }
  374.   return clickWorld;
  375. }
  378. static bool
  379. passesOnscreenTest (int oldSize = -1, bool bOnlyQuery = false)
  380. {
  381.   // scene bbox must have at least 1 corner within inner 80% of screen,
  382.   // and area at least 1% of screen.
  384.   // this test is definitely not perfect; you can get the whole model
  385.   // offscreen while keeping one bbox corner on, and you can't zoom in
  386.   // very far because you'll lose all the corners pretty quick.  But it
  387.   // works pretty well.
  389.   int xmargin = theWidth / 10;
  390.   int ymargin = theHeight / 10;
  391.   TbObj tbObjIdentity;
  392.   ScreenBox sb (&tbObjIdentity,
  393. xmargin, theWidth - xmargin,
  394. ymargin, theHeight - ymargin);
  395.   theScene->computeBBox (Scene::sync);
  397.   bool onscreen = false;
  398.   int minx = INT_MAX, miny = INT_MAX, maxx = ~INT_MAX, maxy = ~INT_MAX;
  400.   Bbox bb = theScene->worldBbox();
  401.   Pnt3 center = sb.getProjector() (bb.center());
  403.   for (int i = 0; i < 8; i++) {
  404.     Pnt3 corner = bb.corner (i);
  405.     if (sb.accept (corner))
  406.       onscreen = true;
  407.     
  408.     Pnt3 screen = sb.getProjector() (corner);
  409.     minx = MIN (minx, screen[0]);
  410.     maxx = MAX (maxx, screen[0]);
  411.     miny = MIN (miny, screen[1]);
  412.     maxy = MAX (maxy, screen[1]);
  413.   }
  415.   int area = (maxx - minx) * (maxy - miny);
  416.   if (bOnlyQuery) {
  417.     oldSize = area;
  419.   } else {
  421.     if (!onscreen) { // all 8 failed
  422.       cerr << "onscreen test fails: All corners offscreen!" << endl;
  423.       return false;
  424.     }
  426.     int minsize = theWidth * theHeight * .01;
  427.     if (oldSize == -1)
  428.       oldSize = minsize;
  429.     
  430.     if (tbView->isZooming() || !tbView->isManipulating()) {
  431.       // don't let them zoom out too far.
  432.       if (area < MIN (oldSize, minsize)) {
  433. cerr << "onscreen test fails: bbox covers only " << area 
  434.      << " and it was " << oldSize << endl;
  435. return false;
  436.       }
  437.     }
  438.   }
  440.   return true;
  441. }
  444. static void
  445. passMoveToTrackball (int x, int y, int t) {
  446.   Xform<float> before;
  447.   int oldSize = -1;
  448.   if (s_bForceOnscreen) {
  449.     before = tbView->getUndoXform();
  450.     passesOnscreenTest (oldSize, true);
  451.     rescheduleAutoReset();
  452.   }
  454.   tbView->move(x, y, t, MeshData(theActiveScan));
  455.   theScene->computeBBox();
  457.   if (s_bForceOnscreen && !passesOnscreenTest (oldSize)) {
  458.     cerr << "annulling trackball action" << endl;
  459.     tbView->setUndoXform (before);
  460.   } else {
  461.     redraw (true);
  462.   }
  463. }
  466. int
  467. PlvRotateXYViewMouseCmd(ClientData clientData, Tcl_Interp *interp, 
  468.    int argc, char *argv[])
  469. {
  470.   if (!strcmp (argv[2], "stopspin")) {
  471.     tbView->stop();
  472.     return TCL_OK;
  473.   }
  474.   
  475.   int x = atoi(argv[2]);
  476.   int y = atoi(argv[3]);
  477.   int t = atoi(argv[4]);
  479.   if (argc > 5) {
  480.     prepareDrawInWin(argv[1]);
  482.     if (!strcmp (argv[5], "start")) {
  483.       lastActionTrackball();
  484.       tbView->pressButton (1, 0, x, y, t, MeshData(theActiveScan));
  485.     } else {
  486.       tbView->pressButton (1, 1, x, y, t, MeshData(theActiveScan));
  488.       if (!tbView->isManipulating()) {
  489. if (manipulatedRenderDifferent())
  490.   redraw (true);
  491.       }
  492.     }
  494.     return TCL_OK;
  495.   }
  497.   passMoveToTrackball (x, y, t);
  498.   return TCL_OK;
  499. }
  502. int
  503. PlvTransXYViewMouseCmd(ClientData clientData, Tcl_Interp *interp, 
  504.   int argc, char *argv[])
  505. {
  506.   //cout << "transxyview" << endl;
  507.   int x, y, t;
  509.   x = atoi(argv[2]);
  510.   y = atoi(argv[3]);
  511.   t = atoi(argv[4]);
  513.   if (argc > 5) {
  514.     prepareDrawInWin(argv[1]);
  516.     if (!strcmp (argv[5], "start")) {
  517.       lastActionTrackball();
  518.       tbView->pressButton (2, 0, x, y, t, MeshData(theActiveScan));
  519.       if (tbView->isPanning())
  520. resetTranslationScale (x, theHeight - 1 - y);
  521.     } else {
  522.       tbView->pressButton (2, 1, x, y, t, MeshData(theActiveScan));
  524.       if (!tbView->isManipulating()) {
  525. if (manipulatedRenderDifferent())
  526.   redraw (true);
  527.       }
  528.     }
  530.     return TCL_OK;
  531.   }
  533.   passMoveToTrackball (x, y, t);
  534.   return TCL_OK;
  535. }
  538. int
  539. PlvTranslateInPlaneCmd(ClientData clientData, Tcl_Interp *interp, 
  540.        int argc, char *argv[])
  541. {
  542.   if (argc < 3) {
  543.     interp->result = "Bad args to PlvTranslateInPlaneCmd";
  544.     return TCL_ERROR;
  545.   }
  547.   float dx = atof (argv[1]);
  548.   float dy = atof (argv[2]);
  550.   Pnt3 dt (dx, dy, 0);
  551.   TbObj* target = MeshData(theActiveScan);
  552.   //tbView->saveUndoPos (target);
  553.   tbView->translateInEyeCoords (dt, target);
  555.   theScene->computeBBox();
  556.   redraw (true);
  558.   return TCL_OK;
  559. }
  562. int
  563. PlvUndoXformCmd(ClientData clientData, Tcl_Interp *interp, 
  564. int argc, char *argv[])
  565. {
  566.   //tbView->undo_last();
  567.   TbObj::undo();
  568.   theScene->computeBBox();
  569.   redraw (true);
  571.   return TCL_OK;
  572. }
  575. int
  576. PlvRedoXformCmd(ClientData clientData, Tcl_Interp *interp, 
  577. int argc, char *argv[])
  578. {
  579.   //tbView->undo_last();
  580.   TbObj::redo();
  581.   theScene->computeBBox();
  582.   redraw (true);
  584.   return TCL_OK;
  585. }
  588. int
  589. PlvGetScreenToWorldCoords(ClientData clientData, Tcl_Interp *interp, 
  590.      int argc, char *argv[])
  591. {
  592.   if (argc != 3) {
  593.     interp->result = "Bad arguments to PlvGetScreenToWorldCoords";
  594.     return TCL_ERROR;
  595.   }
  597.   int x = atoi(argv[1]);
  598.   int y = theHeight - atoi(argv[2]);
  600.   Pnt3 coords;
  601.   char answer[200];
  602.   if (ScreenToWorldCoordinates (x, y, coords)) {
  603.     sprintf (answer, "%g %g %g", coords[0], coords[1], coords[2]);
  604.   } else if (findZBufferNeighbor (x, y, coords)) {
  605.     sprintf (answer, "Hit background; nearest point: %g %g %g",
  606.      coords[0], coords[1], coords[2]);
  607.   } else {
  608.     strcpy (answer, "Hit background");
  609.   }
  611.   
  612.   Tcl_SetResult (interp, answer, TCL_VOLATILE);
  613.   return TCL_OK;
  614. }
  617. int
  618. PlvSetThisAsCenterOfRotation(ClientData clientData, Tcl_Interp *interp, 
  619.      int argc, char *argv[])
  620. {
  621.   if (argc != 3) {
  622.     interp->result = "Bad arguments to PlvSetThisAsCenterOfRotation";
  623.     return TCL_ERROR;
  624.   }
  626.   int x = atoi(argv[1]);
  627.   int y = theHeight - atoi(argv[2]);
  629.   Pnt3 newcenter;
  630.   if (findZBufferNeighbor (x, y, newcenter))
  631.   {
  632.     tbView->newRotationCenter(newcenter, MeshData(theActiveScan));
  633.     return TCL_OK;  
  634.   }
  635.   else
  636.   {
  637.     interp->result =
  638.       "We hit a background pixel.  You must click on the mesh.n";
  639.     return TCL_ERROR;
  640.   }
  641. }
  644. int
  645. PlvResetCenterOfRotation(ClientData clientData, Tcl_Interp *interp, 
  646.  int argc, char *argv[])
  647. {
  648.   Pnt3 center;
  650.   if (!strcmp (argv[1], "screen")) {
  652.     if (theActiveScan != NULL) {
  653.       interp->result = "Don't use screen-centered rotation for moveMesh";
  654.       return TCL_ERROR;
  655.     }
  656.     center = screenRotationCenter();
  658.   } else if (!strcmp (argv[1], "object")) {
  660.     if (theActiveScan == NULL) {
  661.       theScene->computeBBox (Scene::sync);
  662.       center = theScene->worldCenter();
  663.     } else {
  664.       theActiveScan->getMeshData()->computeBBox();
  665.       center = theActiveScan->getMeshData()->worldCenter();
  666.     }
  668.   } else {
  670.     interp->result = "Must specify object|screen to PlvResetCoR";
  671.     return TCL_ERROR;
  673.   }
  675.   tbView->newRotationCenter (center, MeshData(theActiveScan));
  677.   return TCL_OK;
  678. }
  681. int
  682. PlvCameraInfoCmd(ClientData clientData, Tcl_Interp *interp, 
  683.  int argc, char *argv[])
  684. {
  685.   char transform[100];
  687.   float quat[4];
  688.   float trans[3];
  689.   float camera[3];
  691.   tbView->getXform (quat, trans);
  692.   tbView->getCameraCenter (camera);
  693.   for (int i = 0; i < 3; i++)
  694.     trans[i] += camera[i];
  696.   sprintf (transform, "%g %g %gn%g %g %g %gn",
  697.    trans[0], trans[1], trans[2],
  698.    quat[0], quat[1], quat[2], quat[3]);
  700.   if (argc > 1 && 0 == strcmp (argv[1], "graphical"))
  701.     Tcl_SetResult (interp, transform, TCL_VOLATILE);
  702.   else
  703.     printf ("%sn", transform);
  705.   return TCL_OK;
  706. }
  709. int
  710. PlvSetHomeCmd(ClientData clientData, Tcl_Interp *interp, 
  711.       int argc, char *argv[])
  712. {
  713.   if (argc != 2) {
  714.     interp->result = "Bad arguments to PlvSetHomeCmd";
  715.     return TCL_ERROR;
  716.   }
  718.   DisplayableMesh* ms;
  719.   if (0 == strcmp (argv[1], "")) {
  720.     ms = NULL;
  721.   } else {
  722.     ms = FindMeshDisplayInfo (argv[1]);
  723.     if (ms == NULL) {
  724.       interp->result = "Missing meshset in PlvSetHomeCmd";
  725.       return TCL_ERROR;
  726.     }
  727.   }
  729.   if (ms == NULL) { // viewer
  730.     theScene->setHome();
  731.   } else {
  732.     ms->setHome();
  733.   }
  735.   return TCL_OK;
  736. }
  739. int
  740. PlvGoHomeCmd(ClientData clientData, Tcl_Interp *interp, 
  741.       int argc, char *argv[])
  742. {
  743.   if (argc != 2) {
  744.     interp->result = "Bad arguments to PlvGoHomeCmd";
  745.     return TCL_ERROR;
  746.   }
  748.   DisplayableMesh* ms;
  749.   if (0 == strcmp (argv[1], "")) {
  750.     ms = NULL;
  751.   } else {
  752.     ms = FindMeshDisplayInfo (argv[1]);
  753.     if (ms == NULL) {
  754.       interp->result = "Missing meshset in PlvGoHomeCmd";
  755.       return TCL_ERROR;
  756.     }
  757.   }
  759.   if (ms == NULL) { // viewer
  760.     theScene->goHome();
  761.   } else {
  762.     ms->goHome();
  763.   }
  765.   redraw (true);
  766.   return TCL_OK;
  767. }
  770. int
  771. PlvSetOverallResCmd(ClientData clientData, Tcl_Interp *interp, 
  772.     int argc, char *argv[])
  773. {
  774.   if (argc != 2) {
  775.     interp->result = "Bad argument to PlvSetOverallResCmd";
  776.     return TCL_ERROR;
  777.   }
  779.   int res;
  780.   if (strcmp (argv[1], "temphigh") == 0)
  781.     res = Scene::resTempHigh;
  782.   else if (strcmp (argv[1], "templow") == 0)
  783.     res = Scene::resTempLow;
  784.   else if (strcmp (argv[1], "high") == 0)
  785.     res = Scene::resHigh;
  786.   else if (strcmp (argv[1], "low") == 0)
  787.     res = Scene::resLow;
  788.   else if (strcmp (argv[1], "nexthigh") == 0)
  789.     res = Scene::resNextHigh;
  790.   else if (strcmp (argv[1], "nextlow") == 0)
  791.     res = Scene::resNextLow;
  792.   else
  793.     res = Scene::resDefault;
  795.   theScene->setMeshResolution (res);
  796.   redraw (true);
  798.   return TCL_OK;
  799. }
  802. int
  803. PlvFlattenCameraXformCmd(ClientData clientData, Tcl_Interp *interp, 
  804.  int argc, char *argv[])
  805. {
  806.   if (argc != 1) {
  807.     interp->result = "Bad argument to PlvFlattenCameraXformCmd";
  808.     return TCL_ERROR;
  809.   }
  811.   theScene->flattenCameraXform();
  812.   redraw (true);
  814.   return TCL_OK;
  815. }
  818. int
  819. PlvSpaceCarveCmd(ClientData clientData, Tcl_Interp *interp, 
  820.  int argc, char *argv[])
  821. {
  822.   // space-carve all visible scans and display the result as a mesh
  823.   if (argc < 2) {
  824.     interp->result = "Bad argument to PlvSpaceCarveCmd";
  825.     return TCL_ERROR;
  826.   }
  827.   int levels = atoi (argv[1]);
  828.   if (levels <= 0) {
  829.     interp->result = "Bad levels in PlvSpaceCarveCmd";
  830.     return TCL_ERROR;
  831.   }
  833.   // build list of visible scans
  834.   vector<RigidScan*> scans;
  835.   for (int i = 0; i < theScene->meshSets.size(); i++) {
  836.     if (theScene->meshSets[i]->getVisible())
  837.       scans.push_back (theScene->meshSets[i]->getMeshData());
  838.   }
  840.   // space-carve
  841.   vector<Pnt3> pnts;
  842.   vector<int>  tris;
  843.   CubeTree* ct = new CubeTree (theScene->worldCenter(),
  844.        theScene->worldBbox().maxDim() * 1.05);
  845.   //                           2.1 * theScene->sceneRadius());
  847.   SHOW(theScene->sceneRadius());
  849.   if (argc > 2)
  850.     ct->set_leaf_depth (atoi (argv[2]));
  852.   TIMER(carve);
  853.   ct->carve (scans, levels, pnts, tris);
  854.   TIMER_STOP(carve);
  855.   delete ct;
  857.   cout << "Polygonizer results:nt"
  858.        << tris.size()/3 << " trisnt"
  859.        << pnts.size() << " points"
  860.        << endl;
  862. #if 0  // if we don't trust the points output
  863.   for (i=0; i<pnts.size(); i++) {
  864.     if (pnts[i].norm() < 5.0) continue;
  865.     SHOW(pnts[i]);
  866.     pnts[i].set(0,0,0);
  867.   }
  868. #endif
  869. #if 0  // if we don't trust the tris output
  870.   for (i=0; i<tris.size(); i++) {
  871.     if (tris[i] >= pnts.size()) {
  872.       SHOW(tris[i]);
  873.       int base = i/3;
  874.       tris[3*base] = tris[3*base+1] = tris[3*base+2] = 0;
  875.     }
  877.     assert(tris[i]>=0);
  878.     assert(tris[i]<pnts.size());
  879.   }
  880. #endif
  883.   // now add this mesh to scene, and hide all others
  884.   RigidScan* scan = CreateScanFromGeometry (pnts, tris, "polygonize");
  885.   DisplayableMesh* dm = theScene->addMeshSet (scan);
  886.   Tcl_Eval (interp, "showAllMeshes 0");
  887.   Tcl_SetResult (interp, (char*)dm->getName(), TCL_VOLATILE);
  888.   return TCL_OK;
  889. }
  892. int
  893. PlvConstrainRotationCmd(ClientData clientData, Tcl_Interp *interp, 
  894. int argc, char *argv[])
  895. {
  896.   TbConstraint constraint = CONSTRAIN_NONE;
  898.   if (argc > 1) {
  899.     if (!strcmp (argv[1], "x"))
  900.       constraint = CONSTRAIN_X;
  901.     else if (!strcmp (argv[1], "y"))
  902.       constraint = CONSTRAIN_Y;
  903.     else if (!strcmp (argv[1], "z"))
  904.       constraint = CONSTRAIN_Z;
  905.   }
  907.   tbView->constrainRotation (constraint);
  909.   return TCL_OK;
  910. }
  913. int
  914. PlvSetManipRenderModeCmd(ClientData clientData, Tcl_Interp *interp, 
  915.  int argc, char *argv[])
  916. {
  917.   if (argc == 2) { // better be lock/unlock
  918.     if (!strcmp (argv[1], "lock")) {
  919.       s_bManipulatingLocked = true;
  920.       return TCL_OK;
  921.     } else if (!strcmp (argv[1], "unlock")) {
  922.       s_bManipulatingLocked = false;
  923.       return TCL_OK;
  924.     }
  925.   }
  927.   if (argc != 7) {
  928.     interp->result = "Bad args to PlvSetManipRenderModeCmd";
  929.     return TCL_ERROR;
  930.   }
  932.   theRenderParams->bRenderManipsPoints = atoi (argv[1]);
  933.   theRenderParams->bRenderManipsTinyPoints = atoi (argv[2]);
  934.   theRenderParams->bRenderManipsUnlit = atoi (argv[3]);
  935.   theRenderParams->bRenderManipsLores = atoi (argv[4]);
  936.   theRenderParams->bRenderManipsSkipDlist = atoi (argv[5]);
  937.   theRenderParams->iFastManipsThreshold = atoi (argv[6]);
  939.   return TCL_OK;
  940. }
  942. int
  943. PlvManualRotateCmd(ClientData clientData, Tcl_Interp *interp, 
  944.    int argc, char *argv[])
  945. {
  946.   Pnt3 axis;
  948.   if (argc < 4) {
  949.     interp->result = "Bad args to PlvManualRotateCmd";
  950.     return TCL_ERROR;
  951.   }
  953.   //  tbView->saveUndoPos(MeshData(theActiveScan));
  955.   axis[0] = 1; axis[1] = axis[2] = 0;
  956.   tbView->rotateAroundAxis(axis, atof(argv[1]) * M_PI/180.0, 
  957.    MeshData(theActiveScan));
  959.   axis[0] = 0; axis[1] = 1;
  960.   tbView->rotateAroundAxis(axis, atof(argv[2]) * M_PI/180.0, 
  961.    MeshData(theActiveScan));
  963.   axis[1] = 0; axis[2] = 1;
  965.   tbView->rotateAroundAxis(axis, atof(argv[3]) * M_PI/180.0, 
  966.    MeshData(theActiveScan));
  968.   return TCL_OK;
  969. }
  971. int
  972. PlvManualTranslateCmd(ClientData clientData, Tcl_Interp *interp, 
  973.       int argc, char *argv[])
  974. {
  975.   Pnt3 tp;
  977.   if (argc < 4) {
  978.     interp->result = "Bad args to PlvManualTranslateCmd";
  979.     return TCL_ERROR;
  980.   }
  982.   tp[0] = atof(argv[1]);
  983.   tp[1] = atof(argv[2]);
  984.   tp[2] = atof(argv[3]);
  986.   //tbView->saveUndoPos(MeshData(theActiveScan));
  987.   tbView->translateInEyeCoords(tp, MeshData(theActiveScan));
  988.   
  990.   return TCL_OK;
  991. }
  994. int
  995. PlvPickScanFromPointCmd(ClientData clientData, Tcl_Interp *interp, 
  996. int argc, char *argv[])
  997. {
  998.   if (argc < 2) {
  999.     return TCL_ERROR;
  1000.   }
  1002.   static vector<DisplayableMesh*> ptMeshMap;
  1003.   static int w;
  1004.   static int h;
  1006.   if (!strcmp (argv[1], "init")) { // ok to call more than once w/o exit
  1007.     w = Togl_Width  (toglCurrent);
  1008.     h = Togl_Height (toglCurrent);
  1010.     // build pts->mesh map
  1011.     cerr << "Building map from screen points to meshes ... " << flush;
  1012.     GetPtMeshMap (w, h, ptMeshMap);
  1013.     cerr << "done." << endl;
  1015.   } else if (!strcmp (argv[1], "exit")) {
  1017.     // free pts->mesh map
  1018.     ptMeshMap.clear();
  1020.   } else if (!strcmp (argv[1], "get")) {
  1022.     if (argc < 4)
  1023.       return TCL_ERROR;
  1025.     int x = atoi (argv[2]);
  1026.     int y = h - atoi (argv[3]) - 1;
  1028.     cmdassert (x >= 0 && x < w);
  1029.     cmdassert (y >= 0 && y < h);
  1031.     DisplayableMesh* dm = ptMeshMap[y*w + x];
  1032.     if (dm)
  1033.       interp->result = (char*)dm->getName();
  1034.     else
  1035.       interp->result = "";
  1036.   } else
  1037.     return TCL_ERROR;
  1039.   return TCL_OK;
  1040. }
  1042. int
  1043. PlvGetVisiblyRenderedScans(ClientData clientData, Tcl_Interp *interp, 
  1044. int argc, char *argv[])
  1045. {
  1047.  
  1048.   static vector<DisplayableMesh*> ptMeshMap;
  1049.    int w;
  1050.    int h;
  1051.    int startx, starty;
  1052.    int fullx, fully;
  1054.    fullx = Togl_Width  (toglCurrent);
  1055.    fully =  Togl_Height (toglCurrent);
  1056.    if (argc == 1) {
  1057.      // Check whole screen
  1058.      w = Togl_Width  (toglCurrent);
  1059.      h = Togl_Height (toglCurrent);
  1060.      startx=0;
  1061.      starty=0;
  1062.    } else if (argc == 2 && strcmp(argv[1],"selected")==0) {
  1063.      // Find Rectangle
  1064.       if (theSel.type == Selection::rect)
  1065. {
  1067.    startx = min (theSel[0].x, theSel[2].x);
  1068.    w = abs (theSel[0].x - theSel[2].x);
  1069.    starty = min (theSel[0].y, theSel[2].y);
  1070.    h = abs (theSel[0].y - theSel[2].y);
  1071. }
  1072.       else
  1073. {
  1074.   interp->result="Need to have a rectangle selected";
  1075.   return TCL_ERROR;
  1076. }
  1077.    } else if (argc == 5) {
  1078.      // Check in a x,y,w,h region
  1079.      startx = atoi(argv[1]);
  1080.      starty = atoi(argv[2]);
  1081.      w = atoi(argv[3]);
  1082.      h = atoi(argv[4]);
  1083.    } else {
  1084.      // Usage
  1085.      Tcl_SetResult(interp,"Usage: plv_getVisiblyRenderedScans [xstart ystart w h]n       plv_getVisiblyRenderedScans [selected]n",TCL_STATIC);
  1086.      return TCL_ERROR;
  1087.    }
  1089.     // build pts->mesh map
  1090.    // cerr << "Building map from screen points to meshes ... " << flush;
  1091.   GetPtMeshVector (startx,starty,w, h, fullx, fully, ptMeshMap);
  1092.   //cerr << "done." << endl;
  1093.  
  1095.   for (int i=0; i<theScene->meshSets.size(); i++) {
  1096.     DisplayableMesh* dm = ptMeshMap[i];
  1097.     if (dm) {
  1098.       Tcl_AppendResult(interp,(char*)dm->getName()," ", (char *) NULL);
  1099.     }      
  1100.   }
  1102.   ptMeshMap.clear();
  1103.   return TCL_OK;
  1104. }
  1107. int
  1108. PlvPositionCameraCmd(ClientData clientData, Tcl_Interp *interp, 
  1109.      int argc, char *argv[])
  1110. {
  1111.   Pnt3 c, o, t;
  1112.   float q[4];
  1113.   float fov;
  1114.   float oblique_x, oblique_y;
  1116. #define PNT3Contents(p) p[0],p[1],p[2]
  1117.   if (argc == 1) {
  1118.     tbView->getState (c, o, t, q, fov, oblique_x, oblique_y);
  1119.     char buf[1000];
  1120.     sprintf (buf, "%g %g %g %g %g %g %g %g %g %g %g %g %g %g %g %gn",
  1121.      PNT3Contents (c),
  1122.      PNT3Contents (o),
  1123.      PNT3Contents (t),
  1124.      q[0], q[1], q[2], q[3], fov, oblique_x, oblique_y);
  1125.     Tcl_SetResult (interp, buf, TCL_VOLATILE);
  1126.   } else if (argc == 2) {
  1127.     // Load camera from a Tsai parameters file
  1128.     CameraParams *cam = CameraParams::Read(argv[1]);
  1129.     if (!cam) {
  1130.       interp->result = "Can't read camera file";
  1131.       return TCL_ERROR;
  1132.     }
  1134.     tbView->getState (c, o, t, q, fov, oblique_x, oblique_y);
  1136.     Xform<float> xf(cam->GLmodelmatrix());
  1137.     xf.rotX(M_PI);
  1138.     xf.toQuaternion(q);
  1139.     Pnt3 origin, campos, tmp;
  1140.     xf.apply_inv(origin, campos);
  1141.     campos[0] -= o[0];  campos[1] -= o[1];  campos[2] -= o[2];
  1142.     Xform<float> rot;
  1143.     rot.fromQuaternion(q);
  1144.     rot.apply(campos, tmp);
  1145.     tmp[0] += o[0];  tmp[1] += o[1];  tmp[2] += o[2];
  1146.     tmp[0] -= c[0];  tmp[1] -= c[1];  tmp[2] -= c[2];
  1147.     t[0] = -tmp[0];  t[1] = -tmp[1];  t[2] = -tmp[2];
  1149.     float w = cam->imgwidth, h = cam->imgheight;
  1150.     float xscale = (float)theWidth / w;
  1151.     float yscale = (float)theHeight / h;
  1152.     if (xscale < yscale) {
  1153. h *= yscale / xscale;
  1154.     } else {
  1155. w *= xscale / yscale;
  1156.     }
  1157.     float halffov = 0.5 * sqrt(w*w+h*h) / cam->pixels_per_radian;
  1158.     fov = atan(halffov) * 2.0 * 180.0 / M_PI;
  1159.     oblique_x = oblique_y = 0;
  1161.     Pnt3 up (0, 1, 0);
  1162.     tbView->setup (c, o, up, theScene->sceneRadius(), fov, oblique_x, oblique_y);
  1163.     tbView->setState (t, q);
  1165.     theScene->computeBBox();
  1166.     tbView->newRotationCenter (theScene->worldCenter(), MeshData(NULL));
  1168.     delete cam;
  1169.   } else if (argc >= 15) {
  1170.     for (int i = 1; i < 4; i++)
  1171.       c[i-1] = atof (argv[i]);
  1172.     for (; i < 7; i++)
  1173.       o[i-4] = atof (argv[i]);
  1174.     for (; i < 10; i++)
  1175.       t[i-7] = atof (argv[i]);
  1176.     for (; i < 14; i++)
  1177.       q[i-10] = atof (argv[i]);
  1178.     fov = atof(argv[i++]);
  1179.     if (argc == 17) {
  1180. oblique_x = atof(argv[i++]);
  1181. oblique_y = atof(argv[i++]);
  1182.     } else {
  1183. oblique_x = oblique_y = 0;
  1184.     }
  1185.     Pnt3 up (0, 1, 0);
  1186.     tbView->setup (c, o, up, theScene->sceneRadius(), fov, oblique_x, oblique_y);
  1187.     tbView->setState (t, q);
  1188.     theScene->computeBBox (Scene::sync);
  1189.     redraw (true);
  1190.   } else {
  1191.     interp->result = "Bad # args";
  1192.     return TCL_ERROR;
  1193.   }
  1195.   return TCL_OK;
  1196. }
  1199. int
  1200. PlvSortScanListCmd (ClientData clientData, Tcl_Interp *interp, 
  1201.     int argc, char *argv[])
  1202. {
  1203.   vector<DisplayableMesh*> sortedList;
  1204.   vector<Scene::sortCriteria> criteria;
  1206.   Scene::sortCriteria sc;
  1207.   bool bDictionary = true;
  1208.   bool bListInvisible = true;
  1210.   criteria.reserve (argc - 1);
  1211.   for (int i = 1; i < argc; i++) {
  1212.     sc = Scene::none;
  1214.     if (!strcmp (argv[i], "Name"))
  1215.       sc = Scene::name;
  1216.     else if (!strcmp (argv[i], "File date"))
  1217.       sc = Scene::date;
  1218.     else if (!strcmp (argv[i], "Loadedness"))
  1219.       sc = Scene::loaded;
  1220.     else if (!strcmp (argv[i], "Visibility"))
  1221.       sc = Scene::visibility;
  1222.     else if (!strcmp (argv[i], "PolygonCount"))
  1223.       sc = Scene::polycount;
  1224.     else if (!strcmp (argv[i], "ascii"))
  1225.       bDictionary = false;
  1226.     else if (!strcmp (argv[i], "dictionary"))
  1227.       bDictionary = true;
  1228.     else if (!strcmp (argv[i], "onlyvisible"))
  1229.       bListInvisible = false;
  1230.     else
  1231.       cerr << "Warning: unrecognized sort option " << argv[i] << endl;
  1233.     if (sc != Scene::none)
  1234.       criteria.push_back (sc);
  1235.   }
  1237.   theScene->sortSceneMeshes (sortedList, criteria,
  1238.      bDictionary, bListInvisible);
  1240.   int size = 0;
  1241.   for (i = 0; i < sortedList.size(); i++) {
  1242.     size += strlen (sortedList[i]->getName()) + 1;
  1243.   }
  1245.   if (size == 0) {
  1246.     Tcl_SetResult (interp, "", TCL_STATIC);
  1247.   } else {
  1248.     char* list = (char*)malloc (size);
  1249.     char* end = list;
  1250.     for (i = 0; i < sortedList.size(); i++) {
  1251.       strcpy (end, sortedList[i]->getName());
  1252.       end += strlen (end);
  1253.       *end++ = ' ';
  1254.     }
  1255.     end[-1] = 0;  // then terminate the whole shebang
  1256.     
  1257.     Tcl_SetResult (interp, list, (Tcl_FreeProc*)free);
  1258.   }
  1260.   return TCL_OK;
  1261. }
  1264. int
  1265. PlvZoomToRectCmd(ClientData clientData, Tcl_Interp *interp, 
  1266.  int argc, char *argv[])
  1267. {
  1268.   int x1,x2,y1,y2;
  1270.   if (argc==5) {
  1271.     // We passed in the zoom rect values
  1272.     x1 = atoi(argv[1]);
  1273.     int ty1 = theHeight - atoi(argv[2]);
  1274.     x2 = atoi(argv[3]);
  1275.     int ty2 = theHeight - atoi(argv[4]);
  1276.     y1=MIN(ty1,ty2);
  1277.     y2=MAX(ty1,ty2);
  1278.   }
  1279.   else {
  1280.     // We want to get the values from the selection
  1281.     if (theSel.type != Selection::rect) {
  1282.       return TCL_ERROR;
  1283.     }
  1284.     // points 0 and 2 are the corners
  1285.     x1 = MIN (theSel[0].x, theSel[2].x);
  1286.     x2 = MAX (theSel[0].x, theSel[2].x);
  1287.     y1 = MIN (theSel[0].y, theSel[2].y);
  1288.     y2 = MAX (theSel[0].y, theSel[2].y);
  1289.   }
  1291.   printf("zoom %d %d : %d %dn",x1,y1,x2,y2);
  1293.   // need to set translation scale before calling zoomToRect
  1294.   // BUGBUG this just looks for data near the center of selection rect;
  1295.   // normally people will probably use it this way, but we could actually
  1296.   // unproject everything in the selection, and average it.
  1297. resetTranslationScale ((x1 + x2) / 2, (y1 + y2) / 2);
  1298.   tbView->zoomToRect (x1, y1, x2, y2);
  1300.   // attempt to update selection rectangle...
  1301.   int rectW = x2 - x1;
  1302.   int rectH = y2 - y1;
  1303.   float zoom = MIN ((float)theWidth / rectW, (float)theHeight / rectH);
  1305.   x1 = (theWidth / 2) - (rectW * zoom / 2);
  1306.   x2 = (theWidth / 2) + (rectW * zoom / 2);
  1307.   y1 = (theHeight / 2) - (rectH * zoom / 2);
  1308.   y2 = (theHeight / 2) + (rectH * zoom / 2);
  1309. // update selection info only if we zoomed to a rect
  1310. if (argc!=5) {
  1311. theSel[0].x = x1; theSel[0].y = y1;
  1312. theSel[2].x = x2; theSel[2].y = y2;
  1313. theSel[1].x = x1; theSel[1].y = y2;
  1314. theSel[3].x = x2; theSel[3].y = y1;
  1315. }
  1317.   Togl_PostOverlayRedisplay (toglCurrent);
  1318.   redraw (true);
  1320.   return TCL_OK;
  1321. }
  1324. bool
  1325. isManipulatingRender (void)
  1326. {
  1327.   // return true if we render any differently (points, lores, unlit, etc.)
  1328.   // because the rendering is being trackballed
  1330.   if (s_bManipulatingLocked)
  1331.     return true;
  1333.   if (tbView->isManipulating())
  1334.       return manipulatedRenderDifferent();
  1336.   return false;
  1337. }
  1340. bool
  1341. manipulatedRenderDifferent (void)
  1342. {
  1343.   if (theRenderParams->iFastManipsThreshold < 0)
  1344.     return false;
  1346.   if (theRenderParams->bRenderManipsPoints
  1347.       || theRenderParams->bRenderManipsUnlit
  1348.       || theRenderParams->bRenderManipsLores) {
  1350.     char* pszNum = Tcl_GetVar (Togl_Interp (toglCurrent),
  1351.        "visPolyCount",
  1352.        TCL_GLOBAL_ONLY);
  1353.     int nPolys = atoi (pszNum);
  1354.     return (nPolys > theRenderParams->iFastManipsThreshold);
  1355.   }
  1357.   return false;
  1358. }
  1361. static Tk_TimerToken s_autoResetTimerToken = 0;
  1364. static void
  1365. autoResetProc (ClientData clientData = NULL)
  1366. {
  1367.   theScene->centerCamera();
  1368.   theRenderParams->lightPosition[0] = 0.0;
  1369.   theRenderParams->lightPosition[1] = 0.0;
  1370.   theRenderParams->lightPosition[2] = 1.0;
  1371.   redraw (true);
  1373.   if (!s_autoResetScript.empty()) {
  1374.     Tcl_Eval (g_tclInterp, (char*)s_autoResetScript.c_str());
  1375.   }
  1377.   rescheduleAutoReset();
  1378. }
  1381. static void
  1382. rescheduleAutoReset (void)
  1383. {
  1384.   if (s_autoResetTimerToken) {
  1385.     Tk_DeleteTimerHandler (s_autoResetTimerToken);
  1386.     s_autoResetTimerToken = 0;
  1387.   }
  1389.   if (s_iAutoResetTime) {
  1390.     s_autoResetTimerToken =
  1391.       Tk_CreateTimerHandler (s_iAutoResetTime, autoResetProc,
  1392.      NULL);
  1393.   }
  1394. }
  1397. int
  1398. PlvForceKeepOnscreenCmd(ClientData clientData, Tcl_Interp *interp, 
  1399. int argc, char *argv[])
  1400. {
  1401.   if (argc < 2) {
  1402.     interp->result = "Wrong # args";
  1403.     return TCL_ERROR;
  1404.   }
  1406.   s_bForceOnscreen = atoi (argv[1]);
  1407.   if (s_bForceOnscreen && !passesOnscreenTest()) {
  1408.     s_bForceOnscreen = false;
  1409.     interp->result = "Please GET the model onscreen "
  1410.       "before trying to KEEP it there";
  1411.     return TCL_ERROR;
  1412.   }
  1414.   if (s_bForceOnscreen && argc > 2) {
  1415.     // 2nd arg is time until auto-reset-viewer.
  1417.     if (argc > 3) {
  1418.       // 3nd arg is script to run on auto-reset.
  1419.       s_autoResetScript = crope (argv[3]);
  1420.     }
  1422.     // force message to pop up right away
  1423.     s_iAutoResetTime = 50;
  1424.     rescheduleAutoReset();
  1425.     s_iAutoResetTime = 1000 * atoi (argv[2]);
  1427.   } else {
  1428.     s_iAutoResetTime = 0;
  1429.     s_autoResetScript = crope();
  1430.     rescheduleAutoReset();
  1431.   }
  1433.   return TCL_OK;
  1434. }
  1437. void 
  1438. SpinTrackballs (ClientData clientData)
  1439. {
  1440.   if (tbView->isSpinning()) {
  1442.     Xform<float> before;
  1443.     if (s_bForceOnscreen)
  1444.       before = tbView->getUndoXform();
  1446.     redraw (true);
  1448.     if (s_bForceOnscreen && !passesOnscreenTest()) {
  1449.       cerr << "killing spin before it goes offscreen." << endl;
  1450.       tbView->stop();
  1451.       tbView->setUndoXform (before);
  1452.     }
  1453.   }
  1455.   Tk_CreateTimerHandler (30, SpinTrackballs, clientData);
  1456. }