@@ -0,0 +1,23 @@
+---
+type: map
+title: "Normal-mode arrows start at the atom centre and scale uniformly; small ones end inside the sphere (#228)"
+area: wx-viewer
+paths: [src/viz/propsgcommands/NModeVectCmd.C, src/viz/nodes/VRVector.C, src/apps/builder/NModePanel.C, src/wxviz/viewer/SceneScript.C]
+issues: [228]
+---
+`NModeVectCmd` puts one `VRVector` per atom at the atom centre, direction
+`d * 0.5/maxnorm` (Scale slider multiplies it). `VRVector` scales its whole
+geometry (shaft, head, thickness) by |d|; the tip is at 1.075 |d|, so the
+longest arrow reaches 0.5375 A from its centre.
+
+Displayed sphere radii (Ball And Stick and the default style) are covalent
+x 0.5: O 0.365, H 0.20, C about 0.38. An atom whose displacement is below
+about 70 % of the largest one (any heavy atom in an X-H stretch) has its
+whole arrow inside its sphere. Separately, in Ball And Stick an arrow
+pointing along a bond lies inside the bond cylinder and is hidden too (the
+water symmetric stretch shows no arrows at all with Sign unticked).
+
+Measured, not computed: the scene command `nmcheck <name>` reports per atom
+the farthest arrow vertex from the atom centre (`SoCallbackAction`
+triangles) and where a ray along the arrow meets that atom's sphere
+(`SoRayPickAction`, atom detail); `tools/coin/scenes/calc-water-nmcheck.scene`.
@@ -1,6 +1,7 @@
 #ifndef SCENESCRIPT_H_
 #define SCENESCRIPT_H_
 
+#include <functional>
 #include <string>
 #include <vector>
 using std::string;
@@ -9,6 +10,7 @@ using std::vector;
 class IPropCalculation;
 class SGContainer;
 class SGViewer;
+class wxWindow;
 
 /**
  * Drives the viewer from a text script and writes offscreen snapshots, so
@@ -32,6 +34,11 @@ class SGViewer;
  *   viewall | clear               reset the camera / hide MO and modes
  *   snap <name>   the canvas, read back with glReadPixels -> <name>.ppm
  *   thumb <name>  64x64 black background, as the calculation thumbnail
+ *   nmcheck <name>  per normal-mode arrow: tip distance from its atom centre
+ *                   (arrow triangles) and the atom's sphere surface along
+ *                   the arrow (ray pick) -> <name>.txt
+ * Commands this class does not know go to the caller's extension, if set
+ * (the Builder adds "mopanel", which presses the MO panel's Compute).
  */
 class SceneScript
 {
@@ -43,20 +50,32 @@ class SceneScript
     bool run(const string& scriptPath);
     const string& message() const { return p_msg; }
 
+    // Unknown commands go here; return false (and set fail()) on error.
+    typedef std::function<bool(SceneScript&, const vector<string>&)> Extension;
+    void setExtension(Extension e) { p_ext = e; }
+
+    // Runs act() and records every frame the render area under canvasOwner
+    // paints meanwhile: <name>-NN.ppm plus one line per frame in
+    // <name>-frames.txt with the thresholds of the isosurfaces drawn.
+    bool recordFrames(wxWindow *canvasOwner, const string& name,
+                      std::function<void()> act);
+    bool fail(const string& m) { p_msg = m; return false; }
+
   private:
     bool exec(const vector<string>& w, const string& rest);
     bool pickAtoms(const string& name, const vector<string>& atoms);
     bool dragAtom(const string& name, int atom, int dx, int dy);
     bool countRedraws(const string& name, const vector<string>& steps);
     bool snapshot(const string& name, int size, float r, float g, float b);
     bool exportIso(const string& name);
-    bool fail(const string& m) { p_msg = m; return false; }
+    bool nmCheck(const string& name);
 
     SGViewer *p_viewer;
     SGContainer *p_sg;
     IPropCalculation *p_calc;
     string p_outdir;
     string p_msg;
+    Extension p_ext;
 };
 
 #endif
@@ -178,6 +178,7 @@ using std::vector;
 #include "Peptide.H"
 #include "PropertyIndexPanel.H"
 #include "PropertyPanel.H"
+#include "MoPanel.H"
 #include "PropertyPanelFactory.H"
 #include "ShapeDropDown.H"
 #include "StructLib.H"
@@ -5104,6 +5105,24 @@ void Builder::updatePropertyMenus()
       for (int i = 0; i < 30; i++) { wxTheApp->Yield(true); wxMilliSleep(10); }
       viewer->viewAll();
       SceneScript run(viewer, sg, p_calculation, outdir);
+      //  "mopanel <name>": press the MO panel's Compute, as a user would,
+      //  recording every frame the Builder's own canvas paints meanwhile.
+      run.setExtension([this](SceneScript& s, const vector<string>& w) {
+        if (w[0] != "mopanel" || w.size() != 2)
+          return s.fail("unknown command: " + w[0]);
+        MoPanel *mo = 0;
+        set<PropertyPanel*> panels =
+            PropertyPanel::getPanels(p_calculation->getURL().toString());
+        for (set<PropertyPanel*>::iterator it = panels.begin();
+             it != panels.end() && !mo; ++it)
+          mo = dynamic_cast<MoPanel*>(*it);
+        if (!mo) return s.fail("mopanel: no MO panel");
+        return s.recordFrames(p_viewer, w[1], [mo]() {
+          wxCommandEvent ev(wxEVT_BUTTON, MoGUI::ID_BUTTON_MO_COMPUTE);
+          ev.SetEventObject(mo->FindWindow(MoGUI::ID_BUTTON_MO_COMPUTE));
+          mo->GetEventHandler()->ProcessEvent(ev);
+        });
+      });
       if (!ready || !run.run(script)) {
         string msg = ready ? run.message() : "molecule never loaded";
         fprintf(stderr, "ECCE_VIEWER_SCENE: %s\n", msg.c_str());
 
@@ -55,6 +55,8 @@
 
 #ident "$Revision: 22147 $"
 
+#include <cstdio>
+#include <cstdlib>
 #include "inv/actions/SoCallbackAction.H"
 #include "inv/actions/SoGetBoundingBoxAction.H"
 #include "inv/actions/SoGetMatrixAction.H"
@@ -485,4 +487,10 @@ RESET_TIMER();
 
     isoLibIso(threshold.getValue());
 MARK_TIME("DONE with ISO");
+    //  ECCE_DEBUG_ISO: every surface actually generated, with its cutoff.
+    static const bool isoDebug = getenv("ECCE_DEBUG_ISO") != 0;
+    if (isoDebug) {
+        fprintf(stderr, "ISO: ChemIso %p generated at threshold %g, %d vertices\n",
+                (void *)this, threshold.getValue(), vp->vertex.getNum());
+    }
 }
@@ -21,6 +21,13 @@
 #include "inv/misc/SoChildList.H"
 #include "inv/nodes/SoSeparator.H"
 #include "inv/ChemKit/ChemIso.H"
+#include "inv/ChemKit/ChemDetail.H"
+#include "inv/actions/SoCallbackAction.H"
+#include "inv/actions/SoRayPickAction.H"
+#include "inv/SoPickedPoint.H"
+#include "inv/SoPrimitiveVertex.H"
+#include "inv/nodes/SoShape.H"
+#include "viz/VRVector.H"
 #include "inv/misc/SoChildList.H"
 
 #include "dsm/ICalculation.H"
@@ -524,6 +531,10 @@ bool SceneScript::exec(const vector<string>& w, const string& rest)
     return snapshot(w[1], 480, 0.2f, 0.3f, 0.4f);
   } else if (c == "thumb" && w.size() == 2) {
     return snapshot(w[1], 64, 0.0f, 0.0f, 0.0f);
+  } else if (c == "nmcheck" && w.size() == 2) {
+    return nmCheck(w[1]);
+  } else if (p_ext) {
+    return p_ext(*this, w);
   } else {
     return fail("unknown command: " + c);
   }
