Пример #1
0
  void colorIsosurface() {
    if (params.isSquared && volumeData != null) volumeData.filterData(true, Float.NaN);
    /*    if (params.isContoured && marchingSquares == null) {
          //    if (params.isContoured && !(jvxlDataIs2dContour || params.thePlane != null)) {
          Logger.error("Isosurface error: Cannot contour this type of data.");
          return;
        }
    */
    if (meshDataServer != null) {
      meshDataServer.fillMeshData(meshData, MeshData.MODE_GET_VERTICES, null);
    }

    jvxlData.saveVertexCount = 0;
    if (params.isContoured && marchingSquares != null) {
      initializeMapping();
      params.setMapRanges(this, false);
      marchingSquares.setMinMax(params.valueMappedToRed, params.valueMappedToBlue);
      jvxlData.saveVertexCount = marchingSquares.contourVertexCount;
      contourVertexCount =
          marchingSquares.generateContourData(
              jvxlDataIs2dContour, (params.isSquared ? 1e-8f : 1e-4f));
      jvxlData.contourValuesUsed = marchingSquares.getContourValues();
      minMax = marchingSquares.getMinMax();
      if (meshDataServer != null) meshDataServer.notifySurfaceGenerationCompleted();
      finalizeMapping();
    }

    applyColorScale();
    jvxlData.nContours = (params.contourFromZero ? params.nContours : -1 - params.nContours);
    jvxlData.jvxlFileMessage =
        "mapped: min = " + params.valueMappedToRed + "; max = " + params.valueMappedToBlue;
  }
Пример #2
0
 public float[] getMinMaxMappedValues(boolean haveData) {
   if (minMax != null && minMax[0] != Float.MAX_VALUE) return minMax;
   if (params.colorBySets) return (minMax = new float[] {0, Math.max(meshData.nSets - 1, 0)});
   float min = Float.MAX_VALUE;
   float max = -Float.MAX_VALUE;
   if (params.usePropertyForColorRange && params.theProperty != null) {
     for (int i = 0; i < params.theProperty.length; i++) {
       if (params.rangeSelected && !params.bsSelected.get(i)) continue;
       float p = params.theProperty[i];
       if (Float.isNaN(p)) continue;
       if (p < min) min = p;
       if (p > max) max = p;
     }
     return (minMax = new float[] {min, max});
   }
   int vertexCount = (contourVertexCount > 0 ? contourVertexCount : meshData.vertexCount);
   Point3f[] vertexes = meshData.vertices;
   boolean useVertexValue =
       (haveData || jvxlDataIs2dContour || vertexDataOnly || params.colorDensity);
   for (int i = meshData.mergeVertexCount0; i < vertexCount; i++) {
     float v;
     if (useVertexValue) v = meshData.vertexValues[i];
     else v = volumeData.lookupInterpolatedVoxelValue(vertexes[i]);
     if (v < min) min = v;
     if (v > max && v != Float.MAX_VALUE) max = v;
   }
   return (minMax = new float[] {min, max});
 }
Пример #3
0
  protected void setVolumeData(VolumeData v) {
    nBytes = 0;
    volumetricOrigin = v.volumetricOrigin;
    volumetricVectors = v.volumetricVectors;
    voxelCounts = v.voxelCounts;
    voxelData = v.getVoxelData();
    volumeData = v;

    /*    if (mustCalcPoint)
          v.setDataSource(this);
    */ }
Пример #4
0
  boolean readAndSetVolumeParameters(boolean isMapData) {
    if (!readVolumeParameters(isMapData)) return false;
    if (vertexDataOnly) return true;
    // if (volumeData.sr != null)
    // return true;
    return (volumeData.setUnitVectors()); // || isMapData && params.thePlane != null);

    //        && (vertexDataOnly
    //            || isMapData && params.thePlane != null
    //            || volumeData.sr != null
    //            || volumeData.setUnitVectors()));
  }
Пример #5
0
  void applyColorScale() {
    colorFractionBase = jvxlData.colorFractionBase = JvxlCoder.defaultColorFractionBase;
    colorFractionRange = jvxlData.colorFractionRange = JvxlCoder.defaultColorFractionRange;
    if (params.colorPhase == 0) params.colorPhase = 1;
    if (meshDataServer == null) {
      meshData.vertexColixes = new short[meshData.vertexCount];
    } else {
      meshDataServer.fillMeshData(meshData, MeshData.MODE_GET_VERTICES, null);
      if (params.contactPair == null)
        meshDataServer.fillMeshData(meshData, MeshData.MODE_GET_COLOR_INDEXES, null);
    }
    // colorBySign is true when colorByPhase is true, but not vice-versa
    // old: boolean saveColorData = !(params.colorByPhase && !params.isBicolorMap &&
    // !params.colorBySign); //sorry!
    boolean saveColorData =
        (params.colorDensity || params.isBicolorMap || params.colorBySign || !params.colorByPhase);
    if (params.contactPair != null) saveColorData = false;
    // colors mappable always now
    jvxlData.isJvxlPrecisionColor = true;
    jvxlData.vertexCount = (contourVertexCount > 0 ? contourVertexCount : meshData.vertexCount);
    jvxlData.minColorIndex = -1;
    jvxlData.maxColorIndex = 0;
    jvxlData.contourValues = params.contoursDiscrete;
    jvxlData.isColorReversed = params.isColorReversed;
    if (!params.colorDensity)
      if (params.isBicolorMap && !params.isContoured || params.colorBySign) {
        jvxlData.minColorIndex =
            Graphics3D.getColixTranslucent(
                Graphics3D.getColix(params.isColorReversed ? params.colorPos : params.colorNeg),
                jvxlData.translucency != 0,
                jvxlData.translucency);
        jvxlData.maxColorIndex =
            Graphics3D.getColixTranslucent(
                Graphics3D.getColix(params.isColorReversed ? params.colorNeg : params.colorPos),
                jvxlData.translucency != 0,
                jvxlData.translucency);
      }
    jvxlData.isTruncated = (jvxlData.minColorIndex >= 0 && !params.isContoured);
    boolean useMeshDataValues =
        jvxlDataIs2dContour
            ||
            //      !jvxlDataIs2dContour && (params.isContoured && jvxlData.jvxlPlane != null ||
            hasColorData
            || vertexDataOnly
            || params.colorDensity
            || params.isBicolorMap && !params.isContoured;
    if (!useMeshDataValues) {
      if (haveSurfaceAtoms && meshData.vertexSource == null)
        meshData.vertexSource = new int[meshData.vertexCount];
      float min = Float.MAX_VALUE;
      float max = -Float.MAX_VALUE;
      float value;
      initializeMapping();
      for (int i = meshData.vertexCount; --i >= meshData.mergeVertexCount0; ) {
        /* right, so what we are doing here is setting a range within the
         * data for which we want red-->blue, but returning the actual
         * number so it can be encoded more precisely. This turned out to be
         * the key to making the JVXL contours work.
         *
         */
        if (params.colorBySets) {
          value = meshData.vertexSets[i];
        } else if (params.colorByPhase) {
          value = getPhase(meshData.vertices[i]);
          // else if (jvxlDataIs2dContour)
          // marchingSquares
          //    .getInterpolatedPixelValue(meshData.vertices[i]);
        } else {
          value = volumeData.lookupInterpolatedVoxelValue(meshData.vertices[i]);
          if (haveSurfaceAtoms) meshData.vertexSource[i] = getSurfaceAtomIndex();
        }
        if (value < min) min = value;
        if (value > max && value != Float.MAX_VALUE) max = value;
        meshData.vertexValues[i] = value;
      }
      if (params.rangeSelected && minMax == null) minMax = new float[] {min, max};
      finalizeMapping();
    }
    params.setMapRanges(this, true);
    jvxlData.mappedDataMin = params.mappedDataMin;
    jvxlData.mappedDataMax = params.mappedDataMax;
    jvxlData.valueMappedToRed = params.valueMappedToRed;
    jvxlData.valueMappedToBlue = params.valueMappedToBlue;
    if (params.contactPair == null) colorData();

    JvxlCoder.jvxlCreateColorData(jvxlData, (saveColorData ? meshData.vertexValues : null));

    if (haveSurfaceAtoms && meshDataServer != null)
      meshDataServer.fillMeshData(meshData, MeshData.MODE_PUT_VERTICES, null);

    if (meshDataServer != null && params.colorBySets)
      meshDataServer.fillMeshData(meshData, MeshData.MODE_PUT_SETS, null);
  }
