From: <ha...@us...> - 2010-09-16 11:41:05
|
Revision: 14310 http://jmol.svn.sourceforge.net/jmol/?rev=14310&view=rev Author: hansonr Date: 2010-09-16 11:40:57 +0000 (Thu, 16 Sep 2010) Log Message: ----------- version=12.0.13_dev # two new features added retroactively: # new feature: set multipleBondRadiusFactor 0.75 # new feature: multipleBondSpacing # set multipleBondSpacing = -1 (default, varies with viewing angle) # set multipleBondSpacing = -0.5 (half that distance; varies with viewing angle) # set multipleBondSpacing = 0.35 (positive ==> fixed multiple bond spacing) # bug fix: isosurface map MEP not as accurate as could be Modified Paths: -------------- branches/v12_0/Jmol/src/org/jmol/adapter/smarter/AtomSetCollection.java branches/v12_0/Jmol/src/org/jmol/adapter/smarter/SmarterJmolAdapter.java branches/v12_0/Jmol/src/org/jmol/api/MepCalculationInterface.java branches/v12_0/Jmol/src/org/jmol/applet/AppletConsole.java branches/v12_0/Jmol/src/org/jmol/jvxl/calc/MarchingCubes.java branches/v12_0/Jmol/src/org/jmol/jvxl/data/JvxlCoder.java branches/v12_0/Jmol/src/org/jmol/jvxl/readers/AtomPropertyMapper.java branches/v12_0/Jmol/src/org/jmol/jvxl/readers/JvxlXmlReader.java branches/v12_0/Jmol/src/org/jmol/jvxl/readers/Parameters.java branches/v12_0/Jmol/src/org/jmol/jvxl/readers/SurfaceGenerator.java branches/v12_0/Jmol/src/org/jmol/modelset/ModelLoader.java branches/v12_0/Jmol/src/org/jmol/quantum/MepCalculation.java branches/v12_0/Jmol/src/org/jmol/script/ScriptEvaluator.java branches/v12_0/Jmol/src/org/jmol/script/Token.java branches/v12_0/Jmol/src/org/jmol/shape/SticksRenderer.java branches/v12_0/Jmol/src/org/jmol/shapesurface/Isosurface.java branches/v12_0/Jmol/src/org/jmol/util/ColorEncoder.java branches/v12_0/Jmol/src/org/jmol/viewer/Jmol.properties branches/v12_0/Jmol/src/org/jmol/viewer/StateManager.java branches/v12_0/Jmol/src/org/jmol/viewer/Viewer.java branches/v12_0/Jmol/src/org/openscience/jmol/app/jmolpanel/AppConsole.java Modified: branches/v12_0/Jmol/src/org/jmol/adapter/smarter/AtomSetCollection.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/adapter/smarter/AtomSetCollection.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/adapter/smarter/AtomSetCollection.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -197,6 +197,10 @@ private void appendAtomSetCollection(Vector list) { int n = list.size(); + if (n == 0) { + errorMessage = "No file found!"; + return; + } for (int i = 0; i < n; i++) { Object o = list.elementAt(i); if (o instanceof Vector) Modified: branches/v12_0/Jmol/src/org/jmol/adapter/smarter/SmarterJmolAdapter.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/adapter/smarter/SmarterJmolAdapter.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/adapter/smarter/SmarterJmolAdapter.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -344,13 +344,13 @@ && (selectedFile <= 0 || vCollections.size() < selectedFile)) { if (ze.isDirectory()) continue; - byte[] bytes = ZipUtil.getZipEntryAsBytes(zis); String thisEntry = ze.getName(); if (subFileName != null && !thisEntry.equals(subFileName)) continue; if (ZipUtil.isJmolManifest(thisEntry) || haveManifest && exceptFiles == manifest.indexOf("|" + thisEntry + "|") >= 0) continue; + byte[] bytes = ZipUtil.getZipEntryAsBytes(zis); if (ZipUtil.isZipFile(bytes)) { BufferedInputStream bis = new BufferedInputStream( new ByteArrayInputStream(bytes)); Modified: branches/v12_0/Jmol/src/org/jmol/api/MepCalculationInterface.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/api/MepCalculationInterface.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/api/MepCalculationInterface.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -14,4 +14,6 @@ public abstract void assignPotentials(Atom[] atoms, float[] potentials, BitSet bsAromatic, BitSet bsCarbonyl, BitSet bsIgnore, String data); + public abstract float valueFor(float x, float d2, int distanceMode); + } Modified: branches/v12_0/Jmol/src/org/jmol/applet/AppletConsole.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/applet/AppletConsole.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/applet/AppletConsole.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -337,7 +337,8 @@ int kcode = ke.getKeyCode(); switch (ke.getID()) { case KeyEvent.KEY_PRESSED: - if (kcode == KeyEvent.VK_TAB) { + switch (kcode) { + case KeyEvent.VK_TAB: ke.consume(); if (input.getCaretPosition() == input.getText().length()) { String cmd = completeCommand(getText()); @@ -346,6 +347,11 @@ nTab++; return; } + break; + case KeyEvent.VK_ESCAPE: + ke.consume(); + setText(""); + break; } nTab = 0; if (kcode == KeyEvent.VK_ENTER && !ke.isControlDown()) { Modified: branches/v12_0/Jmol/src/org/jmol/jvxl/calc/MarchingCubes.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/jvxl/calc/MarchingCubes.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/jvxl/calc/MarchingCubes.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -544,8 +544,6 @@ protected void addEdgeData(float f) { char ch = JvxlCoder.jvxlFractionAsCharacter(f); - //if (edgeData.length() < 1000) - //System.out.print("" + ch + " " + f + " "); edgeData.append(ch); } Modified: branches/v12_0/Jmol/src/org/jmol/jvxl/data/JvxlCoder.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/jvxl/data/JvxlCoder.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/jvxl/data/JvxlCoder.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -506,6 +506,8 @@ float valueRed = jvxlData.valueMappedToRed; int vertexCount = (jvxlData.saveVertexCount > 0 ? jvxlData.saveVertexCount : jvxlData.vertexCount); + if(vertexCount >= vertexValues.length) + System.out.println("JVXLCODER ERROR"); float min = jvxlData.mappedDataMin; float max = jvxlData.mappedDataMax; StringBuffer list1 = new StringBuffer(); Modified: branches/v12_0/Jmol/src/org/jmol/jvxl/readers/AtomPropertyMapper.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/jvxl/readers/AtomPropertyMapper.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/jvxl/readers/AtomPropertyMapper.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -28,16 +28,23 @@ import org.jmol.util.Logger; import org.jmol.api.AtomIndexIterator; +import org.jmol.api.Interface; +import org.jmol.api.MepCalculationInterface; class AtomPropertyMapper extends AtomDataReader { - AtomPropertyMapper(SurfaceGenerator sg) { + private MepCalculationInterface m; + private String mepType; + private int calcType = 0; + AtomPropertyMapper(SurfaceGenerator sg, String mepType) { super(sg); + this.mepType = mepType; } //// maps property data //// private boolean doSmoothProperty; private AtomIndexIterator iter; + private float smoothingPower; protected void setup() { @@ -48,7 +55,24 @@ point = params.point; doSmoothProperty = params.propertySmoothing; doUseIterator = true; - maxDistance = 4; + if (doSmoothProperty) { + smoothingPower = 7; + if (smoothingPower < 0) + smoothingPower = 0; + else if (smoothingPower > 10) + smoothingPower = 10; + if (smoothingPower == 0) + doSmoothProperty = false; + smoothingPower = (smoothingPower - 11) / 2f; + // 0 to 10 becomes d^-10 to d^-1, and we'll be using distance^2 + } + maxDistance = Integer.MAX_VALUE; + if (mepType != null) { + doSmoothProperty = true; + if (params.mep_calcType >= 0) + calcType = params.mep_calcType; + m = (MepCalculationInterface) Interface.getOptionInterface("quantum." + mepType + "Calculation"); + } getAtoms(Float.NaN, false, doSmoothProperty); setHeader("property", params.calculationType); // for plane mapping @@ -80,9 +104,9 @@ } public float getValueAtPoint(Point3f pt) { - float value = (doSmoothProperty ? 0 : Float.NaN); float dmin = Float.MAX_VALUE; float dminNearby = Float.MAX_VALUE; + float value = (doSmoothProperty ? 0 : Float.NaN); float vdiv = 0; atomDataServer.setIteratorForPoint(iter, modelIndex, pt, maxDistance); while (iter.hasNext()) { @@ -92,24 +116,25 @@ float p = atomProp[iAtom]; if (Float.isNaN(p)) continue; - float d = pt.distance(ptA); + float d2 = pt.distanceSquared(ptA); if (isNearby) { - if (d < dminNearby) - dminNearby = d; - } else if (d < dmin) { - dmin = d; + if (d2 < dminNearby) + dminNearby = d2; + } else if (d2 < dmin) { + dmin = d2; if (!doSmoothProperty) value = p; } - if (doSmoothProperty) { // fourth-power smoothing - d = 1 / d; - d *= d; - d *= d; - vdiv += d; - value += d * p; + if (m != null) { + value += m.valueFor(p, d2, calcType); + } else if (doSmoothProperty) { + d2 = (float) Math.pow(d2, smoothingPower); + vdiv += d2; + value += d2 * p; } } - return (doSmoothProperty ? (vdiv == 0 || dminNearby < dmin ? Float.NaN : value / vdiv) : value); + //System.out.println(pt + " " + value + " " + vdiv + " " + value / vdiv); + return (m != null ? value : doSmoothProperty ? (vdiv == 0 || dminNearby < dmin ? Float.NaN : value / vdiv) : value); } } Modified: branches/v12_0/Jmol/src/org/jmol/jvxl/readers/JvxlXmlReader.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/jvxl/readers/JvxlXmlReader.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/jvxl/readers/JvxlXmlReader.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -35,7 +35,6 @@ import org.jmol.jvxl.data.JvxlCoder; import org.jmol.jvxl.data.JvxlData; import org.jmol.shapesurface.IsosurfaceMesh; -import org.jmol.util.ColorEncoder; import org.jmol.util.Escape; import org.jmol.util.Logger; import org.jmol.util.Parser; @@ -382,10 +381,60 @@ valueB, pointA, edgeVector, fReturn, ptReturn); ptReturn.scaleAdd(fReturn[0] = jvxlGetNextFraction(edgeFractionBase, edgeFractionRange, 0.5f), edgeVector, pointA); - return fReturn[0]; + if (Float.isNaN(valueMin)) + setValueMinMax(); + if (includeValueNaN && Float.isNaN(fReturn[0])) + return Float.NaN; + return getNextValue(); } + private float getNextValue() { + float fraction = Float.NaN; + if (colorPtr >= valueCount) + System.out.println("JvxlXmlREader test 1243 " + colorPtr + " " + valueCount); + while (colorPtr < valueCount && Float.isNaN(fraction)) { + if (jvxlData.isJvxlPrecisionColor) { + // this COULD be an option for mapped surfaces; + // necessary for planes; used for vertex/triangle 2.0 style + // precision is used for FULL-data range encoding, allowing full + // treatment of JVXL files as though they were CUBE files. + // the two parts of the "double-character-precision" value + // are in separate lines, separated by n characters. + fraction = JvxlCoder.jvxlFractionFromCharacter2(jvxlColorDataRead + .charAt(colorPtr), jvxlColorDataRead.charAt((colorPtr++) + + valueCount), colorFractionBase, colorFractionRange); + } else { + // my original encoding scheme + // low precision only allows for mapping relative to the defined color range + fraction = JvxlCoder.jvxlFractionFromCharacter(jvxlColorDataRead + .charAt(colorPtr++), colorFractionBase, colorFractionRange, 0.5f); + } + break; + } + return valueMin + fraction * valueRange; + } + + private void setValueMinMax() { + valueCount = jvxlColorDataRead.length(); + if (jvxlData.isJvxlPrecisionColor) + valueCount /= 2; + includeValueNaN = (valueCount != jvxlEdgeDataRead.length()); + valueMin = (!jvxlData.isJvxlPrecisionColor ? params.valueMappedToRed + : params.mappedDataMin == Float.MAX_VALUE ? defaultMappedDataMin + : params.mappedDataMin); + valueRange = (!jvxlData.isJvxlPrecisionColor ? params.valueMappedToBlue + : params.mappedDataMin == Float.MAX_VALUE ? defaultMappedDataMax + : params.mappedDataMax) + - valueMin; + haveReadColorData = true; + } + + private boolean includeValueNaN = true; + private int valueCount; + private float valueMin = Float.NaN; + private float valueRange = Float.NaN; private int fractionPtr; + private int colorPtr; private String strFractionTemp = ""; private float jvxlGetNextFraction(int base, int range, float fracOffset) { @@ -400,82 +449,78 @@ base, range, fracOffset); } + boolean haveReadColorData; + protected String readColorData() { // overloads SurfaceReader // standard jvxl file read for color - fractionPtr = 0; int vertexCount = jvxlData.vertexCount = meshData.vertexCount; + // the problem is that the new way to read data in Marching Cubes + // is to ignore all points that are NaN. But then we also have to + // remove those points from the color string. + short[] colixes = meshData.vertexColixes; float[] vertexValues = meshData.vertexValues; - strFractionTemp = (isJvxl ? jvxlColorDataRead : ""); - if (isJvxl && strFractionTemp.length() == 0) { + /* + * haveReadColorData? + = (isJvxl ? jvxlColorDataRead : ""); + if (isJvxl && strValueTemp.length() == 0) { Logger .error("You cannot use JVXL data to map onto OTHER data, because it only contains the data for one surface. Use ISOSURFACE \"file.jvxl\" not ISOSURFACE .... MAP \"file.jvxl\"."); return ""; } + */ + //if (colorEncoder == null) + //colorEncoder = new ColorEncoder(null); colorEncoder.setColorScheme(null, false); - colorEncoder.setRange(params.valueMappedToRed, params.valueMappedToBlue, - params.isColorReversed); - fractionPtr = 0; - Logger.info("JVXL reading color data mapped min/max: " + params.mappedDataMin - + "/" + params.mappedDataMax + " for " + vertexCount + " vertices." - + " using encoding keys " + colorFractionBase + " " - + colorFractionRange); + colorEncoder.setRange(params.valueMappedToRed, + params.valueMappedToBlue, params.isColorReversed); + Logger.info("JVXL reading color data mapped min/max: " + + params.mappedDataMin + "/" + params.mappedDataMax + " for " + + vertexCount + " vertices." + " using encoding keys " + + colorFractionBase + " " + colorFractionRange); Logger.info("mapping red-->blue for " + params.valueMappedToRed + " to " + params.valueMappedToBlue + " colorPrecision:" + jvxlData.isJvxlPrecisionColor); - - float min = (params.mappedDataMin == Float.MAX_VALUE ? defaultMappedDataMin - : params.mappedDataMin); - float range = (params.mappedDataMin == Float.MAX_VALUE ? defaultMappedDataMax - : params.mappedDataMax) - - min; - float colorRange = params.valueMappedToBlue - params.valueMappedToRed; + boolean getValues = (Float.isNaN(valueMin)); + if (getValues) + setValueMinMax(); float contourPlaneMinimumValue = Float.MAX_VALUE; float contourPlaneMaximumValue = -Float.MAX_VALUE; if (colixes == null || colixes.length < vertexCount) meshData.vertexColixes = colixes = new short[vertexCount]; - String data = jvxlColorDataRead; //hasColorData = true; - int cpt = 0; short colixNeg = 0, colixPos = 0; if (params.colorBySign) { - colixPos = ColorEncoder - .getColorIndex(params.isColorReversed ? params.colorNeg - : params.colorPos); - colixNeg = ColorEncoder - .getColorIndex(params.isColorReversed ? params.colorPos - : params.colorNeg); + colixPos = Graphics3D.getColix(params.isColorReversed ? params.colorNeg + : params.colorPos); + colixNeg = Graphics3D.getColix(params.isColorReversed ? params.colorPos + : params.colorNeg); } int vertexIncrement = meshData.vertexIncrement; - - for (int i = 0; i < vertexCount; i+= vertexIncrement) { - float fraction, value; - if (jvxlData.isJvxlPrecisionColor) { - // this COULD be an option for mapped surfaces; - // necessary for planes; used for vertex/triangle 2.0 style - // precision is used for FULL-data range encoding, allowing full - // treatment of JVXL files as though they were CUBE files. - // the two parts of the "double-character-precision" value - // are in separate lines, separated by n characters. - fraction = JvxlCoder.jvxlFractionFromCharacter2(data.charAt(cpt), data.charAt(cpt - + vertexCount), colorFractionBase, colorFractionRange); - value = min + fraction * range; - } else { - // my original encoding scheme - // low precision only allows for mapping relative to the defined color range - fraction = JvxlCoder.jvxlFractionFromCharacter(data.charAt(cpt), - colorFractionBase, colorFractionRange, 0.5f); - value = params.valueMappedToRed + fraction * colorRange; + // here's the problem: we are assuming here that vertexCount == nPointsRead + boolean needContourMinMax = (params.mappedDataMin == Float.MAX_VALUE); + for (int i = 0; i < vertexCount; i += vertexIncrement) { + float value; + if(getValues) + value = vertexValues[i] = getNextValue(); + else + value = vertexValues[i]; + if (needContourMinMax) { + if (value < contourPlaneMinimumValue) + contourPlaneMinimumValue = value; + if (value > contourPlaneMaximumValue) + contourPlaneMaximumValue = value; } - vertexValues[i] = value; - ++cpt; - if (value < contourPlaneMinimumValue) - contourPlaneMinimumValue = value; - if (value > contourPlaneMaximumValue) - contourPlaneMaximumValue = value; - + } + if (needContourMinMax) { + params.mappedDataMin = contourPlaneMinimumValue; + params.mappedDataMax = contourPlaneMaximumValue; + } + + for (int i = 0; i < vertexCount; i += vertexIncrement) { + float value = vertexValues[i]; //note: these are just default colorings //orbital color had a bug through 11.2.6/11.3.6 if (marchingSquares != null && params.isContoured) { @@ -487,11 +532,7 @@ colixes[i] = colorEncoder.getColorIndex(value); } } - if (params.mappedDataMin == Float.MAX_VALUE) { - params.mappedDataMin = contourPlaneMinimumValue; - params.mappedDataMax = contourPlaneMaximumValue; - } - return data + "\n"; + return jvxlColorDataRead + "\n"; } /** Modified: branches/v12_0/Jmol/src/org/jmol/jvxl/readers/Parameters.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/jvxl/readers/Parameters.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/jvxl/readers/Parameters.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -229,6 +229,7 @@ contourColixes = null; mep_calcType = -1; pocket = null; + propertySmoothing = false; rangeDefined = false; resolution = Float.MAX_VALUE; scale = Float.NaN; Modified: branches/v12_0/Jmol/src/org/jmol/jvxl/readers/SurfaceGenerator.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/jvxl/readers/SurfaceGenerator.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/jvxl/readers/SurfaceGenerator.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -968,7 +968,7 @@ surfaceReader = new IsoPlaneReader(this); break; case Parameters.SURFACE_PROPERTY: - surfaceReader = new AtomPropertyMapper(this); + surfaceReader = new AtomPropertyMapper(this, null); break; case Parameters.SURFACE_SOLVENT: case Parameters.SURFACE_MOLECULAR: @@ -985,10 +985,16 @@ surfaceReader = new IsoFxyzReader(this); break; case Parameters.SURFACE_MEP: - surfaceReader = new IsoMepReader(this); + if (params.state == Parameters.STATE_DATA_COLORED) + surfaceReader = new AtomPropertyMapper(this, "Mep"); + else + surfaceReader = new IsoMepReader(this); break; case Parameters.SURFACE_MLP: - surfaceReader = new IsoMlpReader(this); + if (params.state == Parameters.STATE_DATA_COLORED) + surfaceReader = new AtomPropertyMapper(this, "Mlp"); + else + surfaceReader = new IsoMlpReader(this); break; } return true; Modified: branches/v12_0/Jmol/src/org/jmol/modelset/ModelLoader.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/modelset/ModelLoader.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/modelset/ModelLoader.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -646,7 +646,7 @@ models[iLast].firstAtomIndex = i; int vdwtype = getDefaultVdwType(iLast); if (vdwtype != vdwtypeLast) { - Logger.info("Default Van der Waal type for model" + " set to " + JmolConstants.getVdwLabel(vdwtype)); + Logger.info("Default Van der Waals type for model" + " set to " + JmolConstants.getVdwLabel(vdwtype)); vdwtypeLast = vdwtype; } } Modified: branches/v12_0/Jmol/src/org/jmol/quantum/MepCalculation.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/quantum/MepCalculation.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/quantum/MepCalculation.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -86,6 +86,9 @@ protected final static int E_MINUS_D = 3; protected int distanceMode = ONE_OVER_D; + private float[] potentials; + private Point3f[] atomCoordAngstroms; + private BitSet bsSelected; public MepCalculation() { rangeBohrOrAngstroms = 8; // Angstroms @@ -112,20 +115,39 @@ } } + public void setup(int calcType, float[] potentials, + Point3f[] atomCoordAngstroms, BitSet bsSelected) { + if (calcType >= 0) + distanceMode = calcType; + this.potentials = potentials; + this.atomCoordAngstroms = atomCoordAngstroms; + this.bsSelected = bsSelected; + } + public void calculate(VolumeDataInterface volumeData, BitSet bsSelected, Point3f[] atomCoordAngstroms, float[] potentials, int calcType) { - if (calcType >= 0) - distanceMode = calcType; + setup(calcType, potentials, atomCoordAngstroms, bsSelected); voxelData = volumeData.getVoxelData(); int[] countsXYZ = volumeData.getVoxelCounts(); initialize(countsXYZ[0], countsXYZ[1], countsXYZ[2]); setupCoordinates(volumeData.getOriginFloat(), volumeData .getVolumetricVectorLengths(), bsSelected, atomCoordAngstroms); - processMep(potentials); + processMep(); } + + public float getValueAtPoint(Point3f pt) { + float value = 0; + for (int i = bsSelected.nextSetBit(0); i >= 0; i = bsSelected + .nextSetBit(i + 1)) { + float x = potentials[i]; + float d2 = pt.distanceSquared(atomCoordAngstroms[i]); + value += valueFor(x, d2, distanceMode); + } + return value; + } - private void processMep(float[] potentials) { + private void processMep() { for (int atomIndex = qmAtoms.length; --atomIndex >= 0;) { if ((thisAtom = qmAtoms[atomIndex]) == null) continue; @@ -138,28 +160,7 @@ for (int iy = yMax; --iy >= yMin;) { float dXY = dX + Y2[iy]; for (int iz = zMax; --iz >= zMin;) { - float d2 = dXY + Z2[iz]; - float x = x0; - switch (distanceMode) { - case ONE_OVER_D: - if (d2 == 0) - x *= Float.POSITIVE_INFINITY; - else - x /= (float) Math.sqrt(d2); - break; - case ONE_OVER_ONE_PLUS_D: - x /= (1 + (float) Math.sqrt(d2)); - break; - case E_MINUS_D_OVER_2: - x *= (float) Math.exp(-Math.sqrt(d2) / 2); - break; - case E_MINUS_D: - x *= (float) Math.exp(-Math.sqrt(d2)); - break; - default: - x = 0; - } - voxelData[ix][iy][iz] += x; + voxelData[ix][iy][iz] += valueFor(x0, dXY + Z2[iz], distanceMode); } } } @@ -167,6 +168,20 @@ } + public float valueFor(float x0, float d2, int distanceMode) { + switch (distanceMode) { + case ONE_OVER_D: + return (d2 == 0 ? x0 * Float.POSITIVE_INFINITY : x0 / (float) Math.sqrt(d2)); + case ONE_OVER_ONE_PLUS_D: + return x0 / (1 + (float) Math.sqrt(d2)); + case E_MINUS_D_OVER_2: + return x0 * (float) Math.exp(-Math.sqrt(d2) / 2); + case E_MINUS_D: + return x0 * (float) Math.exp(-Math.sqrt(d2)); + } + return x0; + } + protected Hashtable htAtomicPotentials; protected float getTabulatedPotential(Atom atom) { Modified: branches/v12_0/Jmol/src/org/jmol/script/ScriptEvaluator.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/script/ScriptEvaluator.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/script/ScriptEvaluator.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -10400,7 +10400,7 @@ case Token.jmol: value = 1; type = RadiusData.TYPE_FACTOR; - --index; + iToken = index - 1; break; case Token.plus: case Token.decimal: @@ -13284,7 +13284,7 @@ if (token != null) tok = token.tok; } - if (tok != Token.symop) + if (tok != Token.symop && tok != Token.state) checkLength(-3); if (statementLength == 2 && str.indexOf("?") >= 0) { showString(viewer.getAllSettings(str.substring(0, str.indexOf("?")))); @@ -13489,6 +13489,19 @@ break; } name = parameterAsString(2); + if (name.equals("/") && (len = statementLength) == 4) { + name = parameterAsString(3); + if (!isSyntaxCheck) { + String[] info = TextFormat.split(viewer.getStateInfo(), '\n'); + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < info.length; i++) + if (info[i].indexOf(name) >= 0) + sb.append(info[i]).append('\n'); + msg = sb.toString(); + } + break; + } + name = parameterAsString(2); if (!isSyntaxCheck) msg = viewer.getSavedState(name); break; @@ -14939,16 +14952,7 @@ error(ERROR_invalidArgument); boolean isVariable = (theTok == Token.variable); if (dataUse == null) { // not mlp or mep - if (bsSelect == null) { - bsSelect = viewer.getSelectionSet(false); - bsSelect.and(viewer.getModelUndeletedAtomsBitSet(modelIndex)); - addShapeProperty(propertyList, "select", bsSelect); - } - if (surfaceObjectSeen) { - // not for overall surface, just this mapping - sbCommand.append(" select " + Escape.escape(bsSelect)); - bsSelect = null; - } else { + if (!surfaceObjectSeen) { surfaceObjectSeen = true; addShapeProperty(propertyList, "sasurface", new Float(0)); sbCommand.append(" vdw"); @@ -15022,11 +15026,13 @@ propertyValue = new Integer(modelIndex); break; case Token.select: - bsSelect = atomExpression(++i); propertyName = "select"; - propertyValue = bsSelect; + propertyValue = atomExpression(++i); i = iToken; - // don't set sbCommand here because at finalize we will do that + if (surfaceObjectSeen) + sbCommand.append(" select " + Escape.escape(propertyValue)); + else + bsSelect = (BitSet) propertyValue; break; case Token.set: thisSetNumber = intParameter(++i); @@ -15656,11 +15662,6 @@ if (modelIndex < 0) error(ERROR_multipleModelsDisplayedNotOK, "ISOSURFACE " + theToken.value); - if (bsSelect == null) { - bsSelect = viewer.getSelectionSet(false); - bsSelect.and(viewer.getModelUndeletedAtomsBitSet(modelIndex)); - addShapeProperty(propertyList, "select", bsSelect); - } surfaceObjectSeen = true; float radius; if (theTok == Token.molecular) { @@ -15934,8 +15935,9 @@ if (surfaceObjectSeen && !isLcaoCartoon && !isSyntaxCheck) { if (bsSelect == null) bsSelect = viewer.getSelectionSet(false); - setShapeProperty(iShape, "finalize", " select " + Escape.escape(bsSelect) - + sbCommand.toString()); + bsSelect.and(viewer.getModelUndeletedAtomsBitSet(modelIndex)); + setShapeProperty(iShape, "finalize", " select " + Escape.escape(bsSelect) + " " + + sbCommand); String s = (String) getShapeProperty(iShape, "ID"); if (s != null) { cutoff = ((Float) getShapeProperty(iShape, "cutoff")).floatValue(); Modified: branches/v12_0/Jmol/src/org/jmol/script/Token.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/script/Token.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/script/Token.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -813,8 +813,10 @@ public final static int minimizationcriterion = floatparam | 21; public final static int mousedragfactor = floatparam | 22; public final static int mousewheelfactor = floatparam | 23; - public final static int navfps = floatparam | 24; - public final static int navigationdepth = floatparam | 26; + public final static int multiplebondradiusfactor = floatparam | 24; + public final static int multiplebondspacing = floatparam | 25; + public final static int navfps = floatparam | 26; + public final static int navigationdepth = floatparam | 27; public final static int navigationslab = floatparam | 28; public final static int navigationspeed = floatparam | 30; public final static int navx = floatparam | 32; @@ -2201,6 +2203,8 @@ "minimizationSilent", new Token(minimizationsilent), "modelkitMode", new Token(modelkitmode), "monitorEnergy", new Token(monitorenergy), + "multipleBondRadiusFactor", new Token(multiplebondradiusfactor), + "multipleBondSpacing", new Token(multiplebondspacing), "multiProcessor", new Token(multiprocessor), "navigateSurface", new Token(navigatesurface), "navigationMode", new Token(navigationmode), Modified: branches/v12_0/Jmol/src/org/jmol/shape/SticksRenderer.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/shape/SticksRenderer.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/shape/SticksRenderer.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -25,6 +25,10 @@ package org.jmol.shape; +import javax.vecmath.Point3f; +import javax.vecmath.Point3i; +import javax.vecmath.Vector3f; + import org.jmol.api.JmolEdge; import org.jmol.g3d.*; import org.jmol.modelset.Atom; @@ -33,36 +37,49 @@ public class SticksRenderer extends ShapeRenderer { - protected boolean showMultipleBonds; - protected byte modeMultipleBond; + private boolean showMultipleBonds; + private float multipleBondSpacing; + private float multipleBondRadiusFactor; + private byte modeMultipleBond; //boolean showHydrogens; - protected byte endcaps; + private byte endcaps; - protected boolean ssbondsBackbone; - protected boolean hbondsBackbone; - protected boolean bondsBackbone; - protected boolean hbondsSolid; + private boolean ssbondsBackbone; + private boolean hbondsBackbone; + private boolean bondsBackbone; + private boolean hbondsSolid; - protected Atom atomA, atomB; - protected Bond bond; - int xA, yA, zA; - int xB, yB, zB; - int dx, dy; - int mag2d; - protected short colixA, colixB; - protected int width; - protected int bondOrder; + private Atom atomA, atomB; + private Bond bond; + private int xA, yA, zA; + private int xB, yB, zB; + private int dx, dy; + private int mag2d; + private short colixA, colixB; + private int width; + private boolean lineBond; + private int bondOrder; private boolean renderWireframe; private boolean isAntialiased; private boolean slabbing; private boolean slabByAtom; - protected void render() { slabbing = viewer.getSlabEnabled(); slabByAtom = viewer.getSlabByAtom(); endcaps = Graphics3D.ENDCAPS_SPHERICAL; - showMultipleBonds = viewer.getShowMultipleBonds(); + multipleBondSpacing = viewer.getMultipleBondSpacing(); + multipleBondRadiusFactor = viewer.getMultipleBondRadiusFactor(); + if (multipleBondSpacing > 0) { + z = new Vector3f(); + x = new Vector3f(); + y = new Vector3f(); + p1 = new Point3f(); + p2 = new Point3f(); + s1 = new Point3i(); + s2 = new Point3i(); + } + showMultipleBonds = multipleBondSpacing != 0 && viewer.getShowMultipleBonds(); modeMultipleBond = viewer.getModeMultipleBond(); renderWireframe = viewer.getInMotion() && viewer.getWireframeRotation(); ssbondsBackbone = viewer.getSsbondsBackbone(); @@ -78,8 +95,7 @@ } } - protected void renderBond() { - mad = bond.getMad(); + private void renderBond() { atomA = bond.getAtom1(); atomB = bond.getAtom2(); int order = bond.getOrder() & ~JmolEdge.BOND_NEW; @@ -135,117 +151,155 @@ zB = atomB.screenZ; if (zA == 1 || zB == 1) return; - dx = xB - xA; - dy = yB - yA; - width = viewer.scaleToScreen((zA + zB) / 2, mad); - if (renderWireframe && width > 0) - width = 1; - lineBond = (width <= 1); - if (lineBond && (isAntialiased)) { - width = 3; - lineBond = false; + + // set the rendered bond order + + bondOrder = order & ~JmolEdge.BOND_NEW; + if ((bondOrder & JmolEdge.BOND_PARTIAL_MASK) == 0) { + if ((bondOrder & JmolEdge.BOND_SULFUR_MASK) != 0) + bondOrder &= ~JmolEdge.BOND_SULFUR_MASK; + if ((bondOrder & JmolEdge.BOND_COVALENT_MASK) != 0) { + if (!showMultipleBonds + || modeMultipleBond == JmolConstants.MULTIBOND_NEVER + || (modeMultipleBond == JmolConstants.MULTIBOND_NOTSMALL && mad > JmolConstants.madMultipleBondSmallMaximum)) { + bondOrder = 1; + } + } } - bondOrder = getRenderBondOrder(order); + + // set the mask + + int mask = 0; switch (bondOrder) { case 1: case 2: case 3: case 4: - drawBond(0); break; case JmolEdge.BOND_ORDER_UNSPECIFIED: case JmolEdge.BOND_AROMATIC_SINGLE: bondOrder = 1; - drawBond(order == JmolEdge.BOND_AROMATIC_SINGLE ? 0 : 1); + mask = (order == JmolEdge.BOND_AROMATIC_SINGLE ? 0 : 1); break; case JmolEdge.BOND_AROMATIC: case JmolEdge.BOND_AROMATIC_DOUBLE: bondOrder = 2; - drawBond(order == JmolEdge.BOND_AROMATIC ? getAromaticDottedBondMask() + mask = (order == JmolEdge.BOND_AROMATIC ? getAromaticDottedBondMask() : 0); break; - //case JmolConstants.BOND_STEREO_NEAR: - //case JmolConstants.BOND_STEREO_FAR: - //renderTriangle(bond); - //break; default: if ((bondOrder & JmolEdge.BOND_PARTIAL_MASK) != 0) { bondOrder = JmolConstants.getPartialBondOrder(order); - drawBond(JmolConstants.getPartialBondDotted(order)); + mask = JmolConstants.getPartialBondDotted(order); } else if ((bondOrder & JmolEdge.BOND_HYDROGEN_MASK) != 0) { - if (hbondsSolid) { - bondOrder = 1; - drawBond(0); - } else { - renderHbondDashed(); - } - break; + bondOrder = 1; + if (!hbondsSolid) + mask = -1; } else if (bondOrder == JmolEdge.BOND_STRUT) { bondOrder = 1; - drawBond(0); } } - } - int getRenderBondOrder(int order) { + // set the diameter - order &= ~JmolEdge.BOND_NEW; - if ((order & JmolEdge.BOND_PARTIAL_MASK) != 0) - return order; - if ((order & JmolEdge.BOND_SULFUR_MASK) != 0) - order &= ~JmolEdge.BOND_SULFUR_MASK; - if ((order & JmolEdge.BOND_COVALENT_MASK) != 0) { - if (!showMultipleBonds || - modeMultipleBond == JmolConstants.MULTIBOND_NEVER || - (modeMultipleBond == JmolConstants.MULTIBOND_NOTSMALL && - mad > JmolConstants.madMultipleBondSmallMaximum)) { - return 1; - } + mad = bond.getMad(); + if (multipleBondRadiusFactor > 0 && bondOrder > 1) + mad *= multipleBondRadiusFactor; + dx = xB - xA; + dy = yB - yA; + width = viewer.scaleToScreen((zA + zB) / 2, mad); + if (renderWireframe && width > 0) + width = 1; + lineBond = (width <= 1); + if (lineBond && (isAntialiased)) { + width = 3; + lineBond = false; } - return order; + + // draw the bond + + switch (mask) { + case -1: + renderHbondDashed(); + break; + default: + drawBond(mask); + break; + } } - - protected void drawBond(int dottedMask) { + + private Vector3f x, y, z; + private Point3f p1, p2; + private Point3i s1, s2; + + private void drawBond(int dottedMask) { if (exportType == Graphics3D.EXPORT_CARTESIAN && bondOrder == 1) { // bypass screen rendering and just use the atoms themselves g3d.drawBond(atomA, atomB, colixA, colixB, endcaps, mad); return; } - if (dx == 0 && dy == 0) { + boolean isEndOn = (dx == 0 && dy == 0); + if (isEndOn && lineBond) + return; + boolean doFixedSpacing = (bondOrder > 1 + && multipleBondSpacing > 0 + && (viewer.getHybridizationAndAxes(atomA.index, z, x, "pz") != null + || viewer.getHybridizationAndAxes(atomB.index, z, x, "pz") != null) + && !Float.isNaN(x.x)); + if (isEndOn && !doFixedSpacing) { // end-on view - if (! lineBond) { - int space = width / 8 + 3; - int step = width + space; - int y = yA - (bondOrder - 1) * step / 2; - do { - fillCylinder(colixA, colixA, endcaps, - width, xA, y, zA, xA, y, zA); - y += step; - } while (--bondOrder > 0); - } + int space = width / 8 + 3; + int step = width + space; + int y = yA - (bondOrder - 1) * step / 2; + do { + fillCylinder(colixA, colixA, endcaps, width, xA, y, zA, xA, y, zA); + y += step; + } while (--bondOrder > 0); return; } if (bondOrder == 1) { if ((dottedMask & 1) != 0) drawDashed(xA, yA, zA, xB, yB, zB); else - fillCylinder(colixA, colixB, endcaps, - width, xA, yA, zA, xB, yB, zB); + fillCylinder(colixA, colixB, endcaps, width, xA, yA, zA, xB, yB, zB); return; } + if (doFixedSpacing) { + x.sub(atomB, atomA); + y.cross(x, z); + y.normalize(); + y.scale(multipleBondSpacing); + x.set(y); + x.scale((bondOrder - 1) / 2f); + p1.sub(atomA, x); + p2.sub(atomB, x); + while (true) { + viewer.transformPoint(p1, s1); + viewer.transformPoint(p2, s2); + p1.add(y); + p2.add(y); + if ((dottedMask & 1) != 0) + drawDashed(s1.x, s1.y, s1.z, s2.x, s2.y, s2.z); + else + fillCylinder(colixA, colixB, endcaps, width, s1.x, s1.y, s1.z, s2.x, + s2.y, s2.z); + dottedMask >>= 1; + if (--bondOrder <= 0) + break; + stepAxisCoordinates(); + } + return; + } int dxB = dx * dx; int dyB = dy * dy; - int mag2d2 = dxB + dyB; - //if (bondOrder == 4) - //mag2d2 *= 4; - mag2d = (int)(Math.sqrt(mag2d2) + 0.5); + mag2d = (int) (Math.sqrt(dxB + dyB) + 0.5); resetAxisCoordinates(); while (true) { if ((dottedMask & 1) != 0) drawDashed(xAxis1, yAxis1, zA, xAxis2, yAxis2, zB); else - fillCylinder(colixA, colixB, endcaps, width, - xAxis1, yAxis1, zA, xAxis2, yAxis2, zB); + fillCylinder(colixA, colixB, endcaps, width, xAxis1, yAxis1, zA, + xAxis2, yAxis2, zB); dottedMask >>= 1; if (--bondOrder <= 0) break; @@ -253,127 +307,41 @@ } } - private boolean lineBond; + private int xAxis1, yAxis1, xAxis2, yAxis2, dxStep, dyStep; - int xAxis1, yAxis1, xAxis2, yAxis2, dxStep, dyStep; - - void resetAxisCoordinates() { + private void resetAxisCoordinates() { int space = mag2d >> 3; + if (multipleBondSpacing != -1 && multipleBondSpacing < 0) + space *= -multipleBondSpacing; int step = width + space; - dxStep = step * dy / mag2d; dyStep = step * -dx / mag2d; - - xAxis1 = xA; yAxis1 = yA; - xAxis2 = xB; yAxis2 = yB; - - if (bondOrder > 1) { - int f = (bondOrder - 1); - xAxis1 -= dxStep * f / 2; yAxis1 -= dyStep * f / 2; - xAxis2 -= dxStep * f / 2; yAxis2 -= dyStep * f / 2; - } + dxStep = step * dy / mag2d; + dyStep = step * -dx / mag2d; + xAxis1 = xA; + yAxis1 = yA; + xAxis2 = xB; + yAxis2 = yB; + int f = (bondOrder - 1); + xAxis1 -= dxStep * f / 2; + yAxis1 -= dyStep * f / 2; + xAxis2 -= dxStep * f / 2; + yAxis2 -= dyStep * f / 2; } - - void stepAxisCoordinates() { + private void stepAxisCoordinates() { xAxis1 += dxStep; yAxis1 += dyStep; xAxis2 += dxStep; yAxis2 += dyStep; } - /*private boolean isClipVisible(int xA, int yA, int xB, int yB) { - // this is not actually correct, but quick & dirty - int xMin, width, yMin, height; - if (xA < xB) { - xMin = xA; - width = xB - xA; - } else if (xB < xA) { - xMin = xB; - width = xA - xB; - } else { - xMin = xA; - width = 1; - } - if (yA < yB) { - yMin = yA; - height = yB - yA; - } else if (yB < yA) { - yMin = yB; - height = yA - yB; - } else { - yMin = yA; - height = 1; - } - // there are some problems with this quick&dirty implementation - // so I am going to throw in some slop - xMin -= 5; - yMin -= 5; - width += 10; - height += 10; - rectTemp.x = xMin; - rectTemp.y = yMin; - rectTemp.width = width; - rectTemp.height = height; - boolean visible = rectClip.intersects(rectTemp); - return visible; - }*/ - - /*private void renderDotted() { - if (dx == 0 && dy == 0) - return; - g3d.drawDashedLine(colixA, colixB, 8, 4, xA, yA, zA, xB, yB, zB); - }*/ - - /* no longer implemented - private static int wideWidthMilliAngstroms = 400; - - private void renderTriangle(Bond bond) { - // for now, always solid, always opaque - if (!g3d.checkTranslucent(false)) - return; - int mag2d = (int)Math.sqrt(dx*dx + dy*dy); - int wideWidthPixels = viewer.scaleToScreen(zB, wideWidthMilliAngstroms); - int dxWide, dyWide; - if (mag2d == 0) { - dxWide = 0; - dyWide = wideWidthPixels; - } else { - dxWide = wideWidthPixels * -dy / mag2d; - dyWide = wideWidthPixels * dx / mag2d; - } - int xWideUp = xB + dxWide/2; - int xWideDn = xWideUp - dxWide; - int yWideUp = yB + dyWide/2; - int yWideDn = yWideUp - dyWide; - g3d.setColix(colixA); - if (colixA == colixB) { - g3d.drawfillTriangle(xA, yA, zA, - xWideUp, yWideUp, zB, xWideDn, yWideDn, zB); - } else { - int xMidUp = (xA + xWideUp) / 2; - int yMidUp = (yA + yWideUp) / 2; - int zMid = (zA + zB) / 2; - int xMidDn = (xA + xWideDn) / 2; - int yMidDn = (yA + yWideDn) / 2; - g3d.drawfillTriangle(xA, yA, zA, - xMidUp, yMidUp, zMid, xMidDn, yMidDn, zMid); - g3d.setColix(colixB); - g3d.drawfillTriangle(xMidUp, yMidUp, zMid, - xMidDn, yMidDn, zMid, xWideDn, yWideDn, zB); - g3d.drawfillTriangle(xMidUp, yMidUp, zMid, - xWideUp, yWideUp, zB, xWideDn, yWideDn, zB); - } - } - */ - private int getAromaticDottedBondMask() { Atom atomC = atomB.findAromaticNeighbor(atomA.getIndex()); if (atomC == null) return 1; - //System.out.println("SticksRenderer atomA " + atomA.getInfo() + " atomB " + atomB.getInfo() + " atomC " + atomC.getInfo()); int dxAC = atomC.screenX - xA; int dyAC = atomC.screenY - yA; return ((dx * dyAC - dy * dxAC) < 0 ? 2 : 1); } - void drawDashed(int xA, int yA, int zA, int xB, int yB, int zB) { + private void drawDashed(int xA, int yA, int zA, int xB, int yB, int zB) { int dx = xB - xA; int dy = yB - yA; int dz = zB - zA; @@ -392,7 +360,7 @@ } } - void renderHbondDashed() { + private void renderHbondDashed() { int dx = xB - xA; int dy = yB - yA; int dz = zB - zA; @@ -412,20 +380,16 @@ xS, yS, zS, xE, yE, zE); } } - - //////////////////////// - - protected void fillCylinder(short colixA, short colixB, byte endcaps, + + private void fillCylinder(short colixA, short colixB, byte endcaps, int diameter, int xA, int yA, int zA, int xB, int yB, int zB) { if (lineBond) g3d.drawLine(colixA, colixB, xA, yA, zA, xB, yB, zB); - else { - if (exportType != Graphics3D.EXPORT_NOT && mad != 1) - diameter = mad; - g3d.fillCylinder(colixA, colixB, endcaps, diameter, xA, yA, zA, xB, yB, - zB); - } + else + g3d.fillCylinder(colixA, colixB, endcaps, + (exportType == Graphics3D.EXPORT_NOT || mad == 1 ? diameter : mad), + xA, yA, zA, xB, yB, zB); } } Modified: branches/v12_0/Jmol/src/org/jmol/shapesurface/Isosurface.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/shapesurface/Isosurface.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/shapesurface/Isosurface.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -620,7 +620,7 @@ int j = script.indexOf("})", i); if (j < 0) return false; - BitSet bs = Escape.unescapeBitset(script.substring(i + 3, j + 1)); + BitSet bs = Escape.unescapeBitset(script.substring(i + 2, j + 2)); if (bsCmd == null) sg.setParameter("select", bs); else @@ -630,7 +630,7 @@ j = script.indexOf("})", i); if (j < 0) return false; - bs = Escape.unescapeBitset(script.substring(i + 1, j + 1)); + bs = Escape.unescapeBitset(script.substring(i, j + 2)); if (bsCmd == null) sg.setParameter("ignore", bs); else @@ -638,7 +638,7 @@ if ((i = script.indexOf("/({", j)) == j + 2) { if ((j = script.indexOf("})", i)) < 0) return false; - bs = Escape.unescapeBitset(script.substring(i + 3, j + 1)); + bs = Escape.unescapeBitset(script.substring(i + 1, j + 2)); if (bsCmd == null) viewer.setTrajectory(bs); else @@ -1408,7 +1408,7 @@ } } if (pickedVertex != -1) - return (Logger.debugging ? "v" + pickedVertex + ": " : "") + m.vertexValues[pickedVertex]; + return (Logger.debugging ? "v" + pickedVertex + " " + m.vertices[pickedVertex] + ": " : "") + m.vertexValues[pickedVertex]; } return null; } Modified: branches/v12_0/Jmol/src/org/jmol/util/ColorEncoder.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/util/ColorEncoder.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/util/ColorEncoder.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -51,33 +51,46 @@ public final static int ROYGB = 0; public final static int BGYOR = 1; - public final static int RWB = 2; - public final static int BWR = 3; - public final static int LOW = 4; - public final static int HIGH = 5; - public final static int BW = 6; - public final static int WB = 7; - public final static int JMOL = 8; - public final static int RASMOL = 9; - public final static int SHAPELY = 10; - public final static int AMINO = 11; + public final static int JMOL = 2; + public final static int RASMOL = 3; + public final static int SHAPELY = 4; + public final static int AMINO = 5; + public final static int RWB = 6; + public final static int BWR = 7; + public final static int LOW = 8; + public final static int HIGH = 9; + public final static int BW = 10; + public final static int WB = 11; public final static int COLOR_RGB = 12; public final static int USER = -13; public final static int RESU = -14; + public final static int ALT = 15; // == 0 private final static String[] colorSchemes = { - "roygb", "bgyor", "rwb", "bwr", "low", "high", "bw", "wb", - BYELEMENT_JMOL, BYELEMENT_RASMOL, BYRESIDUE_SHAPELY, - BYRESIDUE_AMINO, "colorRGB", "user", "resu"}; + "roygb", "bgyor", BYELEMENT_JMOL, BYELEMENT_RASMOL, BYRESIDUE_SHAPELY, + BYRESIDUE_AMINO, + "rwb", "bwr", "low", "high", "bw", "wb", + "colorRGB", // no idea! + // custom + "user", "resu", + // ALT_NAMES: + "rgb", "bgr", "jmol", "rasmol", BYRESIDUE_PREFIX + }; - private final static int schemeIndex(String colorScheme) { + private final static int getSchemeIndex(String colorScheme) { for (int i = 0; i < colorSchemes.length; i++) if (colorSchemes[i].equalsIgnoreCase(colorScheme)) - return (i < -USER ? i : -i); + return (i >= ALT ? i - ALT : i < -USER ? i : -i); return -1; } + + private final static String fixName(String name) { + if (name.equalsIgnoreCase(BYELEMENT_PREFIX)) + return BYELEMENT_JMOL; + int ipt = getSchemeIndex(name); + return (ipt >= 0 ? colorSchemes[ipt] : name.toLowerCase()); + } - private int currentPalette = ROYGB; private boolean currentTranslucent = false; @@ -186,19 +199,6 @@ || thisName.indexOf(BYRESIDUE_PREFIX) == 0); } - private static String fixName(String name) { - name = name.toLowerCase(); - if (name.equals(BYELEMENT_PREFIX)) - return BYELEMENT_JMOL; - if (name.equals("jmol")) - return BYELEMENT_JMOL; - if (name.equals("rasmol")) - return BYELEMENT_RASMOL; - if (name.equals(BYRESIDUE_PREFIX)) - return BYRESIDUE_SHAPELY; - return name; - } - private float lo; private float hi; private boolean isReversed; @@ -280,7 +280,7 @@ return makeColorScheme(name, scale, isOverloaded); } colorScheme = fixName(colorScheme); - int ipt = schemeIndex(colorScheme) ; + int ipt = getSchemeIndex(colorScheme) ; if (schemes.containsKey(colorScheme)) { thisName = colorScheme; thisScale = (int[]) schemes.get(colorScheme); Modified: branches/v12_0/Jmol/src/org/jmol/viewer/Jmol.properties =================================================================== --- branches/v12_0/Jmol/src/org/jmol/viewer/Jmol.properties 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/viewer/Jmol.properties 2010-09-16 11:40:57 UTC (rev 14310) @@ -4,6 +4,17 @@ version=12.0.13_dev +# two new features added retroactively: +# new feature: set multipleBondRadiusFactor 0.75 +# new feature: multipleBondSpacing +# set multipleBondSpacing = -1 (default, varies with viewing angle) +# set multipleBondSpacing = -0.5 (half that distance; varies with viewing angle) +# set multipleBondSpacing = 0.35 (positive ==> fixed multiple bond spacing) + +# bug fix: isosurface map MEP not as accurate as could be +# bug fix: SmarterJmolAdapter should not read zip bytes it doesn't have to +# bug fix: spacefill JMOL does not work +# bug fix: Jmol 12 does not read old 11.1 isosurface commands from states # bug fix: load {i j k} RANGE x.x not expanding load box by 1 in each direction # bug fix: applet console does not display startup message # bug fix: undo/redo problems in AppConsole Modified: branches/v12_0/Jmol/src/org/jmol/viewer/StateManager.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/viewer/StateManager.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/viewer/StateManager.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -887,6 +887,8 @@ setParameterValue("minimizationCriterion", minimizationCriterion); setParameterValue("modelKitMode", modelKitMode); setParameterValue("monitorEnergy", monitorEnergy); + setParameterValue("multipleBondRadiusFactor", multipleBondRadiusFactor); + setParameterValue("multipleBondSpacing", multipleBondSpacing); setParameterValue("multiProcessor", multiProcessor && (Viewer.nProcessors > 1)); setParameterValue("navigationMode", navigationMode); setParameterValue("navigateSurface", navigateSurface); @@ -1136,6 +1138,8 @@ boolean showHydrogens = true; boolean showMultipleBonds = true; boolean ssbondsBackbone = false; + float multipleBondSpacing = -1; // 0.35? + float multipleBondRadiusFactor = 0; // 0.75? //secondary structure + Rasmol Modified: branches/v12_0/Jmol/src/org/jmol/viewer/Viewer.java =================================================================== --- branches/v12_0/Jmol/src/org/jmol/viewer/Viewer.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/jmol/viewer/Viewer.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -5430,6 +5430,14 @@ boolean isInt) { boolean found = true; switch (tok) { + case Token.multiplebondradiusfactor: + // 12.0.13 + global.multipleBondRadiusFactor = value; + break; + case Token.multiplebondspacing: + // 12.0.13 + global.multipleBondSpacing = value; + break; case Token.minimizationcriterion: global.minimizationCriterion = value; break; @@ -6795,6 +6803,14 @@ return global.showMultipleBonds; } + public float getMultipleBondSpacing() { + return global.multipleBondSpacing; + } + + public float getMultipleBondRadiusFactor() { + return global.multipleBondRadiusFactor; + } + public void setShowHydrogens(boolean TF) { // PreferencesDialog // setBooleanProperty Modified: branches/v12_0/Jmol/src/org/openscience/jmol/app/jmolpanel/AppConsole.java =================================================================== --- branches/v12_0/Jmol/src/org/openscience/jmol/app/jmolpanel/AppConsole.java 2010-09-16 11:35:37 UTC (rev 14309) +++ branches/v12_0/Jmol/src/org/openscience/jmol/app/jmolpanel/AppConsole.java 2010-09-16 11:40:57 UTC (rev 14310) @@ -547,7 +547,8 @@ int kcode = ke.getKeyCode(); int kid = ke.getID(); if (kid == KeyEvent.KEY_PRESSED) { - if (kcode == KeyEvent.VK_TAB) { + switch (kcode) { + case KeyEvent.VK_TAB: ke.consume(); if (consoleDoc.isAtEnd()) { String cmd = completeCommand(consoleDoc.getCommandString()); @@ -561,6 +562,15 @@ //checkCommand(); return; } + break; + case KeyEvent.VK_ESCAPE: + ke.consume(); + try { + consoleDoc.replaceCommand("", false); + } catch (BadLocationException e) { + // + } + break; } nTab = 0; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |