@Override
public boolean read(ReadingContext aContext) {
if (mappers == null) {
withPCDataMappedTo(tagName);
}
if (aContext.isStartTagNamed(namespace, tagName)) {
maybePushNewContextObject(aContext);
try {
if (attributes != null) attributes.read(aContext);
while (aContext.isNotEndTag(namespace, tagName)) {
for (XmlReader _m : mappers) {
if (_m.read(aContext)) {
break;
}
}
aContext.next();
}
return true;
} catch (XmlReadingException anExc) {
throw anExc;
} catch (Exception anExc) {
throw new XmlReadingException(anExc);
} finally {
maybePopContext(aContext);
}
} else {
return false;
}
}
protected void readVector(int voxelVectorIndex) throws Exception {
String data = xr.getXmlData("jvxlVolumeVector", tempDataXml, true, true);
tempDataXml = tempDataXml.substring(tempDataXml.indexOf(data) + data.length());
int n = parseIntStr(XmlReader.getXmlAttrib(data, "count"));
if (n == Integer.MIN_VALUE) vertexDataOnly = true;
voxelCounts[voxelVectorIndex] = (n < 0 ? 0 : n);
volumetricVectors[voxelVectorIndex].setT(xr.getXmlPoint(data, "vector"));
if (isAnisotropic) setVectorAnisotropy(volumetricVectors[voxelVectorIndex]);
}
@Override
protected void readSurfaceData(boolean isMapDataIgnored) throws Exception {
thisInside = !params.isContoured;
if (readSurfaceDataXML()) return;
tempDataXml = xr.getXmlData("jvxlEdgeData", null, true, false);
bsVoxelBitSet =
JvxlCoder.jvxlDecodeBitSet(xr.getXmlData("jvxlEdgeData", tempDataXml, false, false));
// if (thisInside)
// bsVoxelBitSet = BitSetUtil.copyInvert(bsVoxelBitSet,
// bsVoxelBitSet.size());
readSurfaceDataJXR();
}
private void getNewNodes() {
Vector levelNodes = new Vector();
Vector nextLevelNodes = new Vector();
Vector passedNodes = new Vector();
levelNodes.add(centerNode.name);
for (int level = 0; level <= Config.navigationDepth; level++) {
for (Enumeration e = levelNodes.elements(); e.hasMoreElements(); ) {
String nodeName = (String) e.nextElement();
if (!passedNodes.contains(nodeName)) {
passedNodes.add(nodeName);
Node node = graph.nodeFromName(nodeName);
if (node == null) {
node = xmlReader.getNode(nodeName);
graph.add(node);
}
node.passed = true;
Set linkSet = node.links.keySet();
for (Iterator it = linkSet.iterator(); it.hasNext(); ) {
String neighbourName = (String) it.next();
if (!passedNodes.contains(neighbourName) && !levelNodes.contains(neighbourName)) {
nextLevelNodes.add(neighbourName);
}
}
}
}
levelNodes = nextLevelNodes;
nextLevelNodes = new Vector();
}
}
/**
* "edge" data includes two parts -- a compressed bitset indicating exactly which edges, in order
* or processing by Jmol, are crossed by the surface, and a set of fractions indicating how far
* along that edge (good to 1 part in 8100) that surface crosses that edge. We are just reading he
* fractions here.
*
* <p>"color" data comprises the corresponding sequence of data mapping values, again stored to a
* precision of 1 part in 8100, relative to a range of values.
*
* @param type
* @param nPoints
* @return data
*/
protected String jvxlReadFractionData(String type, int nPoints) {
String str;
try {
if (type.equals("edge")) {
str = JvxlCoder.jvxlDecompressString(XmlReader.getXmlAttrib(tempDataXml, "data"));
} else {
String data = xr.getXmlData("jvxlColorData", null, true, false);
jvxlData.isJvxlPrecisionColor = getEncoding(data).endsWith("2");
str = JvxlCoder.jvxlDecompressString(XmlReader.getXmlAttrib(data, "data"));
}
} catch (Exception e) {
Logger.error("Error reading " + type + " data " + e);
throw new NullPointerException();
}
return str;
}
public static void main(String argv[]) {
File file = new File("xml1.xml");
XmlReader reader;
XmlWriter writer;
XmlDocument document;
String xmlout;
// Construct a document and parse it
System.out.println("We are going to parse from " + file + ".");
System.out.println("The parser will be set to verbose mode\n");
document = new XmlDocument(file);
reader = new XmlReader();
reader.setVerbose(true);
try {
reader.parse(document);
} catch (Exception e) {
e.printStackTrace();
}
int errors = reader.getErrorCount();
int warnings = reader.getWarningCount();
System.err.println("Completed: " + errors + " errors, " + warnings + " warnings");
if (errors > 0) {
System.err.println("Unrecoverable errors in XML. Stop.");
return;
}
// Now print it
System.out.println("\nHaving parsed the document, we will print it out.");
System.out.println("Here is the DTD:\n");
writer = new XmlWriter();
Writer out = new OutputStreamWriter(System.out);
try {
writer.writeDTD(document, out);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("\nHere is the XML:\n");
try {
writer.write(document, out);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
protected void gotoData(int n, int nPoints) throws Exception {
if (n > 0) Logger.info("skipping " + n + " data sets, " + nPoints + " points each");
vertexDataOnly = jvxlData.vertexDataOnly = (nPoints == 0);
for (int i = 0; i < n; i++) {
jvxlSkipData(nPoints, true);
}
xr.toTag("jvxlSurface");
jvxlReadSurfaceInfo();
}
/**
* Update Groups Registry from XML at URL.
*
* <p>
*
* @param i BeanShell interpreter.
* @param stack BeanShell call stack.
* @param url Use the XML at this <tt>URL</tt> for updates.
* @return True if successful.
* @throws GrouperShellException
* @since 0.1.0
*/
public static boolean invoke(Interpreter i, CallStack stack, URL url)
throws GrouperShellException {
GrouperShell.setOurCommand(i, true);
try {
GrouperSession s = GrouperShell.getSession(i);
XmlImporter importer = new XmlImporter(s, new Properties());
importer.update(XmlReader.getDocumentFromURL(url));
return true;
} catch (GrouperException eG) {
GrouperShell.error(i, eG);
}
return false;
} // public static boolean invoke(i, stack, url)
protected void jvxlDecodeContourData(JvxlData jvxlData, String data) throws Exception {
List<List<Object>> vs = new List<List<Object>>();
SB values = new SB();
SB colors = new SB();
int pt = -1;
jvxlData.vContours = null;
if (data == null) return;
while ((pt = data.indexOf("<jvxlContour", pt + 1)) >= 0) {
List<Object> v = new List<Object>();
String s = xr.getXmlData("jvxlContour", data.substring(pt), true, false);
float value = parseFloatStr(XmlReader.getXmlAttrib(s, "value"));
values.append(" ").appendF(value);
int color = getColor(XmlReader.getXmlAttrib(s, "color"));
short colix = C.getColix(color);
colors.append(" ").append(Escape.escapeColor(color));
String fData = JvxlCoder.jvxlDecompressString(XmlReader.getXmlAttrib(s, "data"));
BS bs = JvxlCoder.jvxlDecodeBitSet(xr.getXmlData("jvxlContour", s, false, false));
int n = bs.length();
IsosurfaceMesh.setContourVector(v, n, bs, value, colix, color, SB.newS(fData));
vs.addLast(v);
}
int n = vs.size();
if (n > 0) {
jvxlData.vContours = AU.createArrayOfArrayList(n);
// 3D contour values and colors
jvxlData.contourColixes = params.contourColixes = new short[n];
jvxlData.contourValues = params.contoursDiscrete = new float[n];
for (int i = 0; i < n; i++) {
jvxlData.vContours[i] = vs.get(i);
jvxlData.contourValues[i] = ((Float) jvxlData.vContours[i].get(2)).floatValue();
jvxlData.contourColixes[i] = ((short[]) jvxlData.vContours[i].get(3))[0];
}
jvxlData.contourColors = C.getHexCodes(jvxlData.contourColixes);
Logger.info("JVXL read: " + n + " discrete contours");
Logger.info("JVXL read: contour values: " + values);
Logger.info("JVXL read: contour colors: " + colors);
}
}
public boolean deserializeChild(
final DeserializationFactory<T, M> factory, @NotNull final XmlReader in) throws XmlException {
if (ProcessConsts.Engine.NAMESPACE.equals(in.getNamespaceUri())) {
switch (in.getLocalName().toString()) {
case EndNode.ELEMENTLOCALNAME:
factory.deserializeEndNode(asM(), in);
return true;
case Activity.ELEMENTLOCALNAME:
factory.deserializeActivity(asM(), in);
return true;
case StartNode.ELEMENTLOCALNAME:
factory.deserializeStartNode(asM(), in);
return true;
case Join.ELEMENTLOCALNAME:
factory.deserializeJoin(asM(), in);
return true;
case Split.ELEMENTLOCALNAME:
factory.deserializeSplit(asM(), in);
return true;
}
}
return false;
}
/**
* decode vertex data found within <jvxlVertexData> element as created by jvxlEncodeVertexData
* (see above)
*
* @param data tag and contents
* @param asArray or just addVertexCopy
* @return Point3f[] if desired
* @throws Exception
*/
public P3[] jvxlDecodeVertexData(String data, boolean asArray) throws Exception {
int vertexCount = parseIntStr(XmlReader.getXmlAttrib(data, "count"));
if (!asArray) Logger.info("Reading " + vertexCount + " vertices");
int ptCount = vertexCount * 3;
P3[] vertices = (asArray ? new P3[vertexCount] : null);
P3 p = (asArray ? null : new P3());
float fraction;
String vData = XmlReader.getXmlAttrib(data, "data");
String encoding = getEncoding(data);
if ("none".equals(encoding)) {
if (vData.length() == 0) vData = xr.getXmlData("jvxlVertexData", data, false, false);
float[] fdata = PT.parseFloatArray(vData);
// first point is count -- ignored.
if (fdata[0] != vertexCount * 3)
Logger.info(
"JvxlXmlReader: vertexData count="
+ ((int) fdata[0])
+ "; expected "
+ (vertexCount * 3));
for (int i = 0, pt = 1; i < vertexCount; i++) {
p = P3.new3(fdata[pt++], fdata[pt++], fdata[pt++]);
if (asArray) vertices[i] = p;
else addVertexCopy(p, 0, i);
}
} else {
P3 min = xr.getXmlPoint(data, "min");
P3 range = xr.getXmlPoint(data, "max");
range.sub(min);
int colorFractionBase = jvxlData.colorFractionBase;
int colorFractionRange = jvxlData.colorFractionRange;
String s = JvxlCoder.jvxlDecompressString(vData);
if (s.length() == 0) s = xr.getXmlData("jvxlVertexData", data, false, false);
for (int i = 0, pt = -1; i < vertexCount; i++) {
if (asArray) p = vertices[i] = new P3();
fraction =
JvxlCoder.jvxlFractionFromCharacter2(
s.charAt(++pt), s.charAt(pt + ptCount), colorFractionBase, colorFractionRange);
p.x = min.x + fraction * range.x;
fraction =
JvxlCoder.jvxlFractionFromCharacter2(
s.charAt(++pt), s.charAt(pt + ptCount), colorFractionBase, colorFractionRange);
p.y = min.y + fraction * range.y;
fraction =
JvxlCoder.jvxlFractionFromCharacter2(
s.charAt(++pt), s.charAt(pt + ptCount), colorFractionBase, colorFractionRange);
p.z = min.z + fraction * range.z;
if (!asArray) addVertexCopy(p, 0, i);
}
}
return vertices;
}
public static <T extends ProcessNode<T, M>, M extends ProcessModelBase<T, M>> M deserialize(
final DeserializationFactory<T, M> factory, final M processModel, final XmlReader in)
throws XmlException {
XmlReaderUtil.skipPreamble(in);
final QName elementName = ELEMENTNAME;
assert XmlReaderUtil.isElement(in, elementName)
: "Expected " + elementName + " but found " + in.getLocalName();
for (int i = in.getAttributeCount() - 1; i >= 0; --i) {
processModel.deserializeAttribute(
in.getAttributeNamespace(i), in.getAttributeLocalName(i), in.getAttributeValue(i));
}
EventType event = null;
loop:
while (in.hasNext() && event != XmlStreaming.END_ELEMENT) {
switch ((event = in.next())) {
case START_ELEMENT:
if (processModel.deserializeChild(factory, in)) {
continue loop;
}
XmlReaderUtil.unhandledEvent(in);
break;
case TEXT:
case CDSECT:
if (false) {
continue loop;
}
default:
XmlReaderUtil.unhandledEvent(in);
}
}
for (final T node : processModel.getModelNodes()) {
for (final Identifiable pred : node.getPredecessors()) {
final T predNode = processModel.getNode(pred);
if (predNode != null) {
predNode.addSuccessor(node);
}
}
}
return processModel;
}
/**
* Parses all xml in a given src dir for xml to compare with the deploy from src xml looking for
* destructive changes to create.
*
* @param origPath
* <p>The original path where the metadata type being parsed lives in the src dir.
* @param toPath
* <p>The dir path to the src dir of the Salesforce org to be deployed to.
* @param fromPath
* <p>The dir path to the src dir of the Salesforce org being deployed from.
* @param metaType
* <p>The metadata type (2nd property in each line in package.properties) to be parsed for
* destruction.
* @param dirName
* <p>The directory name where the metadata type (1st property in each line in
* package.properties) lives in the src dir.
* @param searchTerm
* <p>This term (4th property in each line in package.properties) determines the xml data node
* name to search for. This is usually fullName, but not always.
* @param packageName
* <p>The metadata type (2nd property in each line in package.properties) to be parsed for
* destruction.
*/
private void seekAndDestroy(
final String origPath,
String toPath,
String fromPath,
String metaType,
String dirName,
String searchTerm,
String packageName) {
File root = new File(toPath);
File[] list = root.listFiles();
for (File f : list) {
if (f.isDirectory()) {
seekAndDestroy(origPath, f.getPath(), fromPath, metaType, dirName, searchTerm, packageName);
} else {
// Compare xml
File fromFile =
new File(
f.getPath()
.replace(
orgTo.getSourceFolder().getPath(), orgFrom.getSourceFolder().getPath()));
if (fromFile.exists() && !fromFile.getName().endsWith(".xml")) {
ArrayList<String> rets =
XmlReader.compareXml(f.getPath(), fromFile.getPath(), metaType, searchTerm);
String name = f.getName();
name = name.substring(0, name.indexOf('.'));
for (String component : rets) {
if (component.indexOf('|') > -1) {
component = component.replace("|", ".");
}
addDestructiveComponents(packageName, component, name);
}
}
}
}
}
@Override
protected void readParameters() throws Exception {
String s = xr.getXmlData("jvxlFileTitle", null, false, false);
jvxlFileHeaderBuffer = SB.newS(s);
xr.toTag("jvxlVolumeData");
String data = tempDataXml = xr.getXmlData("jvxlVolumeData", null, true, false);
volumetricOrigin.setT(xr.getXmlPoint(data, "origin"));
isAngstroms = true;
readVector(0);
readVector(1);
readVector(2);
line = xr.toTag("jvxlSurfaceSet");
nSurfaces = parseIntStr(XmlReader.getXmlAttrib(line, "count"));
Logger.info("jvxl file surfaces: " + nSurfaces);
Logger.info("using default edge fraction base and range");
Logger.info("using default color fraction base and range");
cJvxlEdgeNaN = (char) (edgeFractionBase + edgeFractionRange);
}
/**
* retrieve Jvxl 2.0 format vertex/triangle/edge/color data found within <jvxlSurfaceData> element
*
* @throws Exception
*/
protected void getEncodedVertexData() throws Exception {
// get vertices
String sdata = xr.getXmlData("jvxlSurfaceData", null, true, false);
jvxlDecodeVertexData(xr.getXmlData("jvxlVertexData", sdata, true, false), false);
// get triangles
String tData = xr.getXmlData("jvxlTriangleData", sdata, true, false);
String edgeData = xr.getXmlData("jvxlTriangleEdgeData", sdata, true, false);
// note: polygon color data is always between tags, not an attribute, and not compressed:
String polygonColorData = xr.getXmlData("jvxlPolygonColorData", sdata, false, false);
jvxlDecodeTriangleData(tData, edgeData, polygonColorData);
// get vertex value data or vertex color data:
String cData = xr.getXmlData("jvxlColorData", sdata, true, false);
jvxlColorEncodingRead = getEncoding(cData);
jvxlData.isJvxlPrecisionColor = jvxlColorEncodingRead.endsWith("2");
cData = getData(cData, "jvxlColorData");
jvxlColorDataRead =
(jvxlColorEncodingRead.equals("none") ? cData : JvxlCoder.jvxlDecompressString(cData));
jvxlDataIsColorMapped =
((params.colorRgb == Integer.MIN_VALUE || params.colorRgb == Integer.MAX_VALUE)
&& jvxlColorDataRead.length() > 0);
// get contours
if (haveContourData)
jvxlDecodeContourData(jvxlData, xr.getXmlData("jvxlContourData", null, false, false));
}
public void navigateFirst(String nodeName) {
Node node = xmlReader.getNode(nodeName);
graph.add(node);
navigateTo(node);
}
@Override
protected boolean gotoAndReadVoxelData(boolean isMapData) {
initializeVolumetricData();
if (nPointsX < 0 || nPointsY < 0 || nPointsZ < 0) return true;
try {
gotoData(params.fileIndex - 1, nPointsX * nPointsY * nPointsZ);
if (vertexDataOnly) return true;
volumeData.setMappingPlane(params.thePlane);
readSurfaceData(isMapData);
volumeData.setMappingPlane(null);
if (edgeDataCount > 0) jvxlEdgeDataRead = jvxlReadFractionData("edge", edgeDataCount);
params.bsExcluded = jvxlData.jvxlExcluded = new BS[4];
hasColorData = (colorDataCount > 0); // for nonXML version of JVXL
if (hasColorData) jvxlColorDataRead = jvxlReadFractionData("color", colorDataCount);
if (excludedVertexCount > 0) {
jvxlData.jvxlExcluded[0] =
JvxlCoder.jvxlDecodeBitSet(xr.getXmlData("jvxlExcludedVertexData", null, false, false));
if (xr.isNext("jvxlExcludedPlaneData"))
jvxlData.jvxlExcluded[2] =
JvxlCoder.jvxlDecodeBitSet(
xr.getXmlData("jvxlExcludedPlaneData", null, false, false));
}
if (excludedTriangleCount > 0)
jvxlData.jvxlExcluded[3] =
JvxlCoder.jvxlDecodeBitSet(
xr.getXmlData("jvxlExcludedTriangleData", null, false, false));
if (invalidatedVertexCount > 0)
jvxlData.jvxlExcluded[1] =
JvxlCoder.jvxlDecodeBitSet(
xr.getXmlData("jvxlInvalidatedVertexData", null, false, false));
if (haveContourData)
jvxlDecodeContourData(jvxlData, xr.getXmlData("jvxlContourData", null, false, false));
if (jvxlDataIsColorMapped && jvxlData.nVertexColors > 0) {
jvxlData.vertexColorMap = new Hashtable<String, BS>();
String vdata = xr.getXmlData("jvxlVertexColorData", null, true, false);
String baseColor = XmlReader.getXmlAttrib(vdata, "baseColor");
jvxlData.baseColor = (baseColor.length() > 0 ? baseColor : null);
for (int i = 0; i < jvxlData.nVertexColors; i++) {
String s = xr.getXmlData("jvxlColorMap", vdata, true, false);
String color = XmlReader.getXmlAttrib(s, "color");
BS bs = JvxlCoder.jvxlDecodeBitSet(xr.getXmlData("jvxlColorMap", s, false, false));
jvxlData.vertexColorMap.put(color, bs);
}
}
} catch (Exception e) {
Logger.error(e.toString());
return false;
}
return true;
}
/**
* decode triangle data found within <jvxlTriangleData> element as created with
* jvxlEncodeTriangleData (see above)
*
* @param tdata tag and contents
* @param edgeData
* @param colorData
* @throws Exception
*/
void jvxlDecodeTriangleData(String tdata, String edgeData, String colorData) throws Exception {
int nTriangles = parseIntStr(XmlReader.getXmlAttrib(tdata, "count"));
if (nTriangles < 0) return;
int[] nextc = new int[1];
int nColors = (colorData == null ? -1 : PT.parseIntNext(colorData, nextc));
int color = 0;
Logger.info("Reading " + nTriangles + " triangles");
String encoding = getEncoding(tdata);
tdata = getData(tdata, "jvxlTriangleData");
String edata = getData(edgeData, "jvxlTriangleEdgeData");
int[] vertex = new int[3];
int[] nextp = new int[1];
int[] nexte = null;
int edgeMask = 7;
boolean haveEdgeInfo;
boolean haveEncoding = !"none".equals(encoding);
if (haveEncoding) {
tdata = JvxlCoder.jvxlDecompressString(tdata);
edata = JvxlCoder.jvxlDecompressString(edata).trim();
haveEdgeInfo = (edata.length() == nTriangles);
} else {
int n = PT.parseIntNext(tdata, nextp);
haveEdgeInfo = (edata.length() > 0);
if (haveEdgeInfo) {
nexte = new int[1];
PT.parseIntNext(edata, nexte); // throw away count
} else if (n > 0) {
Logger.info("JvxlXmlReader: jvxlTriangleEdgeData count=" + n + "; expected " + nTriangles);
}
}
for (int i = 0, v = 0, p = 0, pt = -1; i < nTriangles; ) {
if (haveEncoding) {
char ch = tdata.charAt(++pt);
int diff;
switch (ch) {
case '!':
diff = 0;
break;
case '+':
case '.':
case ' ':
case '\n':
case '\r':
case '\t':
case ',':
continue;
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
nextp[0] = pt;
diff = PT.parseIntNext(tdata, nextp);
pt = nextp[0] - 1;
break;
default:
diff = ch - 92; // '\' character
}
v += diff;
} else {
v = PT.parseIntNext(tdata, nextp) - 1;
}
vertex[p] = v;
if (++p == 3) {
p = 0;
if (haveEdgeInfo) {
edgeMask =
(nexte == null ? edata.charAt(i) - '0' : javajs.util.PT.parseIntNext(edata, nexte));
if (edgeMask < 0 || edgeMask > 7) edgeMask = 7;
}
if (nColors > 0) {
int c = PT.parseIntNext(colorData, nextc);
if (c == Integer.MIN_VALUE) nColors = 0;
else color = c;
nColors--;
}
addTriangleCheck(vertex[0], vertex[1], vertex[2], edgeMask, 0, false, color);
i++;
}
}
}
private static String getEncoding(String data) {
// original JVXL does not include "encoding"
if (XmlReader.getXmlAttrib(data, "len").length() > 0) return "";
String s = XmlReader.getXmlAttrib(data, "encoding");
return (s.length() == 0 ? "none" : s);
}
private String getData(String sdata, String name) throws Exception {
String data = XmlReader.getXmlAttrib(sdata, "data");
if (data.length() == 0) data = xr.getXmlData(name, sdata, false, false);
return data;
}
protected void jvxlReadSurfaceInfo() throws Exception {
String s;
String data = xr.getXmlData("jvxlSurfaceInfo", null, true, true);
isXLowToHigh = XmlReader.getXmlAttrib(data, "isXLowToHigh").equals("true");
jvxlCutoff = parseFloatStr(XmlReader.getXmlAttrib(data, "cutoff"));
if (!Float.isNaN(jvxlCutoff)) Logger.info("JVXL read: cutoff " + jvxlCutoff);
int nContourData = parseIntStr(XmlReader.getXmlAttrib(data, "nContourData"));
haveContourData = (nContourData > 0);
params.isContoured = XmlReader.getXmlAttrib(data, "contoured").equals("true");
if (params.isContoured) {
int nContoursRead = parseIntStr(XmlReader.getXmlAttrib(data, "nContours"));
if (nContoursRead <= 0) {
nContoursRead = 0;
} else {
s = XmlReader.getXmlAttrib(data, "contourValues");
if (s.length() > 0) {
jvxlData.contourValues = params.contoursDiscrete = parseFloatArrayStr(s);
Logger.info("JVXL read: contourValues " + Escape.eAF(jvxlData.contourValues));
}
s = XmlReader.getXmlAttrib(data, "contourColors");
if (s.length() > 0) {
jvxlData.contourColixes = params.contourColixes = C.getColixArray(s);
jvxlData.contourColors = C.getHexCodes(jvxlData.contourColixes);
Logger.info("JVXL read: contourColixes " + C.getHexCodes(jvxlData.contourColixes));
}
params.contourFromZero = XmlReader.getXmlAttrib(data, "contourFromZero").equals("true");
}
params.nContours = (haveContourData ? nContourData : nContoursRead);
// TODO ? params.contourFromZero = false; // MEP data to complete the plane
}
jvxlData.nVertexColors = parseIntStr(XmlReader.getXmlAttrib(data, "nVertexColors"));
params.isBicolorMap = XmlReader.getXmlAttrib(data, "bicolorMap").equals("true");
if (params.isBicolorMap) {
// TODO -- not quite right, because
s = XmlReader.getXmlAttrib(data, "colorPositive");
if (s.length() > 0
&& params.colorRgb == Integer.MIN_VALUE
&& params.colorPos == Parameters.defaultColorPositive)
params.colorPos = CU.getArgbFromString(s);
s = XmlReader.getXmlAttrib(data, "colorNegative");
if (s.length() > 0
&& params.colorRgb == Integer.MIN_VALUE
&& params.colorNeg == Parameters.defaultColorNegative)
params.colorNeg = CU.getArgbFromString(s);
}
if (params.isBicolorMap || params.colorBySign) jvxlCutoff = 0;
jvxlDataIsColorMapped =
((params.colorRgb == Integer.MIN_VALUE || params.colorRgb == Integer.MAX_VALUE)
&& (params.isBicolorMap || XmlReader.getXmlAttrib(data, "colorMapped").equals("true")));
// isJvxlPrecisionColor is for information only -- will be superceded by encoding attribute of
// jvxlColorData
jvxlData.isJvxlPrecisionColor = XmlReader.getXmlAttrib(data, "precisionColor").equals("true");
jvxlData.jvxlDataIsColorDensity =
params.colorDensity =
(params.colorRgb == Integer.MIN_VALUE
&& XmlReader.getXmlAttrib(data, "colorDensity").equals("true"));
if (jvxlData.jvxlDataIsColorDensity && Float.isNaN(params.pointSize)) {
s = XmlReader.getXmlAttrib(data, "pointSize");
if (s.length() > 0) jvxlData.pointSize = params.pointSize = parseFloatStr(s);
}
s = XmlReader.getXmlAttrib(data, "allowVolumeRender");
jvxlData.allowVolumeRender =
params.allowVolumeRender = (s.length() == 0 || s.equalsIgnoreCase("true"));
s = XmlReader.getXmlAttrib(data, "plane");
if (s.indexOf("{") >= 0) {
params.thePlane = null;
params.mapLattice = null;
try {
params.thePlane = (P4) Escape.uP(s);
s = XmlReader.getXmlAttrib(data, "maplattice");
Logger.info("JVXL read: plane " + params.thePlane);
if (s.indexOf("{") >= 0) {
params.mapLattice = (P3) Escape.uP(s);
Logger.info("JVXL read: mapLattice " + params.mapLattice);
}
if (params.scale3d == 0)
params.scale3d = parseFloatStr(XmlReader.getXmlAttrib(data, "scale3d"));
if (Float.isNaN(params.scale3d)) params.scale3d = 0;
} catch (Exception e) {
if (params.thePlane == null) {
Logger.error("JVXL Error reading plane definition -- setting to 0 0 1 0 (z=0)");
params.thePlane = P4.new4(0, 0, 1, 0);
} else {
Logger.error("JVXL Error reading mapLattice definition -- ignored");
}
}
surfaceDataCount = 0;
edgeDataCount = 0;
} else {
params.thePlane = null;
surfaceDataCount = parseIntStr(XmlReader.getXmlAttrib(data, "nSurfaceInts"));
edgeDataCount = parseIntStr(XmlReader.getXmlAttrib(data, "nBytesUncompressedEdgeData"));
}
excludedVertexCount = parseIntStr(XmlReader.getXmlAttrib(data, "nExcludedVertexes"));
excludedTriangleCount = parseIntStr(XmlReader.getXmlAttrib(data, "nExcludedTriangles"));
invalidatedVertexCount = parseIntStr(XmlReader.getXmlAttrib(data, "nInvalidatedVertexes"));
s = XmlReader.getXmlAttrib(data, "slabInfo");
if (s.length() > 0) jvxlData.slabInfo = s;
colorDataCount =
Math.max(0, parseIntStr(XmlReader.getXmlAttrib(data, "nBytesUncompressedColorData")));
jvxlDataIs2dContour = (params.thePlane != null && jvxlDataIsColorMapped);
// new Jmol 12.1.50
jvxlData.color = XmlReader.getXmlAttrib(data, "color");
if (jvxlData.color.length() == 0 || jvxlData.color.indexOf("null") >= 0)
jvxlData.color = "orange";
jvxlData.translucency = parseFloatStr(XmlReader.getXmlAttrib(data, "translucency"));
if (Float.isNaN(jvxlData.translucency)) jvxlData.translucency = 0;
s = XmlReader.getXmlAttrib(data, "meshColor");
if (s.length() > 0) jvxlData.meshColor = s;
s = XmlReader.getXmlAttrib(data, "rendering");
if (s.length() > 0) jvxlData.rendering = s;
jvxlData.colorScheme = XmlReader.getXmlAttrib(data, "colorScheme");
if (jvxlData.colorScheme.length() == 0) jvxlData.colorScheme = null;
if (jvxlData.thisSet < 0) {
int n = parseIntStr(XmlReader.getXmlAttrib(data, "set"));
if (n > 0) jvxlData.thisSet = n - 1;
}
jvxlData.slabValue = parseIntStr(XmlReader.getXmlAttrib(data, "slabValue"));
jvxlData.isSlabbable = (XmlReader.getXmlAttrib(data, "slabbable").equalsIgnoreCase("true"));
jvxlData.diameter = parseIntStr(XmlReader.getXmlAttrib(data, "diameter"));
if (jvxlData.diameter == Integer.MIN_VALUE) jvxlData.diameter = 0;
if (jvxlDataIs2dContour) params.isContoured = true;
if (params.colorBySign) params.isBicolorMap = true;
boolean insideOut = XmlReader.getXmlAttrib(data, "insideOut").equals("true");
float dataMin = Float.NaN;
float dataMax = Float.NaN;
float red = Float.NaN;
float blue = Float.NaN;
if (jvxlDataIsColorMapped) {
dataMin = parseFloatStr(XmlReader.getXmlAttrib(data, "dataMinimum"));
dataMax = parseFloatStr(XmlReader.getXmlAttrib(data, "dataMaximum"));
red = parseFloatStr(XmlReader.getXmlAttrib(data, "valueMappedToRed"));
blue = parseFloatStr(XmlReader.getXmlAttrib(data, "valueMappedToBlue"));
if (Float.isNaN(dataMin)) {
dataMin = red = -1f;
dataMax = blue = 1f;
}
}
jvxlSetColorRanges(dataMin, dataMax, red, blue, insideOut);
}
protected void jvxlSkipData(
@SuppressWarnings("unused") int nPoints, @SuppressWarnings("unused") boolean doSkipColorData)
throws Exception {
readLine();
xr.skipTag("jvxlSurface");
}