Пример #6
0
  boolean createIsosurface(boolean justForPlane) {
    resetIsosurface();
    jvxlData.cutoff = Float.NaN;
    if (!readAndSetVolumeParameters(justForPlane)) return false;
    if (!justForPlane && !Float.isNaN(params.sigma) && !allowSigma) {
      if (params.sigma > 0)
        Logger.error("Reader does not support SIGMA option -- using cutoff 1.6");
      params.cutoff = 1.6f;
    }
    // negative sigma just ignores the error message
    // and means it was inserted by Jmol as a default option
    if (params.sigma < 0) params.sigma = -params.sigma;
    nPointsX = voxelCounts[0];
    nPointsY = voxelCounts[1];
    nPointsZ = voxelCounts[2];
    jvxlData.isSlabbable = ((params.dataType & Parameters.IS_SLABBABLE) != 0);
    jvxlData.insideOut = params.insideOut;
    jvxlData.dataXYReversed = params.dataXYReversed;
    jvxlData.isBicolorMap = params.isBicolorMap;
    jvxlData.nPointsX = nPointsX;
    jvxlData.nPointsY = nPointsY;
    jvxlData.nPointsZ = nPointsZ;
    jvxlData.jvxlVolumeDataXml = volumeData.xmlData;
    jvxlData.voxelVolume = volumeData.voxelVolume;
    if (justForPlane) {
      // float[][][] voxelDataTemp =  volumeData.voxelData;
      volumeData.setMappingPlane(params.thePlane);
      // volumeData.setDataDistanceToPlane(params.thePlane);
      if (meshDataServer != null)
        meshDataServer.fillMeshData(meshData, MeshData.MODE_GET_VERTICES, null);
      params.setMapRanges(this, false);
      generateSurfaceData();
      volumeData.setMappingPlane(null);

      // if (volumeData != null)
      //  volumeData.voxelData = voxelDataTemp;
    } else {
      if (!readVolumeData(false)) return false;
      generateSurfaceData();
    }
    if (jvxlFileHeaderBuffer != null) {
      String s = jvxlFileHeaderBuffer.toString();
      int i = s.indexOf('\n', s.indexOf('\n', s.indexOf('\n') + 1) + 1) + 1;
      jvxlData.jvxlFileTitle = s.substring(0, i);
    }
    if (params.contactPair == null) setBoundingBox();
    if (!params.isSilent)
      Logger.info("boundbox corners " + Escape.escape(xyzMin) + " " + Escape.escape(xyzMax));
    jvxlData.boundingBox = new Point3f[] {xyzMin, xyzMax};
    jvxlData.dataMin = dataMin;
    jvxlData.dataMax = dataMax;
    jvxlData.cutoff = (isJvxl ? jvxlCutoff : params.cutoff);
    jvxlData.isCutoffAbsolute = params.isCutoffAbsolute;
    jvxlData.pointsPerAngstrom = 1f / volumeData.volumetricVectorLengths[0];
    jvxlData.jvxlColorData = "";
    jvxlData.jvxlPlane = params.thePlane;
    jvxlData.jvxlEdgeData = edgeData;
    jvxlData.isBicolorMap = params.isBicolorMap;
    jvxlData.isContoured = params.isContoured;
    jvxlData.colorDensity = params.colorDensity;
    if (jvxlData.vContours != null) params.nContours = jvxlData.vContours.length;
    jvxlData.nContours = (params.contourFromZero ? params.nContours : -1 - params.nContours);
    jvxlData.nEdges = edgeCount;
    jvxlData.edgeFractionBase = edgeFractionBase;
    jvxlData.edgeFractionRange = edgeFractionRange;
    jvxlData.colorFractionBase = colorFractionBase;
    jvxlData.colorFractionRange = colorFractionRange;
    jvxlData.jvxlDataIs2dContour = jvxlDataIs2dContour;
    jvxlData.jvxlDataIsColorMapped = jvxlDataIsColorMapped;
    jvxlData.jvxlDataIsColorDensity = jvxlDataIsColorDensity;
    jvxlData.isXLowToHigh = isXLowToHigh;
    jvxlData.vertexDataOnly = vertexDataOnly;
    jvxlData.saveVertexCount = 0;

    if (jvxlDataIsColorMapped || jvxlData.nVertexColors > 0) {
      if (meshDataServer != null) {
        meshDataServer.fillMeshData(meshData, MeshData.MODE_GET_VERTICES, null);
        meshDataServer.fillMeshData(meshData, MeshData.MODE_GET_COLOR_INDEXES, null);
      }
      jvxlData.jvxlColorData = readColorData();
      updateSurfaceData();
      if (meshDataServer != null) meshDataServer.notifySurfaceMappingCompleted();
    }
    return true;
  }
Пример #7
0
 protected void newVoxelDataCube() {
   volumeData.setVoxelData(voxelData = new float[nPointsX][nPointsY][nPointsZ]);
 }