Examples with MSNode ffx.potential.bonded.MSNode used on opensource projects

Example 1 with MSNode

use of ffx.potential.bonded.MSNode in project ffx by mjschnie.

the class GraphicsCanvas method postRender.

/**
 * {@inheritDoc}
 *
 * Labels are drawn in postRender.
 */
@Override
public void postRender() {
    if (RendererCache.labelAtoms || RendererCache.labelResidues) {
        J3DGraphics2D g2D = getGraphics2D();
        synchronized (mainPanel.getHierarchy()) {
            ArrayList<MSNode> nodes = mainPanel.getHierarchy().getActiveNodes();
            if (nodes != null && nodes.size() > 0) {
                for (MSNode node : nodes) {
                    MolecularAssembly sys = (MolecularAssembly) node.getMSNode(MolecularAssembly.class);
                    if (sys != null) {
                        node.drawLabel(this, g2D, sys.getWireFrame());
                    }
                }
            } else {
                return;
            }
        }
        g2D.flush(true);
    }
}

Example 2 with MSNode

use of ffx.potential.bonded.MSNode in project ffx by mjschnie.

the class GraphicsCanvas method rotateAboutPick.

/**
 * <p>
 * rotateAboutPick</p>
 */
public void rotateAboutPick() {
    MSNode node = rendererPicking.getPick();
    if (node != null) {
        double[] center = node.getCenter(false);
        MolecularAssembly m = (MolecularAssembly) node.getMSNode(MolecularAssembly.class);
        m.rotateAbout(new Vector3d(center));
    }
}

Example 3 with MSNode

use of ffx.potential.bonded.MSNode in project ffx by mjschnie.

the class GraphicsCanvas method setColorModel.

/**
 * **********************************************************************
 */
// Color Commands
/**
 * Operates on the Active nodes.
 *
 * @param model String
 */
public void setColorModel(String model) {
    if (!RendererCache.colorModelHash.containsKey(model.toUpperCase())) {
        return;
    }
    RendererCache.ColorModel colorModel = RendererCache.colorModelHash.get(model.toUpperCase());
    ArrayList<MSNode> active = mainPanel.getHierarchy().getActiveNodes();
    if (active == null) {
        return;
    }
    renderer.arm(active, false, false, null, true, colorModel);
}

Example 4 with MSNode

use of ffx.potential.bonded.MSNode in project ffx by mjschnie.

the class GraphicsCanvas method setViewModel.

/**
 * Operates on the active nodes.
 *
 * @param model String
 */
public void setViewModel(String model) {
    if (!RendererCache.viewModelHash.containsKey(model.toUpperCase())) {
        return;
    }
    RendererCache.ViewModel viewModel = RendererCache.viewModelHash.get(model.toUpperCase());
    if (viewModel == RendererCache.ViewModel.RESTRICT) {
        renderer.arm(mainPanel.getDataRoot(), false, true, viewModel, false, null);
        return;
    }
    ArrayList<MSNode> active = mainPanel.getHierarchy().getActiveNodes();
    if (active == null) {
        return;
    }
    renderer.arm(active, false, true, viewModel, false, null);
}

Example 5 with MSNode

use of ffx.potential.bonded.MSNode in project ffx by mjschnie.

the class GraphicsPicking method updateScene.

/**
 * {@inheritDoc}
 *
 * Called by Java3D when an atom is picked
 */
public void updateScene(int xpos, int ypos) {
    if (picking == false) {
        return;
    }
    // Determine what FNode was picked
    pickCanvas.setShapeLocation(xpos, ypos);
    PickResult result = pickCanvas.pickClosest();
    if (result != null) {
        SceneGraphPath sceneGraphPath = result.getSceneGraphPath();
        Node node = sceneGraphPath.getObject();
        if (!(node instanceof Shape3D)) {
            return;
        }
        Shape3D pickedShape3D = (Shape3D) node;
        Object userData = pickedShape3D.getUserData();
        if (userData instanceof MolecularAssembly) {
            FFXSystem sys = (FFXSystem) userData;
            if (result.numIntersections() > 0) {
                PickIntersection pickIntersection = result.getIntersection(0);
                int[] coords = pickIntersection.getPrimitiveCoordinateIndices();
                userData = sys.getAtomFromWireVertex(coords[0]);
            } else {
                return;
            }
        }
        if (userData instanceof Atom) {
            Atom a = (Atom) userData;
            // Check to see if the pickLevel has changed
            if (!(pickLevel == newPickLevel)) {
                pickLevel = newPickLevel;
                pickNumber = 0;
            }
            // Clear selections between measurements
            String pickLevelString = pickLevel.toString();
            boolean measure = pickLevelString.startsWith("MEASURE");
            if (!measure || count == 0) {
                for (Atom matom : atomCache) {
                    matom.setSelected(false);
                    matom.setColor(RendererCache.ColorModel.SELECT, null, null);
                }
                atomCache.clear();
                count = 0;
            }
            // If measuring, select the current atom and add it to the cache
            if (measure && !atomCache.contains(a)) {
                atomCache.add(0, a);
                a.setSelected(true);
                a.setColor(RendererCache.ColorModel.PICK, null, null);
                count++;
                measure();
            }
            if (!measure) {
                // This allows iteration through the atom's terms
                if (a == previousAtom) {
                    pickNumber++;
                } else {
                    previousAtom = a;
                    pickNumber = 0;
                }
                MSNode currentPick = null;
                switch(pickLevel) {
                    case PICKATOM:
                        currentPick = a;
                        break;
                    case PICKBOND:
                    case PICKANGLE:
                    case PICKDIHEDRAL:
                        ArrayList terms = null;
                        if (pickLevel == PickLevel.PICKBOND) {
                            terms = a.getBonds();
                        } else if (pickLevel == PickLevel.PICKANGLE) {
                            terms = a.getAngles();
                        } else if (pickLevel == PickLevel.PICKDIHEDRAL) {
                            terms = a.getTorsions();
                        }
                        if (terms == null) {
                            return;
                        }
                        int num = terms.size();
                        if (pickNumber >= num) {
                            pickNumber = 0;
                        }
                        currentPick = (BondedTerm) terms.get(pickNumber);
                        break;
                    case PICKRESIDUE:
                    case PICKPOLYMER:
                    case PICKMOLECULE:
                    case PICKSYSTEM:
                        MSNode dataNode = null;
                        if (pickLevel == PickLevel.PICKRESIDUE) {
                            dataNode = (MSNode) a.getMSNode(Residue.class);
                        } else if (pickLevel == PickLevel.PICKPOLYMER) {
                            dataNode = (MSNode) a.getMSNode(Polymer.class);
                        } else if (pickLevel == PickLevel.PICKSYSTEM) {
                            dataNode = (MSNode) a.getMSNode(MolecularAssembly.class);
                        } else if (pickLevel == PickLevel.PICKMOLECULE) {
                            dataNode = (MSNode) a.getMSNode(Molecule.class);
                            if (dataNode == null) {
                                dataNode = (MSNode) a.getMSNode(Polymer.class);
                            }
                        }
                        currentPick = dataNode;
                        break;
                    case MEASUREANGLE:
                    case MEASUREDIHEDRAL:
                    case MEASUREDISTANCE:
                        break;
                }
                // Add the selected node to the Tree View
                if (currentPick != null) {
                    if (controlButton) {
                        mainPanel.getHierarchy().toggleSelection(currentPick);
                    } else if (currentPick != previousPick) {
                        mainPanel.getHierarchy().onlySelection(currentPick);
                    }
                    // Color the Current Pick by Picking Color
                    mainPanel.getGraphics3D().updateScene(currentPick, false, false, null, true, RendererCache.ColorModel.PICK);
                }
                // Remove picking color from the previousPick
                if (previousPick != null && previousPick != currentPick) {
                    previousPick.setColor(RendererCache.ColorModel.REVERT, null, null);
                }
                previousPick = currentPick;
            }
        }
    }
}