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

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

3D图形编程

开发平台：

Visual C++

plvClipBoxCmds.cc：源码内容
  1. #include <iostream.h>
  2. #include <fstream.h>
  3. #include <string>
  4. #ifdef WIN32
  5. # include "winGLdecs.h"
  6. #endif
  7. #include <GL/gl.h>
  8. #include <GL/glu.h>
  10. #include <tcl.h>
  11. #include "TclCmdUtils.h"
  13. #include "togl.h"
  14. #include "plvGlobals.h"
  15. #include "plvClipBoxCmds.h"
  16. #include "plvMeshCmds.h"
  17. #include "plvDrawCmds.h"
  18. #include "plvScene.h"
  19. #include "plvDraw.h"
  20. #include "DisplayMesh.h"
  21. #include "RigidScan.h"
  22. #include "VertexFilter.h"
  23. #include "plvAnalyze.h"
  24. #include "Progress.h"
  25. #include "GroupScan.h"
  26. #include "GenericScan.h"
  27. #include "RangeGrid.h"
  30. // public globals
  31. Selection theSel;
  33. // module globals
  34. static const int kHandleSize = 3;
  35. static bool bManipulatingSel = false;
  36. static bool bMoveEntire = false;
  37. static bool bChangeExisting = false;
  38. static int iChangeExisting = 0;
  39. static int iDelete = -1;
  40. Selection::Pt ptRelativeTo;
  43. static GLint olColor = -1;
  44. static GLint handleColor = -1;
  45. static GLint handleSelColor = -1;
  48. Selection::Selection (void)
  49. {
  50.   clear();
  51. }
  54. void Selection::clear (void)
  55. {
  56.   type = none;
  57.   pts.clear();
  58. }
  61. static void drawHandle (Selection::Pt pt, bool bSelected = false);
  62. static bool ptOnHandle (Selection::Pt pt, Selection::Pt handle);
  63. static bool ptOnLine (Selection::Pt pt,
  64.       Selection::Pt start, Selection::Pt end);
  65. static int findSelectionHandle (Selection::Pt pt, const Selection& sel);
  66. static int findSelectionLine (Selection::Pt pt, const Selection& sel);
  68. // static DisplayableMesh *
  69. // ClipGroupHelper (GroupScan *groupFrom, const VertexFilter &filter);
  70. static DisplayableMesh* Renamer (DisplayableMesh *mesh);
  72. int
  73. PlvClipToSelectionCmd(ClientData clientData, Tcl_Interp *interp, 
  74.       int argc, char *argv[])
  75. {
  76.   if (argc < 2) {
  77.     interp->result = "Bad args to PlvClipToSelectionCmd";
  78.     return TCL_ERROR;
  79.   }
  81.   DisplayableMesh* meshDisp = FindMeshDisplayInfo (argv[1]);
  83.   bool bClipInvisible = false;
  84.   bool bClipMulti = false;
  85.   bool bKeepInside = true;
  86.   bool bClipInPlace = false;
  87.   for (int i = 2; i < argc; i++) {
  88.     if (!strcmp (argv[i], "inside"))
  89.       bKeepInside = true;
  90.     else if (!strcmp (argv[i], "outside"))
  91.       bKeepInside = false;
  92.     else if (!strcmp (argv[i], "inplace"))
  93.       bClipInPlace = true;
  94.     else if (!strcmp (argv[i], "newmesh"))
  95.       bClipInPlace = false;
  96.     else if (!strcmp (argv[i], "sel"))
  97.       bClipMulti = false;
  98.     else if (!strcmp (argv[i], "vis")) {
  99.       bClipMulti = true; bClipInvisible = false;
  100.     } else if (!strcmp (argv[i], "all")) {
  101.       bClipMulti = bClipInvisible = true;
  102.     }
  103.   }
  105.   // build list of scans to clip
  106.   vector<DisplayableMesh*> clippees;
  107.   if (bClipMulti) {
  108.     // push all meshes with sufficient visibility
  109.     for (DisplayableMesh** pdm = theScene->meshSets.begin();
  110.  pdm != theScene->meshSets.end();
  111.  pdm++) {
  112.       if (bClipInvisible || (*pdm)->getVisible())
  113. clippees.push_back (*pdm);
  114.     }
  115.   } else {
  116.     // just use the given source mesh
  117.     clippees.push_back (meshDisp);
  118.   }
  120.   // now iterate and clip each clippee
  121.   bool bSuccess = true;
  122.   char* error = NULL;
  123.   Progress* progress = new Progress (clippees.size(), "Clipping scans", true);
  124.   cout << "Clipping " << clippees.size() << " scans..." << endl;
  125.   for (DisplayableMesh** clippee = clippees.begin();
  126.        clippee != clippees.end();
  127.        clippee++) {
  129.     DisplayableMesh* oldDisp = *clippee;
  130.     if (!oldDisp) {
  131.       cerr << "Attempt to clip nonexistent mesh!" << endl;
  132.       bSuccess = false;
  133.       continue;
  134.     }
  135.     RigidScan* meshFrom = oldDisp->getMeshData();
  137.     VertexFilter* filter = filterFromSelection (meshFrom, theSel);
  138.     if (!filter) {
  139.       error = "First you must select an area";
  140.       bSuccess = false;
  141.       break;
  142.     }
  143.     
  144.     if (!bKeepInside) {
  145.       filter->invert();
  146.     }
  147.     
  148.     if (bClipInPlace) {
  149.       // inplace mode -- no creating new mesh, just munge the existing one
  150.       // Do it by saving the mesh's name and then making a
  151.       // filtered copy of it.  Then delete the old one, rename
  152.       // the new one and add it.
  153.       cerr << "attempting a clip of mesh: " << meshFrom->get_name() << endl;
  154.       RigidScan* meshTo = meshFrom->filtered_copy(*filter);
  155.       GroupScan *groupResult = dynamic_cast<GroupScan*>(meshTo);
  156.       if (meshTo) {
  158. if (meshTo->num_resolutions() > 0) {
  160.   char *name = strdup(meshFrom->get_name().c_str());
  161.   // get the old theMesh
  162.   char *theMeshOld = GetTclGlobal("theMesh");
  163.   
  164.   char tclCmdBuff[256];
  165.   sprintf(tclCmdBuff, "confirmDeleteMesh %s", oldDisp->getName());
  166.   if (Tcl_Eval (interp, tclCmdBuff) != TCL_OK)
  167.     cerr << "confirmDelete failed " << endl;
  168.   
  169.   
  170.   DisplayableMesh* newDisp;
  171.   if(!groupResult) {
  172.     meshTo->set_name(name);
  173.     newDisp = theScene->addMeshSet (meshTo, false);
  174.   } else {     
  175.     // clipping a group in place means that we need to 
  176.     // rename the group and all its members using 
  177.     // the Renamer routine.
  178.        
  179.     newDisp = FindMeshDisplayInfo(meshTo);
  180.   
  181.     newDisp = Renamer(newDisp);
  182.   }
  183.   
  184.   sprintf(tclCmdBuff, "clipInplaceHelper %s %s", newDisp->getName(), 
  185.   theMeshOld);
  186.   Tcl_Eval (interp, tclCmdBuff);
  187.   
  188.   free(name);
  189.   
  190. } else {
  191.   // scan supports clipping, but had no data
  192.      
  193.   Tcl_VarEval (interp, "changeVis ", oldDisp->getName(), " 0", NULL);
  194. }
  195.       } else {
  196. // scan doesn't know how to clip
  197. cerr << "Scan " << meshTo->get_name()
  198.      << " failed filtered_inplace" << endl;
  199. bSuccess = false;
  200.       }
  201.       
  202.     } else {
  203.       // newmesh mode... makes a new mesh and adds it to Mesh Controls
  204.       // filtered_copy will return NULL if not supported; will return
  205.       // valid pointer to scan with no resolutions if the clip excludes
  206.       // all data.
  207.       RigidScan* meshTo = meshFrom->filtered_copy(*filter);
  208.       
  209.       if (meshTo) {
  210. if (meshTo->num_resolutions() > 0) {
  211.   // set name, same as old with clip appended before extension
  212.   GroupScan *group = dynamic_cast<GroupScan*>(meshTo);
  213.   if (!group) {
  214.     crope name = meshFrom->get_basename()
  215.       + "Clip." + meshFrom->get_nameending();
  216.     meshTo->set_name(name);
  217.     
  218.     DisplayableMesh* newDisp = theScene->addMeshSet (meshTo, false);
  219.     Tcl_VarEval (interp, "clipMeshCreateHelper ",
  220.  oldDisp->getName(), " ", newDisp->getName(), NULL);
  221.   } else { 
  222.     // since it is a group, it has already been named + added to the scene
  223.     Tcl_VarEval (interp, "clipMeshCreateHelper ",
  224.  oldDisp->getName(), " ", 
  225.  FindMeshDisplayInfo(meshTo)->getName(), NULL);
  226.   }
  227. } else {
  228.   // scan supports clipping, but had no data
  229.   Tcl_VarEval (interp, "changeVis ", oldDisp->getName(), " 0", NULL);
  230. }
  231.       } else {
  232. // scan doesn't know how to clip
  233. cerr << "Scan " << meshFrom->get_name()
  234.      << " failed filtered_copy" << endl;
  235. bSuccess = false;
  236.       }
  237.     }
  239.     delete filter;
  241.     // update progress; check for cancel
  242.     if (!progress->updateInc()) {
  243.       cerr << "Clip operation cancelled (" 
  244.    << (clippee - clippees.begin() + 1)
  245.    << " down; " << (clippees.end() - clippee - 1)
  246.    << " to go)" << endl;
  247.       break;
  248.     }
  249.   }
  251.   delete progress;
  253.   theScene->computeBBox();
  254.   if (bSuccess)
  255.     return TCL_OK;
  257.   if (error)
  258.     interp->result = error;
  259.   else
  260.     interp->result = "At least one scan could not be clipped... "
  261.       "Perhaps it does not support filtered_copy or filter_inplace?";
  263.   return TCL_ERROR;
  264. }
  266. // This helper routine looks for the last instance
  267. // of "Clip" in haystack.
  268. // we are guaranteed that there is at least one "Clip"
  269. // in the string haystack since we just created
  270. // it as a filtered_copy.
  272. static char*
  273. my_clip_strrstr (char** haystack) 
  274. {
  275.   char *str = *haystack;
  276.   char *oldstr = str;
  278.   //cerr << "str initted to " << str << endl;
  279.   while ((str = strstr(oldstr+1, "Clip")) != NULL) {
  280.     oldstr = str;
  281.     //cerr << "Oldstr is " << oldstr << endl;
  282.   }
  283.   return oldstr;
  284. }
  286. // Clipping in place for groups works by creating a filtered
  287. // copy of the group and then renaming each member recursively.
  288. // We must delete it from the hashtable in theScene using its
  289. // old name and then add it back with the new name.
  290. // Also, theScene->meshSets (a vector) also maintains a list of
  291. // displayable meshes - but by renaming the displayable
  292. // mesh, we are ensuring that meshSets is in sync with the
  293. // hashtable which is crucial.
  294. // we have to rename both the displayable mesh and the rigid scan
  295. // The renaming takes place by finding the last occurrence of
  296. // "Clip" in the name and getting rid of it, so as to disguise
  297. // the clip as the original mesh.
  298. // (Due to complications with the hashtable/meshSets data
  299. // structures, the renaming must take place after the 
  300. // entire group has been created, not while it is being
  301. // built from its constituents).
  302. static DisplayableMesh * 
  303. Renamer (DisplayableMesh *mesh) {
  304.   vector<DisplayableMesh*>children;
  305.   vector<DisplayableMesh*>vec;
  306.   RigidScan *scan = mesh->getMeshData();
  308.   char oldname [256];
  309.   sprintf(oldname, "%s",  mesh->getMeshData()->get_basename().c_str());
  310.   char *tmp = oldname; // tmp is needed to convince compiler
  311.   *(my_clip_strrstr(&tmp)) = ''; // removes "Clip" from end of string
  313.   //cerr << "oldname is now " << oldname << endl;
  314.   crope newname;
  315.   newname = crope(oldname) + "." + mesh->getMeshData()->get_nameending();
  316.   char newbuf [PATH_MAX];
  317.   sprintf (newbuf, "%s", newname.c_str());
  319.   GroupScan *g = dynamic_cast<GroupScan*>(scan);
  320.   if (g) {
  321.     if (g->get_children_for_display(children)) {
  322.       ungroupScans(mesh);    
  323.       for (DisplayableMesh** it = children.begin(); it < children.end(); it++)
  324. vec.push_back(Renamer (*it)); // rename the descendants of the group first
  325.       mesh = groupScans(vec, newbuf, true);
  326.       return mesh;
  327.     }
  328.     return NULL; //ok as long as group has to have children
  329.   } else {
  330.     // rename rigid scan
  331.     mesh->getMeshData()->set_name(newname);
  332.     
  333.     // rename displayable mesh
  334.     char buf[PATH_MAX];
  335.     sprintf(buf, "%s",  mesh->getName());
  336.     char *tmp2 = buf;
  337.     *(my_clip_strrstr(&tmp2)) = ''; // removes "Clip" from end of string
  338.     MeshSetHashDelete(strdup(mesh->getName()));
  339.     mesh->setName(buf);
  340.     AddMeshSetToHash(mesh);
  341.     
  342.     return mesh;
  343.   }
  344. }
  346. // static DisplayableMesh *
  347. // ClipGroupHelper (GroupScan *groupFrom, const VertexFilter &filter)
  348. // {
  349. //   vector<DisplayableMesh*>newkids;
  350. //   char *oldGroupName = strdup(groupFrom->get_name().c_str());
  351. //   cerr << "Old group name " << oldGroupName << endl;
  352. //   VertexFilter *childfilter;
  353. //   DisplayableMesh *groupMeshTo, *clippedGroup;
  354.   
  355. //   vector<DisplayableMesh*>kids = 
  356. //     ungroupScans(FindMeshDisplayInfo(oldGroupName));
  357. //   for (DisplayableMesh** it = kids.begin(); it < kids.end(); it++) {
  358. //     RigidScan *from = (*it)->getMeshData();
  359. //     assert(from);
  360. //     GroupScan* g = dynamic_cast<GroupScan*>(from);
  361. //     childfilter = filter.transformedClone((float*)from->getXform());
  362. //     if (g) {
  363. //       clippedGroup = ClipGroupHelper (g, *childfilter);
  364. //       newkids.push_back(clippedGroup);
  365. //     } else {      
  366. //       RigidScan *to = from->filtered_copy(*childfilter, true);
  367. //       char *name = strdup(from->get_name().c_str());
  368. //       DisplayableMesh *disp = FindMeshDisplayInfo((*it)->getName());
  369. //       theScene->deleteMeshSet(disp);
  370. //       if (to) {
  371. //  if (to->num_resolutions() > 0) {
  372.   
  373. //    //   char *theMeshOld = "back1"; //GetTclGlobal("theMesh");
  374. //    to->set_name(name);
  375.   
  376. //    DisplayableMesh *newkid = theScene->addMeshSet(to,false);
  377.   
  378. //    newkids.push_back(newkid);
  379. //  }
  380. //       }
  381. //     }
  382. //   }
  383. //   groupMeshTo = groupScans (newkids, oldGroupName, true);
  384. //   return groupMeshTo;
  385. // }
  387. /* This function is called from interactors.tcl when the user
  388.    selects the Print Voxel Info command from the right-click
  389.    menu after specifying a rectangular box region 
  390.    - for display voxel feature */
  391. int PlvPrintVoxelsCmd(ClientData clientData, Tcl_Interp *interp, 
  392.      int argc, char *argv[])
  393. {
  394.   printf("Getting voxel information...n");
  396.   if (argc != 2) {
  397.     interp->result = "Bad args to PlvPrintVoxelsCmd";
  398.     return TCL_ERROR;
  399.   }
  401.   DisplayableMesh* meshDisp = FindMeshDisplayInfo (argv[1]);
  402.   if (meshDisp == NULL) {
  403.     interp->result = "Attempting to print voxels for non-existant mesh";
  404.     return (TCL_ERROR);
  405.   }
  407.   RigidScan* meshFrom = meshDisp->getMeshData();
  408.   if (meshFrom == NULL) {
  409.     interp->result = "PlvPrintVoxelsCmd: We don't have a mesh";
  410.     return (TCL_ERROR);
  411.   }
  412.   //GenericScan* gscanFrom = (GenericScan *) meshFrom;
  413.   GenericScan *gscanFrom = dynamic_cast<GenericScan*> (meshFrom);
  414.   if (!gscanFrom) {
  415.     interp->result = "Mesh is not a ply file";
  416.     return (TCL_ERROR);
  417.   }
  419.   VertexFilter* filter = filterFromSelection (gscanFrom, theSel);
  420.   // VertexFilter* filter = filterFromSelection (meshFrom, theSel);
  421.   if (!filter) {
  422.     interp->result = "First you must select an area";
  423.     return (TCL_ERROR);
  424.   }
  425.   RigidScan* meshTo = gscanFrom->filtered_copy(*filter);
  426.   //RigidScan* meshTo = meshFrom->filtered_copy(*filter);
  427.   GenericScan* gscanTo = (GenericScan *) meshTo;
  428.   if (meshTo->num_vertices() == 0) {
  429.     interp->result = "No vertices selected";
  430.     return (TCL_ERROR);
  431.   } else gscanTo->PrintVoxelInfo();
  433.   return (TCL_OK);
  434. }
  436. int
  437. PlvClearSelectionCmd(ClientData clientData, Tcl_Interp *interp, 
  438.      int argc, char *argv[])
  439. {
  440.   struct Togl* togl = toglHash.FindTogl (argv[1]);
  441.   assert (togl);
  443.   theSel.clear();
  444.   Togl_PostOverlayRedisplay (togl);
  445.   
  446.   return TCL_OK;
  447. }
  451. int
  452. PlvDrawLineSelectionCmd(ClientData clientData, Tcl_Interp *interp, 
  453. int argc, char *argv[])
  454. {
  455.   // args are %x %y start
  456.   if (argc < 4)
  457.     return TCL_ERROR;
  459.   Selection::Pt pt;
  460.   pt.x = atoi(argv[1]);
  461.   pt.y = theHeight - atoi(argv[2]);
  463.   if (!strcmp (argv[3], "start")) {
  464.     bChangeExisting = false;
  465.     bManipulatingSel = true;
  466.     bMoveEntire = false;
  468.     if (theSel.type == Selection::line) {
  469.       // attempt to find existing line
  470.       int iHandle = findSelectionHandle (pt, theSel);
  471.       if (iHandle >= 0) {
  472. // reuse pt that's not iHandle
  473. bChangeExisting = true;
  474. if (iHandle == 0)
  475.   theSel[0] = theSel[1];
  476. theSel[1] = pt;
  477.       } else if (ptOnLine (pt, theSel[0], theSel[1])) {
  478. bChangeExisting = true;
  479. bMoveEntire = true;
  480. ptRelativeTo = pt;
  481.       }
  482.     }
  483.     
  484.     if (!bChangeExisting)
  485.     {
  486.       // start new line
  487.       theSel.clear();
  488.       theSel.type = Selection::line;
  489.       theSel.pts.push_back (pt);
  490.       theSel.pts.push_back (pt);
  491.       ptRelativeTo.x = ptRelativeTo.y = 0;
  492.     }
  493.   } else if (!strcmp (argv[3], "stop")) {
  494.     bManipulatingSel = false;
  495.     if (theSel[0].x == theSel[1].x && theSel[0].y == theSel[1].y)
  496.       Tcl_Eval (Togl_Interp (toglCurrent), "clearSelection");
  497.   } else if (!strcmp (argv[3], "move")) {
  498.     if (theSel.type != Selection::line) {
  499.       interp->result = "Internal selection tracking error";
  500.       return TCL_ERROR;
  501.     }
  503.     if (bMoveEntire) {
  504.       theSel[0].x += pt.x - ptRelativeTo.x;
  505.       theSel[0].y += pt.y - ptRelativeTo.y;
  506.       theSel[1].x += pt.x - ptRelativeTo.x;
  507.       theSel[1].y += pt.y - ptRelativeTo.y;
  508.       ptRelativeTo = pt;
  509.     } else {
  510.       if (argc > 4 && !strcmp (argv[4], "constrain")) {
  511. int dx = abs (pt.x - theSel[0].x);
  512. int dy = abs (pt.y - theSel[0].y);
  514. if (dx > 2 * dy)   // strongly x-oriented -- x only
  515.   pt.y = theSel[0].y;
  516. else if (dy > 2 * dx) // strongly y-oriented -- y only
  517.   pt.x = theSel[0].x;
  518. else if (dx > dy)  // x dominates; 45 degree controlled by x
  519.   pt.y = theSel[0].y + dx * (pt.y > theSel[0].y ? 1 : -1);
  520. else  // 45 degree controlled by y
  521.   pt.x = theSel[0].x + dy * (pt.x > theSel[0].x ? 1 : -1);
  522.       }
  524.     theSel[1] = pt;
  525.     }
  526.   }
  528. #ifndef no_overlay_support
  529.   Togl_PostOverlayRedisplay (toglCurrent);
  530. #else
  531.   drawOverlayAndSwap(toglCurrent);
  532. #endif
  534.   return TCL_OK;
  535. }
  538. int
  539. PlvDrawShapeSelectionCmd(ClientData clientData, Tcl_Interp *interp, 
  540.  int argc, char *argv[])
  541. {
  542.   // args are %x %y start
  543.   if (argc < 4)
  544.     return TCL_ERROR;
  546.   Selection::Pt pt;
  547.   pt.x = atoi(argv[1]);
  548.   pt.y = theHeight - atoi(argv[2]);
  550.   if (!strcmp (argv[3], "start")) {
  551.     bChangeExisting = false;
  552.     bManipulatingSel = true;
  553.     bMoveEntire = false;
  555.     if (theSel.type == Selection::shape) {
  556.       // attempt to find existing polyline
  557.       int iHandle = findSelectionHandle (pt, theSel);
  558.       if (iHandle >= 0) {
  559. // reuse pt i
  560. bChangeExisting = true;
  561. iChangeExisting = iHandle;
  562.       } else {
  563. // not on a handle; look for a line
  564. if (findSelectionLine (pt, theSel) >= 0) {
  565.   bChangeExisting = true;
  566.   iChangeExisting = -1;
  567.   bMoveEntire = true;
  568.   ptRelativeTo = pt;
  569. }
  570.       }
  571.     }
  572.     
  573.     if (bChangeExisting) {
  574.       if (iChangeExisting >= 0)
  575. theSel[iChangeExisting] = pt;
  576.     } else {
  577.       if (theSel.type != Selection::shape) {
  578. // start new polyline
  579. theSel.clear();
  580. theSel.type = Selection::shape;
  581. theSel.pts.push_back (pt);
  582.       }
  584.       bChangeExisting = true;
  585.       iChangeExisting = theSel.pts.size();
  586.       theSel.pts.push_back (pt);
  587.       ptRelativeTo.x = ptRelativeTo.y = 0;
  588.     }
  589.   } else if (!strcmp (argv[3], "stop")) {
  590.     bManipulatingSel = false;
  591.   } else if (!strcmp (argv[3], "move")) {
  592.     if (theSel.type != Selection::shape) {
  593.       interp->result = "Internal selection tracking error";
  594.       return TCL_ERROR;
  595.     }
  596.     iDelete = -1;
  598.     if (bMoveEntire) {
  599.       for (int i = 0; i < theSel.pts.size(); i++) {
  600. theSel[i].x += pt.x - ptRelativeTo.x;
  601. theSel[i].y += pt.y - ptRelativeTo.y;
  602.       }
  603.       ptRelativeTo = pt;
  604.     } else if (bChangeExisting) {
  605.       theSel.pts[iChangeExisting] = pt;
  606.     }
  607.   } else if (!strcmp (argv[3], "modify")) {
  608.     // attempt to find existing polyline handle
  609.     if (theSel.type != Selection::shape) {
  610.       interp->result = "Internal selection tracking error";
  611.       return TCL_ERROR;
  612.     }
  613.     int nPts = theSel.pts.size();
  614.     bMoveEntire = false;
  615.     bChangeExisting = false;
  617.     // look for a point -- if found, start dragging it
  618.     int iHandle = findSelectionHandle (pt, theSel);
  619.     if (iHandle >= 0) {
  620.       bChangeExisting = true;
  621.       iChangeExisting = iDelete = iHandle;
  622.     } else {
  623.     // not on a point; look for a line to add a point
  624.       int iLine = findSelectionLine (pt, theSel);
  625.       if (iLine >= 0) {
  626. // insert new point between iLine and iLine+1
  627. iChangeExisting = iLine + 1;
  628. bChangeExisting = true;
  629. theSel.pts.insert (&theSel[iChangeExisting], pt);
  630.       }
  631.     }
  632.   } else if (!strcmp (argv[3], "remove")) {
  633.     // if this was a click and not a drag, remove selected pt
  634.     if (iDelete >= 0 && ptOnHandle (pt, theSel[iDelete])) {
  635.       theSel.pts.erase (&theSel[iDelete]);
  636.     }    
  637.   }
  638.  
  639. #ifndef no_overlay_support
  640.   Togl_PostOverlayRedisplay (toglCurrent);
  641. #else
  642.   drawOverlayAndSwap(toglCurrent); 
  643. #endif
  645.   return TCL_OK;
  646. }
  649. int
  650. PlvDrawBoxSelectionCmd(ClientData clientData, Tcl_Interp *interp, 
  651.        int argc, char *argv[])
  652. {
  653.   if (argc < 5)
  654.     return TCL_ERROR;
  656.   Selection::Pt pt;
  657.   pt.x = atoi(argv[2]);
  658.   pt.y = theHeight - atoi(argv[3]);
  659.   
  660.   struct Togl* togl = toglHash.FindTogl (argv[1]);
  661.   assert (togl);
  663.   // rect is stored as 4 points, corners, so that area selection
  664.   // iterators actually work with it
  665.   
  666.   if (argc > 4 && !strcmp (argv[4], "start")) {
  667.     bChangeExisting = false;
  668.     bManipulatingSel = true;
  669.     bMoveEntire = false;
  671.     // attempt to move existing points
  672.     if (theSel.type == Selection::rect) {
  673.       int iHandle = findSelectionHandle (pt, theSel);
  674.       if (iHandle >= 0) {
  675. // reuse pt iHandle
  676. bChangeExisting = true;
  677. theSel[0] = theSel[(iHandle+2)%4];
  678. theSel[2] = pt;
  679. theSel[1].x = theSel[2].x; theSel[1].y = theSel[0].y;
  680. theSel[3].x = theSel[0].x; theSel[3].y = theSel[2].y;
  681.       } else {
  682. if (findSelectionLine (pt, theSel) >= 0) {
  683.   bChangeExisting = true;
  684.   bMoveEntire = true;
  685.   ptRelativeTo = pt;
  686. }
  687.       }
  688.     }
  689.     
  690.     if (!bChangeExisting) {
  691.       theSel.clear();
  692.       theSel.type = Selection::rect;
  693.       theSel.pts.push_back (pt);
  694.       theSel.pts.push_back (pt);
  695.       theSel.pts.push_back (pt);
  696.       theSel.pts.push_back (pt);
  697.     }
  699.     return TCL_OK;
  700.   } else if (!strcmp (argv[4], "stop")) {
  701.     bManipulatingSel = false;
  702.     if (theSel[0].x == theSel[2].x && theSel[0].y == theSel[2].y)
  703.       Tcl_Eval (Togl_Interp (togl), "clearSelection");
  704.   } else {
  705.     if (theSel.type != Selection::rect) {
  706.       interp->result = "Internal selection tracking error";
  707.       return TCL_ERROR;
  708.     }
  710.     if (bMoveEntire) {
  711.       for (int i = 0; i < 4; i++) {
  712. theSel[i].x += pt.x - ptRelativeTo.x;
  713. theSel[i].y += pt.y - ptRelativeTo.y;
  714.       }
  715.       ptRelativeTo = pt;
  716.     } else {
  717.       // pt 0 doesn't change; pt 2 becomes new pont
  718.       // pt 1 needs to change x, pt 3 needs to change y
  719.       theSel[1].x = pt.x;
  720.       theSel[3].y = pt.y;
  721.       theSel[2] = pt;
  722.     }
  723.   }
  724.   
  725. #ifndef no_overlay_support
  726.   Togl_PostOverlayRedisplay (togl);
  727. #else
  728.   drawOverlayAndSwap(togl); 
  729. #endif
  731.   return TCL_OK;
  732. }
  735. int
  736. PlvGetSelectionCursorCmd(ClientData clientData, Tcl_Interp *interp, 
  737.  int argc, char *argv[])
  738. {
  739.   if (argc < 3)
  740.     return TCL_ERROR;
  742.   Selection::Pt pt;
  743.   pt.x = atoi(argv[1]);
  744.   pt.y = theHeight - atoi(argv[2]);
  745.   
  746.   // cursors: default = tcross, handle = dotbox, border = fleur
  747.   // check handles
  748.   if (findSelectionHandle (pt, theSel) >= 0)
  749.     interp->result = "dotbox";
  750.   else if (findSelectionLine (pt, theSel) >= 0)
  751.     interp->result = "fleur";
  752.   else
  753.     interp->result = "tcross";
  755.   return TCL_OK;
  756. }
  758. // ------------------------------------------------------------
  759. // PlvGetSelectionInfoCmd
  760. // Gets a string for the info of the current selection object
  761. // ------------------------------------------------------------
  762. int
  763. PlvGetSelectionInfoCmd(ClientData clientData, Tcl_Interp *interp, 
  764.   int argc, char *argv[])
  765. {
  766.   char buff[256];
  768.   switch ( theSel.type ) {
  769.   case Selection::none:
  770.     interp->result = "PlvGetSelectionInfoCmd: error -- nothing selected";
  771.     return TCL_ERROR;
  772.     //    break;
  773.   case Selection::line:
  774.     sprintf(buff, "line %i %i %i %i", theSel[0].x, theSel[0].y, 
  775.     theSel[1].x, theSel[1].y);
  776.     break; 
  777.   case Selection::rect:
  778.     /*
  779.     sprintf(buff, "rect %i %i %i %i %i %i %i %i", theSel[0].x, theSel[0].y,
  780.     theSel[1].x, theSel[1].y, theSel[2].x, theSel[2].y,
  781.     theSel[3].x, theSel[3].y);
  782.     */
  783.     break;
  784.   case Selection::shape:
  785.     // CHEAP HACK WARNING!
  786.     // Something weird happens when I try to use 0 1 2
  787.     printf("PlvGetSelectionInfoCmd: getting only first 3 pointsn");
  788.     sprintf(buff, "shape %i %i %i %i %i %i", theSel[1].x, theSel[1].y,
  789.     theSel[2].x, theSel[2].y, theSel[3].x, theSel[3].y);
  790.     break;
  791.   default:
  792.     interp->result = "PlvGetSelectionInfoCmd: error -- type not supported";
  793.     return TCL_ERROR;
  794.     //    break;
  795.   }
  797.   Tcl_SetResult(interp, buff, TCL_VOLATILE);
  798.   return TCL_OK;
  799. }
  802. int
  803. PlvMeshIntersectSelectionCmd(ClientData clientData, Tcl_Interp *interp, 
  804.      int argc, char *argv[])
  805. {
  806.   if (argc < 2) {
  807.     interp->result = "Missing mesh argument in PlvShowBySelectionCmd";
  808.     return TCL_ERROR;
  809.   }
  811.   if (theSel.type != Selection::rect) {
  812.     interp->result = "Only rectangle selections supported";
  813.     return TCL_ERROR;
  814.   }
  816.   DisplayableMesh* dm = FindMeshDisplayInfo (argv[1]);
  817.   if (!dm) {
  818.     interp->result = "Bad mesh argument in PlvShowBySelectionCmd";
  819.     return TCL_ERROR;
  820.   }
  821.   RigidScan* rs = dm->getMeshData();
  822.   Bbox scanBox = rs->worldBbox();
  824.   Bbox screenBounds;
  825.   for (int i = 0; i < 8; i++) {
  826.     Pnt3 pt = scanBox.corner (i);
  827.     screenBounds.add (pt);
  828.   }
  830.   return TCL_OK;
  831. }
  834. void
  835. initSelection (struct Togl* togl)
  836. {
  837.   if (togl) {
  838.     olColor = Togl_AllocColorOverlay (togl, 1, 0, 0);
  839.     handleColor = Togl_AllocColorOverlay (togl, 1, 1, 0);
  840.     handleSelColor = Togl_AllocColorOverlay (togl, 0, 1, 0);
  841.   }
  842. }
  845. void
  846. drawSelection (struct Togl* togl)
  847. {
  848.   int width, height;
  849.   
  850.   width = Togl_Width (togl);
  851.   height = Togl_Height (togl);
  852.   
  853.   glViewport(0, 0, width, height); 
  854.   glMatrixMode(GL_PROJECTION);
  855.   glPushMatrix(); // kberg - needed when overlay planes not available
  856.   glLoadIdentity();
  857.   gluOrtho2D(-0.5, width+0.5, -0.5, height+0.5);
  858.    
  859.   glMatrixMode(GL_MODELVIEW);
  860.   glPushMatrix(); // kberg - needed for when overlay planes not available
  861.   glLoadIdentity();
  862.   
  863.   int nPts = theSel.pts.size();
  864.   if (nPts) {
  865.     glPushAttrib (GL_LIGHTING_BIT);
  866.     glDisable (GL_LIGHTING);
  867.     
  868.     // draw handles, if it's not currently being dragged
  869.     if (!bManipulatingSel) {
  870.       for (int i = 0; i < nPts; i++)
  871. drawHandle (theSel[i],
  872.     theSel.type == Selection::shape
  873.     && ((i==0) || (i==(nPts-1))));
  874.     }
  875.   
  876.     // now draw the selection itself as a line loop   
  877. #ifdef no_overlay_support
  878.     glColor3f(1,0,0);
  879. #else
  880.      glIndexi (olColor);
  881. #endif
  882.     glBegin (GL_LINE_LOOP);
  883.     for (int i = 0; i <= nPts; i++)
  884.       glVertex2i (theSel[i%nPts].x, theSel[i%nPts].y);
  885.     glEnd();
  887.     glPopAttrib();
  888.   }
  889.   
  890.   glPopMatrix();
  891.   glMatrixMode(GL_PROJECTION);
  892.   glPopMatrix();
  894.   glFinish();
  895. }
  898. static void drawHandle (Selection::Pt pt, bool bSelected)
  899. {
  900.   glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
  901.  
  902. #ifndef no_overlay_support
  903.   glIndexi (bSelected ? handleSelColor : handleColor);
  905.   glBegin (GL_QUADS);
  907. #else
  908.   // no clue on this one, but Linux/nVidia won't draw the quads but
  909.   // will draw the line loop
  910.   glBegin(GL_LINE_LOOP);
  911.   bSelected ?  glColor3f(0,1,0) : glColor3f(1,1,0);
  912. #endif
  913.   glVertex2i (pt.x - kHandleSize, pt.y - kHandleSize);
  914.   glVertex2i (pt.x - kHandleSize, pt.y + kHandleSize);
  915.   glVertex2i (pt.x + kHandleSize, pt.y + kHandleSize);
  916.   glVertex2i (pt.x + kHandleSize, pt.y - kHandleSize);
  917.   glEnd();
  918. }
  921. static bool ptOnHandle (Selection::Pt pt, Selection::Pt handle)
  922. {
  923.   return (   abs (pt.x - handle.x) < kHandleSize
  924.   && abs (pt.y - handle.y) < kHandleSize);
  925. }
  928. static int findSelectionHandle (Selection::Pt pt, const Selection& sel)
  929. {
  930.   int nPts = sel.pts.size();
  931.   for (int i = 0; i < nPts; i++)
  932.     if (ptOnHandle (pt, sel[i]))
  933.       return i;
  935.   return -1;
  936. }
  939. static bool ptOnLine (Selection::Pt pt,
  940.       Selection::Pt start, Selection::Pt end)
  941. {
  942.   // handle vertical line
  943.   if (start.x == end.x) {
  944.     if (abs (pt.x - start.x) >= kHandleSize)
  945.       return false;
  947.     if (pt.y > start.y && pt.y > end.y)
  948.       return false;
  949.     if (pt.y < start.y && pt.y < end.y)
  950.       return false;
  952.     return true;
  953.   }
  955.   // ok, not vertical -- check horizontal
  956.   if (pt.x < start.x && pt.x < end.x)
  957.     return false;
  958.   if (pt.x > start.x && pt.x > end.x)
  959.     return false;
  961.   // ok horizontally -- get slope
  962.   float slope = (end.y - start.y) / (float)(end.x - start.x);
  963.   float icpt = start.y - slope * start.x;
  964.   int yofs = pt.y - (icpt + (slope * pt.x));
  966.   return (abs (yofs) < kHandleSize);
  967. }
  970. static int findSelectionLine (Selection::Pt pt, const Selection& sel)
  971. {
  972.   int nPts = sel.pts.size();
  973.   for (int i = 0; i < nPts; i++)
  974.     if (ptOnLine (pt, sel[i], sel[(i+1)%nPts]))
  975.       return i;
  976.   
  977.   return -1;
  978. }
  981. void splTessError (GLenum er)
  982. {
  983.   const GLubyte *str = gluErrorString (er);
  984.   cout << "Tesselation error during polyline rasterization: "
  985.        << str << endl;
  986. }
  989. vector<GLdouble*> hack_vert_alloc;
  991. void splTessCombine (GLdouble coords[3],
  992.   GLdouble* vertex_data[4],
  993.   GLfloat weight[4],
  994.   GLdouble** dataOut)
  995. {
  996.   GLdouble* vertex = new GLdouble[3];
  998.   vertex[0] = coords[0];
  999.   vertex[1] = coords[1];
  1000.   vertex[2] = coords[2];
  1002.   hack_vert_alloc.push_back (vertex);  // mark to free later
  1003.   *dataOut = vertex;
  1004. }
  1007. unsigned char* filledPolyPixels (int& width, int& height,
  1008.  const vector<ScreenPnt>& pts)
  1009. {
  1010.   // for word alignment: rounded up to nearest mult. of 4
  1011.   width = 4 * ((width + 3) / 4);
  1013.   // set up GL modes for rendering in screen coords
  1014.   int vp[4];
  1015.   glGetIntegerv(GL_VIEWPORT, vp);
  1016.   glViewport(0, 0, width, height);
  1017.   glMatrixMode(GL_PROJECTION);
  1018.   glPushMatrix();
  1019.   glLoadIdentity();
  1020.   gluOrtho2D(-0.5, width+0.5, -0.5, height+0.5);
  1021.   glMatrixMode(GL_MODELVIEW);
  1022.   glPushMatrix();
  1023.   glLoadIdentity();
  1025.   // render filled polygon with tesselator
  1026.   glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  1027.   glClear (GL_COLOR_BUFFER_BIT);
  1028.   glDisable (GL_DEPTH_TEST);
  1029.   glDisable (GL_LIGHTING);
  1030.   glDisable (GL_CULL_FACE);
  1031.   glColor3f (1, 1, 1);
  1033. #ifdef GLU_VERSION_1_2
  1034.   GLUtesselator* tess = gluNewTess();
  1035.   hack_vert_alloc.clear();
  1037. #ifdef WIN32
  1038. #  define DECORATE (GLvoid(__stdcall *) ()) &
  1039. #else
  1040. #  define DECORATE (GLvoid(*) ()) &
  1041. #endif
  1042.   gluTessCallback (tess, GLU_TESS_VERTEX, DECORATE glVertex3dv);
  1043.   gluTessCallback (tess, GLU_TESS_BEGIN,  DECORATE glBegin);
  1044.   gluTessCallback (tess, GLU_TESS_END,    DECORATE glEnd);
  1045.   gluTessCallback (tess, GLU_TESS_COMBINE,DECORATE splTessCombine);
  1046.   gluTessCallback (tess, GLU_TESS_ERROR,  DECORATE splTessError);
  1047. #undef DECORATE
  1049.   gluTessBeginPolygon (tess, NULL);
  1050.   gluTessBeginContour (tess);
  1052.   int nPts = pts.size();
  1053.   GLdouble* coords = new GLdouble [3 * (nPts + 1)];
  1054.   for (int i = 0; i <= nPts; i++) {
  1055.     coords[3*i  ] = pts[i%nPts].x;
  1056.     coords[3*i+1] = pts[i%nPts].y;
  1057.     coords[3*i+2] = 0;
  1058.     gluTessVertex (tess, coords + 3*i, coords + 3*i);
  1059.   }
  1060.   
  1061.   gluTessEndContour (tess);
  1062.   gluTessEndPolygon (tess);
  1063.   gluDeleteTess (tess);
  1064.   delete coords;
  1066.   // free memory used by combine-created vertices
  1067.   for (i = 0; i < hack_vert_alloc.size(); i++)
  1068.     delete hack_vert_alloc[i];
  1069.   hack_vert_alloc.clear();
  1070. #endif // GLU_VERSION_1_2
  1072.   // read the fruits of our labors
  1073.   unsigned char* pixels = new unsigned char [width*height];
  1074.   memset (pixels, 0, width*height);
  1075.   glReadBuffer (GL_BACK);
  1076.   glReadPixels (0, 0, width, height, GL_RED, GL_UNSIGNED_BYTE,
  1077. pixels);
  1078.   GLenum a = glGetError();
  1079.   if (a != GL_NO_ERROR) {
  1080.     cout << "raw error: " << a << endl;
  1081.     cout << "GL error: " << gluErrorString (a) << endl;
  1082.   }
  1084.   // and reset GL params
  1085.   glMatrixMode (GL_PROJECTION);
  1086.   glPopMatrix();
  1087.   glMatrixMode (GL_MODELVIEW);
  1088.   glPopMatrix();
  1089.   glViewport (vp[0], vp[1], vp[2], vp[3]);
  1091. #if 0
  1092.   int n = 0;
  1093.   for (i = 0; i < width*height; i++) {
  1094.     if (pixels[i] != 0)
  1095.       n++;
  1096.   }
  1097.   cout << n << " pixels are set" << endl;
  1098. #endif
  1100.   return pixels;
  1101. }
  1105. int
  1106. PlvGetSelectedMeshesCmd(ClientData clientData, Tcl_Interp *interp, 
  1107. int argc, char *argv[])
  1108. {
  1109.   bool bIncludeHidden = false;
  1110.   bool bInvert = false;
  1111.   bool bSilent = false;
  1113.   for (int i = 1; i < argc; i++) {
  1114.     if (!strcmp (argv[i], "hidden"))
  1115.       bIncludeHidden = true;
  1116.     else if (!strcmp (argv[i], "invert"))
  1117.       bInvert = true;
  1118.     else if (!strcmp (argv[i], "silent"))
  1119.       bSilent = true;
  1120.     else {
  1121.       cerr << argv[0] << " doesn't understand " << argv[i] << endl;
  1122.       interp->result = "Bad argument: look at stderr";
  1123.       return TCL_ERROR;
  1124.     }
  1125.   }
  1127.   if (theSel.type != Selection::rect) {
  1128.     if (bSilent && theSel.type == Selection::none)
  1129.       return TCL_OK;
  1131.     interp->result = "First you must select an area";
  1132.     return TCL_ERROR;
  1133.   }
  1135.   for (i = 0; i < theScene->meshSets.size(); i++) {
  1136.     DisplayableMesh *displayMesh = theScene->meshSets[i];
  1137.     if (!bIncludeHidden && !displayMesh->getVisible())
  1138.       continue;
  1140.     RigidScan *mesh = displayMesh->getMeshData();
  1141.     VertexFilter* filter = filterFromSelection (mesh, theSel);
  1142.     if (!filter) {
  1143.       interp->result = "First you must select an area";
  1144.       return TCL_ERROR;
  1145.     }
  1147.     if (bInvert)
  1148.       filter->invert();
  1150.     if (filter->accept(mesh->localBbox())) {
  1151.       Tcl_AppendElement (interp, (char*)displayMesh->getName());
  1152.     }
  1153.     delete filter;
  1154.   }
  1155.   
  1156.   return TCL_OK;
  1157. }
  1160. void resizeSelectionToWindow (struct Togl* togl)
  1161. {
  1162.   int nPts = theSel.pts.size();
  1163.   if (!nPts) return;
  1165.   float newhyp = sqrt (Togl_Width(togl)*Togl_Width(togl)
  1166.        +Togl_Height(togl)*Togl_Height(togl));
  1167.   float oldhyp = sqrt (theWidth*theWidth + theHeight*theHeight);
  1168.   float scale = newhyp / oldhyp;
  1170.   int cx = 0, cy = 0;
  1171.   for (int i = 0; i < nPts; i++) {
  1172.     cx += theSel[i].x;
  1173.     cy += theSel[i].y;
  1174.   }
  1175.   cx /= i;
  1176.   cy /= i;
  1178.   int ncx = cx * Togl_Width (togl) / theWidth;
  1179.   int ncy = cy * Togl_Height (togl) / theHeight;
  1181.   for (i = 0; i < nPts; i++) {
  1182.     theSel[i].x = ncx + scale * (theSel[i].x - cx);
  1183.     theSel[i].y = ncy + scale * (theSel[i].y - cy);
  1184.   }
  1186.   Togl_PostOverlayRedisplay (togl);
  1187. }