コード例 #1
0
 /* (non-Javadoc)
  * @see gov.nasa.ial.mde.solver.symbolic.AnalyzedItem#dispose()
  */
 public void dispose() {
   xName = null;
   yName = null;
   xData = null;
   yData = null;
   preferredBounds = null;
   features = null;
   xPointValues = null;
   disposeGraphTrails();
   disposePoints();
 }
コード例 #2
0
  /* (non-Javadoc)
   * @see gov.nasa.ial.mde.solver.symbolic.AnalyzedItem#computePoints(double, double, double, double)
   */
  public void computePoints(double left, double right, double top, double bottom) {
    // Calculate the points and graph-trails for the given bounds
    int lastIndex = xData.length - 1;

    int leftIndex = Arrays.binarySearch(xData, left);
    if (leftIndex < 0) {
      leftIndex = -leftIndex - 1;
    }
    if (leftIndex >= xData.length) {
      leftIndex = lastIndex;
    }
    // Use the point to the left of the index found in the binary search,
    // which puts us to the left of the desired left position.
    while ((leftIndex > 0) && (xData[leftIndex] > left)) {
      leftIndex--;
    }

    int rightIndex = Arrays.binarySearch(xData, right);
    if (rightIndex < 0) {
      rightIndex = -rightIndex - 1;
    }
    if (rightIndex >= xData.length) {
      rightIndex = lastIndex;
    }
    // Use the index found in the binary search, which puts us to the right
    // of the desired right position.
    while ((rightIndex < lastIndex) && (xData[rightIndex] < right)) {
      rightIndex++;
    }

    if (leftIndex > rightIndex) {
      throw new IllegalArgumentException("Can not have left bound > right bound");
    }

    // The left and right indexes for all the real data points in the given bounds.
    this.leftIndexBound = leftIndex;
    this.rightIndexBound = rightIndex;

    maxJump = Math.abs(top - bottom);
    int totalPts = (rightIndex - leftIndex) + 1;

    // NOTE: Our current model is to either interpolate or decimate the real data points.
    // TODO: Use a real data model.

    // Dispose of the current points array so we don't have a memory leak.
    disposePoints();

    // Generate the points that will be used for sonifying the model.
    if (totalPts < NUM_POINTS) {
      // Interpolate the data to a length of NUM_POINTS.
      points = PointsUtil.interpolatePoints(leftIndex, rightIndex, NUM_POINTS, xData, yData);
    } else if (totalPts > NUM_POINTS) {
      // Decimate the data to a length of NUM_POINTS.
      points = PointsUtil.decimatePoints(leftIndex, rightIndex, NUM_POINTS, xData, yData);
    } else {
      // Make a copy of the points that is a length of NUM_POINTS.
      points = PointsUtil.copyPoints(leftIndex, rightIndex, xData, yData);
    }

    // Create the array of x-values of the points for quick x-value to index lookup.
    // We assume that the x values from the points array are sorted in ascending order.
    if (points == null) {
      xPointValues = null;
    } else {
      int len = points.length;
      if ((xPointValues == null) || (xPointValues.length != len)) {
        xPointValues = new double[len];
      }
      for (int i = 0; i < len; i++) {
        xPointValues[i] = points[i].x;
      }
    }

    // Dispose of the current graph trails array so we don't have a memory leak.
    disposeGraphTrails();

    // Generate the trails used for graphing the model of the real data.
    graphTrails = TrailUtil.getGraphTrailsFrom(points, maxJump);

    // Update the preferred bounds we keep for this analyzed data.
    preferredBounds.setBounds(left, right, top, bottom);
  }