@@ -867,3 +878,137 @@ bool SceneScript::snapshot(const string& name, int size, float r, float g,
   writePpm(p_outdir + "/" + name + ".ppm", size, size, rend->getBuffer());
   return true;
 }
+
+
+namespace {
+
+struct TipData { SbVec3f centre; float maxDist; };
+
+void arrowTriangle(void *d, SoCallbackAction *a, const SoPrimitiveVertex *v1,
+                   const SoPrimitiveVertex *v2, const SoPrimitiveVertex *v3)
+{
+  TipData *t = (TipData *)d;
+  const SoPrimitiveVertex *v[3] = {v1, v2, v3};
+  for (int i = 0; i < 3; i++) {
+    SbVec3f p;
+    a->getModelMatrix().multVecMatrix(v[i]->getPoint(), p);
+    float dist = (p - t->centre).length();
+    if (dist > t->maxDist) t->maxDist = dist;
+  }
+}
+
+}  // namespace
+
+//  Two measurements from the scene as drawn, neither from NModeVectCmd's
+//  arithmetic: how far the arrow's geometry reaches from the atom centre,
+//  and where a ray along the arrow meets that atom's sphere.
+bool SceneScript::nmCheck(const string& name)
+{
+  SGFragment *frag = p_sg->getFragment();
+  SoWxRenderArea *area = findRenderArea(p_viewer);
+  if (!frag || !area) return fail("nmcheck: no fragment or render area");
+  SbViewportRegion vpr(SbVec2s(480, 480));
+  SoSearchAction sa;
+  sa.setType(VRVector::getClassTypeId(), FALSE);
+  sa.setInterest(SoSearchAction::ALL);
+  sa.apply(p_sg->getNMVecRoot());
+  FILE *o = fopen((p_outdir + "/" + name + ".txt").c_str(), "w");
+  if (!o) return fail("nmcheck: cannot write");
+  fprintf(o, "# atom elem |d|_A tip_A sphere_A tip_minus_sphere_A verdict\n");
+  for (int k = 0; k < sa.getPaths().getLength(); k++) {
+    VRVector *vec = (VRVector *)sa.getPaths()[k]->getTail();
+    const double *pos = frag->atomRef(k)->coordinates(), *dir = vec->getDirection();
+    SbVec3f c((float)pos[0], (float)pos[1], (float)pos[2]);
+    SbVec3f u((float)dir[0], (float)dir[1], (float)dir[2]);
+    float dlen = u.length();
+    TipData td = {c, 0.0f};
+    SoCallbackAction ca;
+    ca.addTriangleCallback(SoShape::getClassTypeId(), arrowTriangle, &td);
+    ca.apply(vec);
+    float sphere = -1.0f;
+    if (dlen > 0.0f) {
+      u /= dlen;
+      const float L = 6.0f;
+      SoRayPickAction rp(vpr);
+      rp.setRay(c + u * L, -u, 0.0f, L);
+      rp.setPickAll(TRUE);
+      rp.apply(p_viewer->getTopNode());
+      const SoPickedPointList& pl = rp.getPickedPointList();
+      for (int i = 0; i < pl.getLength(); i++) {
+        const ChemDetail *cd = dynamic_cast<const ChemDetail *>(pl[i]->getDetail());
+        if (!cd) continue;
+        int32_t ai = -1, bi = -1;
+        cd->getAtomBondIndex(ai, bi);
+        if (ai != k || bi >= 0) continue;
+        float r = (pl[i]->getPoint() - c).length();
+        if (r > sphere) sphere = r;
+      }
+    }
+    const char *verdict = sphere < 0.0f ? "no-sphere-hit"
+                        : (td.maxDist <= sphere ? "INSIDE" : "outside");
+    fprintf(o, "%d %s %.4f %.4f %.4f %.4f %s\n", k + 1,
+            frag->atomRef(k)->atomicSymbol().c_str(), dlen, td.maxDist, sphere,
+            td.maxDist - sphere, verdict);
+  }
+  fclose(o);
+  return true;
+}
+
+namespace {
+
+struct FrameLog {
+  SGContainer *sg;
+  string prefix;
+  FILE *log;
+  int n;
+  wxStopWatch clock;
+};
+
+void logFrame(void *d)
+{
+  FrameLog *f = (FrameLog *)d;
+  GLint vp[4];
+  glGetIntegerv(GL_VIEWPORT, vp);
+  vector<unsigned char> px((size_t)vp[2] * vp[3] * 3);
+  glFinish();
+  glPixelStorei(GL_PACK_ALIGNMENT, 1);
+  glReadPixels(vp[0], vp[1], vp[2], vp[3], GL_RGB, GL_UNSIGNED_BYTE, &px[0]);
+  char buf[32];
+  snprintf(buf, sizeof buf, "-%02d.ppm", f->n);
+  writePpm(f->prefix + buf, vp[2], vp[3], &px[0]);
+  //  The thresholds the drawn isosurfaces carry at this frame, read from
+  //  the scene graph, not from whoever set them.
+  SoSearchAction sa;
+  sa.setType(ChemIso::getClassTypeId(), FALSE);
+  sa.setInterest(SoSearchAction::ALL);
+  sa.apply(f->sg->getMORoot());
+  fprintf(f->log, "frame %02d t=%ldms %dx%d isosurfaces %d thresholds", f->n,
+          f->clock.Time(), vp[2], vp[3], sa.getPaths().getLength());
+  for (int k = 0; k < sa.getPaths().getLength(); k++)
+    fprintf(f->log, " %.6g", ((ChemIso *)sa.getPaths()[k]->getTail())->threshold.getValue());
+  fprintf(f->log, "\n");
+  fflush(f->log);
+  f->n++;
+}
+
+}  // namespace
+
+bool SceneScript::recordFrames(wxWindow *canvasOwner, const string& name,
+                               std::function<void()> act)
+{
+  SoWxRenderArea *area = findRenderArea(canvasOwner);
+  if (!area) return fail("recordframes: no render area");
+  FrameLog f;
+  f.sg = p_sg;
+  f.prefix = p_outdir + "/" + name;
+  f.log = fopen((f.prefix + "-frames.txt").c_str(), "w");
+  if (!f.log) return fail("recordframes: cannot write");
+  f.n = 0;
+  area->setFrameCallback(logFrame, &f);
+  act();
+  //  Let any deferred redraw land too (1 s of event loop).
+  for (int i = 0; i < 100; i++) { wxTheApp->Yield(true); wxMilliSleep(10); }
+  area->setFrameCallback(0, 0);
+  fclose(f.log);
+  return true;
+}
@@ -0,0 +1,4 @@
+# #226: press the MO panel's Compute (default selection, the HOMO) and record
+# every frame the Builder's canvas paints, with the isosurface thresholds in
+# the scene at that frame (mo-compute-frames.txt).
+mopanel mo-compute
@@ -0,0 +1,18 @@
+# #228: normal-mode arrows against their atoms' spheres, calc-water-vib.
+# Modes are 0-based: 0 bend 1645, 1 sym. stretch 3866, 2 asym. stretch 3965.
+# nmcheck writes, per atom, the arrow tip's distance from the atom centre and
+# where a ray along the arrow meets the atom's sphere.
+viewall
+nmvect 1
+nmcheck nm1-default
+snap nm1-default
+nmvect 2
+nmcheck nm2-default
+snap nm2-default
+style Ball And Stick
+nmvect 1
+nmcheck nm1-ballstick
+snap nm1-ballstick
+nmvect 2
+nmcheck nm2-ballstick
+snap nm2-ballstick