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

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

3D图形编程

开发平台：

Visual C++

plvMeshCmds.cc：源码内容
  1. #include <stdlib.h>
  2. #include "plvDrawCmds.h"
  3. #include "plvGlobals.h"
  4. #include "plvDraw.h"
  5. #include "plvMeshCmds.h"
  6. #include "plvScene.h"
  7. #include "ply++.h"
  8. #include "Mesh.h"
  9. #include "RigidScan.h"
  10. #include "togl.h"
  11. #include "DisplayMesh.h"
  12. #include "GroupUI.h"
  13. #include "plvPlyCmds.h"
  14. #include "GroupScan.h"
  15. #include "GenericScan.h"
  16. #include "ScanFactory.h"
  17. #include "plvClipBoxCmds.h"
  19. static RigidScan*
  20. GetMeshFromCmd (Tcl_Interp* interp, int argc, char* argv[],
  21. int minArgC = 2, DisplayableMesh** pOutDisp = NULL,
  22. int iMeshName = 1)
  23. {
  24.   char buf [1000];
  26.   if (argc < minArgC) {
  27.     sprintf (buf, "%s: Wrong number of args", argv[0]);
  28.     Tcl_SetResult (interp, buf, TCL_VOLATILE);
  29.     return NULL;
  30.   }
  32.   DisplayableMesh* dispMesh = FindMeshDisplayInfo (argv[iMeshName]);
  33.   if (pOutDisp != NULL)
  34.     *pOutDisp = dispMesh;
  36.   if (dispMesh == NULL) {
  37.     sprintf (buf, "%s: Mesh '%s' does not exist", argv[0], argv[iMeshName]);
  38.     Tcl_SetResult (interp, buf, TCL_VOLATILE);
  39.     return NULL;
  40.   }
  42.   RigidScan* meshSet = dispMesh->getMeshData();
  43.   assert (meshSet != NULL);
  45.   return meshSet;
  46. }
  49. int
  50. PlvMeshResolutionCmd(ClientData clientData, Tcl_Interp *interp, 
  51.      int argc, char *argv[])
  52. {
  53.   DisplayableMesh* dm;
  54.   RigidScan* scan = GetMeshFromCmd (interp, argc, argv, 3, &dm);
  55.   if (!scan)
  56.     return TCL_ERROR;
  58.   bool ok = false;
  60.   if (!strcmp (argv[2], "higher"))
  61.     ok = scan->select_finer();
  62.   else if (!strcmp (argv[2], "lower"))
  63.     ok = scan->select_coarser();
  64.   else if (!strcmp (argv[2], "highest"))
  65.     ok = scan->select_finest();
  66.   else if (!strcmp (argv[2], "lowest"))
  67.     ok = scan->select_coarsest();
  68.   else
  69.     ok = scan->select_by_count (atoi (argv[2]));
  71.   dm->invalidateCachedData();
  72.   redraw (true);
  74.   interp->result = ok ? "1" : "0";
  75.   return TCL_OK;
  76. }
  79. int
  80. PlvMeshDecimateCmd(ClientData clientData, Tcl_Interp *interp,
  81.    int argc, char *argv[])
  82. {
  83.   RigidScan* theSet = GetMeshFromCmd (interp, argc, argv, 3);
  84.   if (!theSet)
  85.     return TCL_ERROR;
  87.   int targetSize = atoi(argv[2]);
  89.   ResolutionCtrl::Decimator dec = ResolutionCtrl::decQslim;
  90.   if (argc > 3) {
  91.     if (!strcmp (argv[3], "qlsim"))
  92.       dec = ResolutionCtrl::decQslim;
  93.     else if (!strcmp (argv[3], "plycrunch"))
  94.       dec = ResolutionCtrl::decPlycrunch;
  95.   }
  97.   int nPolys = theSet->create_resolution_absolute(targetSize, dec);
  99.   char szPolys[20];
  100.   sprintf (szPolys, "%d", nPolys);
  101.   Tcl_SetResult (interp, szPolys, TCL_VOLATILE);
  103.   if (nPolys)
  104.     return TCL_OK;
  105.   else 
  106.     return TCL_ERROR;
  107. }
  109. int
  110. PlvMeshResListCmd(ClientData clientData, Tcl_Interp *interp, 
  111.        int argc, char *argv[])
  112. {
  113.   char result[PATH_MAX], tempstr[PATH_MAX];
  115.   RigidScan* theSet = GetMeshFromCmd (interp, argc, argv, 2);
  116.   if (!theSet)
  117.     return TCL_ERROR;
  119.   bool bShort = false;
  120.   if (argc > 2 && !strcmp (argv[2], "short"))
  121.     bShort = true;
  123.   vector<ResolutionCtrl::res_info> resList;
  124.   theSet->existing_resolutions (resList);
  126.   result[0] = '';
  127.   for (int i = 0; i < resList.size(); i++) {
  128.     if (bShort)
  129.       sprintf (tempstr, "%d ", resList[i].abs_resolution);
  130.     else
  131.       sprintf (tempstr, "(%c%c):%d ",
  132.        resList[i].desired_in_mem ? 'A' : '-',
  133.        resList[i].in_memory ? 'L' : '-',
  134.        resList[i].abs_resolution);
  135.     strcat(result, tempstr);
  136.   }
  137.   Tcl_SetResult(interp, result, TCL_VOLATILE);
  138.   return TCL_OK;
  139. }
  141. int
  142. PlvSetMeshResPreloadCmd(ClientData clientData, Tcl_Interp *interp,
  143. int argc, char *argv[])
  144. {
  145.   RigidScan* theSet = GetMeshFromCmd (interp, argc, argv, 4);
  146.   if (!theSet)
  147.     return TCL_ERROR;
  149.   int nRes = atoi(argv[2]);
  150.   bool bPreload = atoi(argv[3]);
  152.   if (theSet->set_load_desired (nRes, bPreload))
  153.     return TCL_OK;
  154.   
  155.   interp->result = "Specified resolution does not exist";
  156.   return TCL_ERROR;
  157. }
  160. int
  161. PlvCurrentResCmd(ClientData clientData, Tcl_Interp *interp,
  162.  int argc, char *argv[])
  163. {
  164.   char info[PATH_MAX];
  166.   RigidScan* meshSet = GetMeshFromCmd (interp, argc, argv, 2);
  167.   if (!meshSet)
  168.   {
  169.     interp->result = "Unable to find mesh in PlvCurrentResCmd";
  170.     return TCL_ERROR;
  171.   }
  173.   if (!meshSet->num_resolutions())
  174.   {
  175.     interp->result = "Given mesh has no data in PlvCurrentResCmd";
  176.     return TCL_ERROR;
  177.   }
  179.   ResolutionCtrl::res_info res = meshSet->current_resolution();
  180.   sprintf(info, "%d", res.abs_resolution);
  181.   Tcl_SetResult(interp, info, TCL_VOLATILE);
  182.   return TCL_OK;
  183. }
  186. int
  187. PlvMeshInfoCmd(ClientData clientData, Tcl_Interp *interp, 
  188.        int argc, char *argv[])
  189. {
  190.   RigidScan* meshSet = GetMeshFromCmd (interp, argc, argv, 2);
  191.   if (meshSet == NULL)
  192.     return TCL_ERROR;
  193.   
  194.   if (argc > 2 && 0 == strcmp (argv[2], "graphical"))
  195.     Tcl_SetResult(interp, (char *)meshSet->getInfo().c_str(), 
  196.   TCL_VOLATILE);
  197.   else
  198.     cout << meshSet->getInfo() << endl;
  200.   return TCL_OK;
  201. }
  203. int
  204. PlvMeshDeleteResCmd(ClientData clientData, Tcl_Interp *interp,
  205.     int argc, char *argv[])
  206. {
  207.   RigidScan* scan = GetMeshFromCmd (interp, argc, argv, 3);
  208.   if (scan == NULL)
  209.     return TCL_ERROR;
  211.   if (scan->num_resolutions() == 1) {
  212.     interp->result = "Scan has only 1 resolution; can't be deleted";
  213.     return TCL_ERROR;
  214.   }
  215.   int resLevel = atoi(argv[2]);
  216.   if (!scan->delete_resolution (resLevel))
  217.     return TCL_ERROR;
  218.   
  219.   //cout << "new #resolutions: " << scan->num_resolutions() << endl;
  220.   return TCL_OK;
  221. }
  224. int
  225. PlvMeshUnloadResCmd(ClientData clientData, Tcl_Interp *interp,
  226.     int argc, char* argv[])
  227. {
  228.   DisplayableMesh* dm;
  229.   RigidScan* scan = GetMeshFromCmd (interp, argc, argv, 3, &dm);
  230.   if (scan == NULL) {
  231.     cerr << argv[0] << " does not exist!" << endl;
  232.     return TCL_ERROR;
  233.   }
  235.   int resLevel = atoi(argv[2]);
  236.   
  237.   if (!scan->release_resolution (resLevel)) {
  238.     cerr << "scan " << dm->getName()
  239.  << " failed to release resolution" << endl;
  240.     return TCL_ERROR;
  241.   }
  243.   // scan released memory... which dm could have hold on
  244.   dm->invalidateCachedData();
  246.   return TCL_OK;
  247. }
  249. static void DeleteHelper (DisplayableMesh *mesh);
  251. int
  252. PlvMeshSetDeleteCmd(ClientData clientData, Tcl_Interp *interp, 
  253.  int argc, char *argv[])
  254. {
  255.   DisplayableMesh* dispMesh;
  256.   RigidScan* meshSet = GetMeshFromCmd (interp, argc, argv, 2, &dispMesh);
  257.   if (meshSet == NULL)
  258.     return TCL_ERROR;
  260.   DeleteHelper(dispMesh);
  261.   //theScene->deleteMeshSet (dispMesh);
  263.   return TCL_OK;
  264. }
  267. static void 
  268. DeleteHelper (DisplayableMesh *mesh) {
  269.   RigidScan *scan = mesh->getMeshData();
  270.   GroupScan *group = dynamic_cast<GroupScan*>(scan);
  272.   if (group) {
  273.     vector<DisplayableMesh*> children = ungroupScans(mesh);
  274.     
  275.     for (DisplayableMesh** it = children.begin(); it < children.end(); it++) {
  276.       DeleteHelper(*it);
  277.     }
  279.   } else {
  280.     theScene->deleteMeshSet (mesh);
  281.   }
  282. }
  284.   
  287. int
  288. PlvTransMeshCmd (ClientData clientData, Tcl_Interp *interp,
  289.  int argc, char* argv[])
  290. {
  291.   if (argc != 5) {
  292.     printf ("%s: mesh x y zn", argv[0]);
  293.     return TCL_OK;
  294.   }
  295.   
  296.   DisplayableMesh* dispMesh = FindMeshDisplayInfo (argv[1]);
  297.   if (dispMesh == NULL) {
  298.     printf ("Nonexistent mesh %sn", argv[1]);
  299.     return TCL_OK;
  300.   }
  301.   RigidScan* meshSet = dispMesh->getMeshData();
  302.   assert (meshSet != NULL);
  304.   meshSet->translate(atof(argv[2]), atof(argv[3]), atof(argv[4]));
  305.   redraw (true);
  307.   return TCL_OK;
  308. }
  311. int
  312. PlvMeshRemoveStepCmd(ClientData clientData, Tcl_Interp *interp,
  313.      int argc, char *argv[])
  314. {
  316. #if 1
  317.   printf ("Unimplemented!!!n");
  318. #endif
  320.   return TCL_OK;
  321. }
  323. int
  324. PlvScanColorCodeCmd(ClientData clientData, Tcl_Interp *interp,
  325.     int argc, char *argv[])
  326. {
  327.   DisplayableMesh* dispMesh;
  328.   RigidScan* meshSet = GetMeshFromCmd (interp, argc, argv, 3, &dispMesh, 2);
  329.   if (meshSet == NULL)
  330.     return TCL_ERROR;
  332.   if (!strcmp (argv[1], "set")) {
  333.     unsigned int r, g, b;
  334.     if (argc != 4 || 3 != sscanf (argv[3], "#%02x%02x%02x", &r, &g, &b)) {
  335.       interp->result = "Bad color args.";
  336.       return TCL_ERROR;
  337.     }
  338.     vec3uc color = {r, g, b};
  339.     dispMesh->setFalseColor (color);
  341.   } else {
  343.     char color[20];
  344.     const vec3uc& diffuse = dispMesh->getFalseColor();
  345.     sprintf (color, "#%02x%02x%02x",
  346.      (unsigned)diffuse[0],
  347.      (unsigned)diffuse[1],
  348.      (unsigned)diffuse[2]);
  349.     Tcl_SetResult (interp, color, TCL_VOLATILE);
  350.   }
  352.   return TCL_OK;
  353. }
  356. int
  357. PlvFlipMeshNormalsCmd(ClientData clientData, Tcl_Interp *interp,
  358.       int argc, char *argv[])
  359. {
  360.   DisplayableMesh* mesh;
  361.   RigidScan* scan = GetMeshFromCmd (interp, argc, argv, 2, &mesh);
  362.   if (scan == NULL)
  363.     return TCL_ERROR;
  365.   scan->flipNormals();
  366.   mesh->invalidateCachedData();
  368.   redraw (true);
  369.   return TCL_OK;
  370. }
  373. int
  374. PlvBlendMeshCmd(ClientData clientData, Tcl_Interp *interp,
  375. int argc, char *argv[])
  376. {
  377.   DisplayableMesh* mesh;
  378.   RigidScan* meshSet = GetMeshFromCmd (interp, argc, argv, 3, &mesh);
  379.   if (meshSet == NULL)
  380.     return TCL_ERROR;
  382.   float alpha = atof (argv[2]);
  384.   if (alpha > 0.0 && alpha < 1.0)
  385.     mesh->setBlend (true, alpha);
  386.   else
  387.     mesh->setBlend (false, 1);
  389.   redraw (true);
  390.   return TCL_OK;
  391. }
  394. int
  395. PlvGroupScansCmd(ClientData clientData, Tcl_Interp *interp,
  396.  int argc, char *argv[])
  397. {
  398.   if (argc < 3) {
  399.     interp->result = "Bad args to PlvGroupScansCmd";
  400.     return TCL_ERROR;
  401.   }
  403.   vector<DisplayableMesh*> members;
  404.   
  405.   if (!strcmp (argv[1], "create")) {
  406.       
  407.     for (int i = 3; i < argc-1; i++) {
  408.       DisplayableMesh* dm = FindMeshDisplayInfo (argv[i]);
  409.       if (!dm) {
  410. cerr << "No such mesh: " << argv[i] << endl;
  411. interp->result = "Missing scan in PlvGroupScansCmd";
  412. return TCL_ERROR;
  413.       }
  414.       members.push_back (dm);
  415.     }
  416.     bool dirty = (bool) atoi(argv[argc-1]);
  417.     DisplayableMesh* group = groupScans (members, argv[2], dirty);
  418.     
  419.     if (!group) {
  420.       interp->result = "The group could not be created.";
  421.       return TCL_ERROR;
  422.     }
  423.     interp->result = (char*)group->getName();
  425.   } else if (!strcmp (argv[1], "list")) {
  427.     DisplayableMesh* mesh;
  428.     if (!GetMeshFromCmd (interp, argc, argv, 3, &mesh, 2))
  429.       return TCL_ERROR;
  431.     GroupScan* group = dynamic_cast<GroupScan*> (mesh->getMeshData());
  433.     crope names;
  434.     if (group) {
  435.       if (group->get_children_for_display (members)) {
  436. for (int i = 0; i < members.size(); i++) {
  437.   names += crope (" ") + members[i]->getName();
  438. }
  439.       }
  440.     }
  441.     Tcl_SetResult (interp, (char*)names.c_str(), TCL_VOLATILE);
  443.   } else if (!strcmp (argv[1], "break") || !strcmp (argv[1], "expand")) {
  445.     DisplayableMesh* mesh;
  446.     if (!GetMeshFromCmd (interp, argc, argv, 3, &mesh, 2))
  447.       return TCL_ERROR;
  449.     members = ungroupScans (mesh);
  450.     if (!members.size()) {
  451.       interp->result = "The scan could not be ungrouped -- perhaps "
  452. "it's not a group in the first place?";
  453.       return TCL_ERROR;
  454.     }
  456.     crope names (members[0]->getName());
  457.     for (int i = 1; i < members.size(); i++) {
  458.       names += crope (" ") + members[i]->getName();
  459.     }
  460.     Tcl_SetResult (interp, (char*)names.c_str(), TCL_VOLATILE);
  462.   } else if (!strcmp (argv[1], "isgroup")) {
  464.       DisplayableMesh* dm = FindMeshDisplayInfo (argv[2]);
  465.       if (!dm) {
  466. interp->result = "Missing scan in PlvGroupScansCmd";
  467. return TCL_ERROR;
  468.       }
  469.       RigidScan* scan = dm->getMeshData();
  470.       vector<RigidScan*> children;
  471.       if (scan->get_children (children)) {
  472. interp->result = "1";
  473.       } else {
  474. interp->result= "0";
  475.       }
  476.       return TCL_OK;
  478.   } else {
  479.     interp->result = "Unrecognized option to PlvGroupScansCmd";
  480.     return TCL_ERROR;
  481.   }
  483.   //cout << "Group: scene now has " << theScene->meshSets.size()
  484.   //     << " meshes" << endl;
  486.   return TCL_OK;
  487. }
  490. int
  491. PlvHiliteScanCmd(ClientData clientData, Tcl_Interp *interp,
  492.  int argc, char *argv[])
  493. {
  494.   // unhilite previous selection in meshcontrols window
  495.   for (int i = 0; i < g_hilitedScans.size(); i++)
  496.     Tcl_VarEval (interp, "hiliteScanEntry ",
  497.  g_hilitedScans[i]->getName(),
  498.  " 0", NULL);
  500.   // build new vector of currently hilited scans
  501.   g_hilitedScans.clear();
  502.   g_hilitedScans.reserve (argc - 1);
  504.   for (i = 1; i < argc; i++) {
  505.     DisplayableMesh* dispMesh = FindMeshDisplayInfo (argv[i]);
  506.     if (!dispMesh) {
  507.       cerr << argv[0] << " can't find " << argv[i] << endl;
  508.       interp->result = "Bad scan in PlvHiliteScanCmd";
  509.       return TCL_ERROR;
  510.     }
  511.     
  512.     g_hilitedScans.push_back (dispMesh);
  513.   }
  515.   // and hilite current selection in meshcontrols window
  516.   for (i = 0; i < g_hilitedScans.size(); i++)
  517.     Tcl_VarEval (interp, "hiliteScanEntry ",
  518.  g_hilitedScans[i]->getName(),
  519.  " 1", NULL);
  521. #ifndef no_overlay_support
  522.   Togl_PostOverlayRedisplay (toglCurrent);
  523. #else
  524.   drawOverlayAndSwap(toglCurrent);
  525. #endif
  527.   return TCL_OK;
  528. }
  531. int
  532. SczXformScanCmd (ClientData clientData, Tcl_Interp *interp, 
  533.  int argc, char *argv[])
  534. {
  535.   RigidScan* scan = GetMeshFromCmd (interp, argc, argv, 2);
  536.   if (!scan)
  537.     return TCL_ERROR;
  539.   if (argc < 3) {
  540.     interp->result = "Missing command in SczXformScanCmd";
  541.     return TCL_ERROR;
  542.   }
  544.   if (!strcmp (argv[2], "reload")) {
  545.     if (!scan->readXform (scan->get_basename())) {
  546.       cerr << "Scan " << scan->get_name()
  547.    << " failed to read xform." << endl;
  548.       interp->result = "Xform read failed!";
  549.       return TCL_ERROR;
  550.     }
  551.   } else if (!strcmp (argv[2], "matrix")) {
  552.     if (argc < 4) {
  553.       interp->result = "Missing matrix!";
  554.       return TCL_ERROR;
  555.     }
  557.     Xform<float> xfTo;
  558.     if (!matrixFromString (argv[3], xfTo)) {
  559.       interp->result = "Bad matrix!";
  560.       return TCL_ERROR;
  561.     }
  563.     Xform<float> xfRelTo;
  564.     if (argc > 4) {
  565.       if (!strcmp (argv[4], "relative"))
  566. xfTo = xfTo * scan->getXform();
  567.       else if(!matrixFromString (argv[4], xfRelTo)) {
  568. interp->result = "Bad matrix!";
  569. return TCL_ERROR;
  570.       }
  571.     }
  573.     if (!xfRelTo.isIdentity()) {
  574.       xfRelTo.invert();
  575.       xfTo = xfTo * xfRelTo * scan->getXform();
  576.     }
  578.     scan->setXform (xfTo);
  579.   }
  581.   theScene->computeBBox();
  582.   redraw();
  584.   return TCL_OK;
  585. }
  588. int SczGetScanXformCmd(ClientData clientData, Tcl_Interp *interp,
  589.        int argc, char *argv[])
  590. {
  591.   RigidScan* scan = GetMeshFromCmd (interp, argc, argv, 2);
  592.   if (!scan)
  593.     return TCL_ERROR;
  595.   if (argc < 3) {
  596.     interp->result = "Missing command in SczXformScanCmd";
  597.     return TCL_ERROR;
  598.   }
  600.   Xform<float> xf = scan->getXform();
  601.   char buffer[1000] = "";
  603.   if (!strcmp (argv[2], "matrix")) {
  604.     char line[100];
  605.     for (int i = 0; i < 4; i++) {
  606.       sprintf (line, "%g %g %g %gn",
  607.        xf(i,0), xf(i,1), xf(i,2), xf(i,3));
  608.       strcat (buffer, line);
  609.     }
  610.   } else if (!strcmp (argv[2], "quat")) {
  611.     float q[4], t[3];
  612.     xf.toQuaternion (q);
  613.     xf.getTranslation (t);
  614.     sprintf (buffer, "%g %g %g %gn%g %g %gn",
  615.      q[0], q[1], q[2], q[3],
  616.      t[0], t[1], t[2]);
  617.   } else if (!strcmp (argv[2], "axis")) {
  618.     float phi, ax, ay, az, t[3];    
  619.     xf.get_rot (phi, ax, ay, az);
  620.     xf.getTranslation (t);
  622.     sprintf (buffer, "%g around %g %g %gn%g %g %gn",
  623.      phi * 180 / M_PI, ax, ay, az,
  624.      t[0], t[1], t[2]);
  625.   } else {
  626.     interp->result = "Bad command in SczGetScanXformCmd!";
  627.     return TCL_ERROR;
  628.   }
  630.   Tcl_SetResult (interp, buffer, TCL_VOLATILE);
  631.   return TCL_OK;
  632. }
  634. int
  635. PlvSmoothMesh(ClientData clientData, Tcl_Interp *interp,
  636.       int argc, char *argv[])
  637. {
  638.   if (argc < 4) {
  639.     interp->result = "plvSmoothMesh <meshName> <iterations> <maxMotion_mm>";
  640.     return TCL_ERROR;
  641.   }
  643.   RigidScan* scan = GetMeshFromCmd (interp, argc, argv, 1);
  644.   if (scan == NULL)
  645.     {
  646.       return TCL_ERROR;
  647.     }
  649.   int iterations = atoi(argv[2]);
  650.   double maxMotion = atof(argv[3]);
  652.   printf ("%s %d %fn",argv[1],iterations,maxMotion);
  654.   GenericScan* gscan=(GenericScan *)scan;
  655.   gscan->dequantizationSmoothing(iterations,maxMotion);
  656.   
  657.   return TCL_OK;
  659. }
  662. #define MINARGCOUNT(n) 
  663.   if (argc < n) { 
  664.     _BadArgCount (argv[0], interp); 
  665.     return TCL_ERROR; 
  666.   }
  668. void _BadArgCount (char* proc, Tcl_Interp* interp)
  669. {
  670.   char buf[200];
  672.   sprintf (buf, "%s: not enough argumentsn", proc);
  673.   Tcl_SetResult (interp, buf, TCL_VOLATILE);
  674. }
  677. int PolygonArea(vector<ScreenPnt> &pts)
  678. {
  679.   int i, j, area = 0;
  681.   for (i=0; i<pts.size(); i++) {
  682.     j = (i + 1) % pts.size();
  683.     
  684.     area += pts[i].x * pts[j].y;
  685.     area -= pts[j].x * pts[i].y;
  686.   }
  687.   
  688.   return area / 2;
  689. }
  691. //
  692. // PlvRunExternalProgram
  693. // ---------------------
  694. // Tcl visible function that enables an external program to be run
  695. // on a mesh.  Temporary files are used to transfer information to/from
  696. // the external program.
  697. //
  698. int PlvRunExternalProgram(ClientData clientData, Tcl_Interp *interp,
  699.   int argc, char *argv[])
  700. {
  701.   char buf[256]; // temporary storage
  702.   char clipBoxCoord[256];
  703.   GLdouble mvmatrix[16], projmatrix[16];
  705.   if (argc != 5) {
  706.     interp->result = "plvRunExternalProgram <command> <name> "
  707.                      "<output> <incBox>";
  708.     return TCL_ERROR;
  709.   }
  711.   // easier access to command line parameters
  712.   char *command = argv[1];
  713.   char *inputMesh = argv[2];
  714.   char *outputMesh = argv[3];
  715.   int writeCBox = atoi(argv[4]);
  717.   // parameter error checking
  718.   if (!strlen(command) || !strlen(inputMesh) || !strlen(outputMesh)) {
  719.     interp->result = "Please enter a command, inputMesh or outputMesh name";
  720.     return TCL_ERROR;
  721.   }
  722.     
  723.   if (writeCBox) {
  724.     clipBoxCoord[0] = '';
  725.     if (theSel.pts.size() < 3) {
  726.       interp->result = "At least 3 points are needed for clipping information";
  727.       return TCL_ERROR;
  728.     }
  730.     GLint viewport[4];
  731.     vector<Pnt3> obj;
  732.     vector<Pnt3> objNormForward;
  734.     // information for unprojecting
  735.     glGetIntegerv(GL_VIEWPORT, viewport);
  736.     glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
  737.     glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);
  738.        
  739.     for (int i=0; i<theSel.pts.size(); i++) {
  740.       Unprojector unp;
  741.       GLdouble objx, objy, objz, objFarX, objFarY, objFarZ;
  742.    
  743.       gluUnProject(theSel.pts[i].x, theSel.pts[i].y, 0,
  744.    mvmatrix, projmatrix, viewport, &objx, &objy, &objz);
  745.       gluUnProject(theSel.pts[i].x, theSel.pts[i].y, 1,
  746.    mvmatrix, projmatrix, viewport, &objFarX, &objFarY, &objFarZ);
  748.       Pnt3 v1(objFarX-objx, objFarY-objy, objFarZ-objz);
  749.       v1.normalize();
  750.       objNormForward.push_back(v1);
  752.       Pnt3 t(objx, objy, objz);
  753.       obj.push_back(t);
  754.     }
  756.     // print the list of information
  757.     // get orientation of face vertices
  758.     bool ccw = (PolygonArea(theSel.pts) > 0 ? true : false);
  759.     
  760.     int j;
  761.     for (i=0; i<theSel.pts.size(); i++) {
  762.       char tempVertBuf[256];
  763.       j = (i + 1) % theSel.pts.size();
  764.       
  765.       Pnt3 crs;
  766.       Pnt3 up(obj[j][0] - obj[i][0], obj[j][1] - obj[i][1], obj[j][2] - obj[i][2]);
  767.       
  768.       if (!ccw)
  769. crs = cross(objNormForward[i], up);
  770.       else
  771. crs = cross(up, objNormForward[i]);
  773.       crs.normalize();
  775.       // make the point list and concat it with the current clip region string
  776.       sprintf(tempVertBuf, "%f %f %f %f %f %f ", (double)obj[i][0], (double)obj[i][1], 
  777.       (double)obj[i][2], (double)crs[0], (double)crs[1], (double)crs[2]);
  779.       strcat(clipBoxCoord, tempVertBuf);
  780.     }    
  781.   }
  783.   // get the mesh to send to output
  784.   DisplayableMesh* dispMesh = FindMeshDisplayInfo (inputMesh);
  786.   if (dispMesh == NULL) {
  787.     sprintf (buf, "%s: Mesh '%s' does not exist", argv[0], inputMesh);
  788.     Tcl_SetResult (interp, buf, TCL_VOLATILE);
  789.     return TCL_ERROR;
  790.   }
  791.   
  792.   // get the rigid scan from the mesh
  793.   RigidScan* meshSet = dispMesh->getMeshData();
  794.   if (meshSet == NULL) {
  795.     sprintf (buf, "%s: Mesh '%s' does not exist", argv[0], inputMesh);
  796.     Tcl_SetResult (interp, buf, TCL_VOLATILE);
  797.     return TCL_ERROR;
  798.   }
  800.   // get a temporary name and convert it to a crope with extension ply
  801.   crope inTName = tmpnam(NULL);
  802.   inTName += ".ply";
  803.     
  804.   // write the highest resolution to the temporary file
  805.   vector<ResolutionCtrl::res_info> resList;
  806.   meshSet->existing_resolutions (resList);
  807.  
  808.   int finest = 0;
  809.   for (int i=1; i<resList.size(); i++) {
  810.     if (resList[finest].abs_resolution < resList[i].abs_resolution)
  811.       finest = i;
  812.   }
  813.    
  814.   // if we're clipping the object against some box, put the object in it's world space orientation
  815.   // rather than just using it's default object space orientation.
  816.   if (writeCBox)
  817.     meshSet->write_resolution_mesh(resList[finest].abs_resolution, inTName, meshSet->getXform());
  818.   else
  819.     meshSet->write_resolution_mesh(resList[finest].abs_resolution, inTName);
  821.   // get another temporary name
  822.   crope outTName = tmpnam(NULL);
  823.   outTName += ".ply";
  824.   
  825.   // execute the command
  826.   char cmdBuffer[512];
  827.   if (writeCBox)
  828.     sprintf(cmdBuffer, "%s %s %s %s", command, inTName.c_str(), outTName.c_str(), clipBoxCoord);
  829.   else
  830.     sprintf(cmdBuffer, "%s %s %s ", command, inTName.c_str(), outTName.c_str());
  832.   if (system (cmdBuffer)) {
  833.     interp->result = "Command failed.";
  835.     // delete the temporary files
  836.     sprintf(cmdBuffer, "rm -f %s", inTName.c_str());
  837.     system(cmdBuffer);
  838.     sprintf(cmdBuffer, "rm -f %s", outTName.c_str());
  839.     system(cmdBuffer);
  841.     return TCL_ERROR;
  842.   }
  844.   // read in the output file
  845.   RigidScan *newScan = CreateScanFromFile(outTName.c_str());
  846.   if (newScan != NULL) {
  847.     crope omName = outputMesh;
  848.     omName += ".ply";
  850.     newScan->set_name(omName);
  851.     
  852.     DisplayableMesh *dm = theScene->addMeshSet(newScan);
  854.     sprintf(cmdBuffer, "clipMeshCreateHelper %s %s", inputMesh, outputMesh);
  855.     Tcl_Eval(interp, cmdBuffer);
  856.   } else {
  857.     interp->result = "A filtered scan could not be created";
  858.     
  859.     // delete the temporary files
  860.     sprintf(cmdBuffer, "rm -f %s", inTName.c_str());
  861.     system(cmdBuffer);
  862.     sprintf(cmdBuffer, "rm -f %s", outTName.c_str());
  863.     system(cmdBuffer);
  865.     return TCL_ERROR;
  866.   }
  868.   // delete the temporary files
  869.   sprintf(cmdBuffer, "rm -f %s", inTName.c_str());
  870.   system(cmdBuffer);
  871.   sprintf(cmdBuffer, "rm -f %s", outTName.c_str());
  872.   system(cmdBuffer);
  874.   return TCL_OK;
  875. }