Пример #1
0
  public boolean play() {

    try {
      if (playState != STOPPED) playStop();

      if (audioBytes == null) return false;

      DataLine.Info info = new DataLine.Info(Clip.class, format);

      clip = (Clip) AudioSystem.getLine(info);
      clip.addLineListener(new ClipListener());

      long clipStart = (long) (audioBytes.length * getStartTime() / (getDuration() * 1000.0));
      long clipEnd = (long) (audioBytes.length * getEndTime() / (getDuration() * 1000.0));
      if ((clipEnd - clipStart) > MAX_CLIP_LENGTH) clipEnd = clipStart + MAX_CLIP_LENGTH;
      byte[] clipBytes = new byte[(int) (clipEnd - clipStart)];
      System.arraycopy(audioBytes, (int) clipStart, clipBytes, 0, clipBytes.length);
      clip.open(format, clipBytes, 0, clipBytes.length);

      FloatControl panControl = (FloatControl) clip.getControl(FloatControl.Type.PAN);

      panControl.setValue((float) panSetting / 100.0f);

      double value = (double) gainSetting;

      FloatControl gainControl = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN);
      float dB = (float) (Math.log(value == 0.0 ? 0.0001 : value) / Math.log(10.0) * 20.0);
      gainControl.setValue(dB);
      double playStartTime = (player.getSeekTime() / 100) * (playGetLength());
      clip.setMicrosecondPosition((long) playStartTime);

      clip.start();

      playState = PLAYING;

      return true;

    } catch (Exception ex) {
      ex.printStackTrace();
      playState = STOPPED;
      clip = null;
      return false;
    }
  }
Пример #2
0
 public double getValue(DatanVector x) {
   double result;
   double a = sqrt2pi * x.getElement(1);
   if (a < small) f = big;
   else f = Math.log(a);
   result = (double) y.length * f;
   for (int i = 0; i < y.length; i++) {
     f = Math.pow((y[i] - x.getElement(0)), 2.) / (2. * x.getElement(1) * x.getElement(1));
     result += f;
   }
   return result;
 }
Пример #3
0
  private int percentToZoomLevel(double percent) {
    double minZoomPercent = mImagePresentationModel.getMinZoom();
    double zoomIncrement = computeZoomIncrementToMakeExactlyNIncrements();

    return (int) Math.round((Math.log(percent / minZoomPercent) / Math.log(zoomIncrement)) + 1);
  }
Пример #4
0
  /** Translation durchfuehren */
  public void process() {
    int i, j, k;
    int ch, len;
    float f1;
    double d1, d2, d3, d4, d5;
    long progOff, progLen, lo;

    // io
    AudioFile reInF = null;
    AudioFile imInF = null;
    AudioFile reOutF = null;
    AudioFile imOutF = null;
    AudioFileDescr reInStream = null;
    AudioFileDescr imInStream = null;
    AudioFileDescr reOutStream = null;
    AudioFileDescr imOutStream = null;
    FloatFile reFloatF[] = null;
    FloatFile imFloatF[] = null;
    File reTempFile[] = null;
    File imTempFile[] = null;
    int outChanNum;

    float[][] reInBuf; // [ch][i]
    float[][] imInBuf; // [ch][i]
    float[][] reOutBuf = null; // [ch][i]
    float[][] imOutBuf = null; // [ch][i]
    float[] convBuf1, convBuf2;
    boolean complex;

    PathField ggOutput;

    // Synthesize
    Param ampRef = new Param(1.0, Param.ABS_AMP); // transform-Referenz
    float gain; // gain abs amp
    float dryGain, wetGain;
    float inGain;
    float maxAmp = 0.0f;
    Param peakGain;

    int inLength, inOff;
    int pre;
    int post;
    int length;
    int framesRead, framesWritten, outLength;
    boolean polarIn, polarOut;

    // phase unwrapping
    double[] phi;
    int[] wrap;
    double[] carry;

    Param lenRef;

    topLevel:
    try {

      complex = pr.bool[PR_HASIMINPUT] || pr.bool[PR_HASIMOUTPUT];
      polarIn = pr.intg[PR_OPERATOR] == OP_POLAR2RECT;
      polarOut = pr.intg[PR_OPERATOR] == OP_RECT2POLAR;
      if ((polarIn || polarOut) && !complex) throw new IOException(ERR_NOTCOMPLEX);

      // ---- open input ----

      reInF = AudioFile.openAsRead(new File(pr.text[PR_REINPUTFILE]));
      reInStream = reInF.getDescr();
      inLength = (int) reInStream.length;
      reInBuf = new float[reInStream.channels][8192];
      imInBuf = new float[reInStream.channels][8192];

      if (pr.bool[PR_HASIMINPUT]) {
        imInF = AudioFile.openAsRead(new File(pr.text[PR_IMINPUTFILE]));
        imInStream = imInF.getDescr();
        if (imInStream.channels != reInStream.channels) throw new IOException(ERR_COMPLEX);
        inLength = (int) Math.min(inLength, imInStream.length);
      }

      lenRef = new Param(AudioFileDescr.samplesToMillis(reInStream, inLength), Param.ABS_MS);
      d1 =
          AudioFileDescr.millisToSamples(
              reInStream, (Param.transform(pr.para[PR_OFFSET], Param.ABS_MS, lenRef, null).value));
      j = (int) (d1 >= 0.0 ? (d1 + 0.5) : (d1 - 0.5)); // correct rounding for negative values!
      length =
          (int)
              (AudioFileDescr.millisToSamples(
                      reInStream,
                      (Param.transform(pr.para[PR_LENGTH], Param.ABS_MS, lenRef, null)).value)
                  + 0.5);

      // System.err.println( "offset = "+j );

      if (j >= 0) {
        inOff = Math.min(j, inLength);
        if (!pr.bool[PR_REVERSE]) {
          reInF.seekFrame(inOff);
          if (pr.bool[PR_HASIMINPUT]) {
            imInF.seekFrame(inOff);
          }
        }
        inLength -= inOff;
        pre = 0;
      } else {
        inOff = 0;
        pre = Math.min(-j, length);
      }
      inLength = Math.min(inLength, length - pre);
      post = length - pre - inLength;

      if (pr.bool[PR_REVERSE]) {
        i = pre;
        pre = post;
        post = i;
        inOff += inLength;
      }

      // .... check running ....
      if (!threadRunning) break topLevel;

      // for( op = 0; op < 2; op++ ) {
      // 	System.out.println( op +": pre "+pre[op]+" / len "+inLength[op]+" / post "+post[op] );
      // }
      // System.out.println( "tot "+length[0]);

      outLength = length;
      outChanNum = reInStream.channels;

      // ---- open output ----

      ggOutput = (PathField) gui.getItemObj(GG_REOUTPUTFILE);
      if (ggOutput == null) throw new IOException(ERR_MISSINGPROP);
      reOutStream = new AudioFileDescr(reInStream);
      ggOutput.fillStream(reOutStream);
      reOutStream.channels = outChanNum;
      // well, more sophisticated code would
      // move and truncate the markers...
      if ((pre == 0) /* && (post == 0) */) {
        reInF.readMarkers();
        reOutStream.setProperty(
            AudioFileDescr.KEY_MARKERS, reInStream.getProperty(AudioFileDescr.KEY_MARKERS));
      }
      reOutF = AudioFile.openAsWrite(reOutStream);
      reOutBuf = new float[outChanNum][8192];
      imOutBuf = new float[outChanNum][8192];

      if (pr.bool[PR_HASIMOUTPUT]) {
        imOutStream = new AudioFileDescr(reInStream);
        ggOutput.fillStream(imOutStream);
        imOutStream.channels = outChanNum;
        imOutStream.file = new File(pr.text[PR_IMOUTPUTFILE]);
        imOutF = AudioFile.openAsWrite(imOutStream);
      }
      // .... check running ....
      if (!threadRunning) break topLevel;

      // ---- Further inits ----

      phi = new double[outChanNum];
      wrap = new int[outChanNum];
      carry = new double[outChanNum];
      for (ch = 0; ch < outChanNum; ch++) {
        phi[ch] = 0.0;
        wrap[ch] = 0;
        carry[ch] = Double.NEGATIVE_INFINITY;
      }

      progOff = 0; // read, transform, write
      progLen = (long) outLength * 3;

      wetGain = (float) (Param.transform(pr.para[PR_WETMIX], Param.ABS_AMP, ampRef, null)).value;
      dryGain = (float) (Param.transform(pr.para[PR_DRYMIX], Param.ABS_AMP, ampRef, null)).value;
      if (pr.bool[PR_DRYINVERT]) {
        dryGain = -dryGain;
      }
      inGain = (float) (Param.transform(pr.para[PR_INPUTGAIN], Param.ABS_AMP, ampRef, null)).value;
      if (pr.bool[PR_INVERT]) {
        inGain = -inGain;
      }

      // normalization requires temp files
      if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
        reTempFile = new File[outChanNum];
        reFloatF = new FloatFile[outChanNum];
        for (ch = 0;
            ch < outChanNum;
            ch++) { // first zero them because an exception might be thrown
          reTempFile[ch] = null;
          reFloatF[ch] = null;
        }
        for (ch = 0; ch < outChanNum; ch++) {
          reTempFile[ch] = IOUtil.createTempFile();
          reFloatF[ch] = new FloatFile(reTempFile[ch], GenericFile.MODE_OUTPUT);
        }
        if (pr.bool[PR_HASIMOUTPUT]) {
          imTempFile = new File[outChanNum];
          imFloatF = new FloatFile[outChanNum];
          for (ch = 0;
              ch < outChanNum;
              ch++) { // first zero them because an exception might be thrown
            imTempFile[ch] = null;
            imFloatF[ch] = null;
          }
          for (ch = 0; ch < outChanNum; ch++) {
            imTempFile[ch] = IOUtil.createTempFile();
            imFloatF[ch] = new FloatFile(imTempFile[ch], GenericFile.MODE_OUTPUT);
          }
        }
        progLen += outLength;
      } else {
        gain = (float) (Param.transform(pr.para[PR_GAIN], Param.ABS_AMP, ampRef, null)).value;
        wetGain *= gain;
        dryGain *= gain;
      }
      // .... check running ....
      if (!threadRunning) break topLevel;

      // ----==================== the real stuff ====================----

      framesRead = 0;
      framesWritten = 0;

      while (threadRunning && (framesWritten < outLength)) {
        // ---- choose chunk len ----
        len = Math.min(8192, outLength - framesWritten);
        if (pre > 0) {
          len = Math.min(len, pre);
        } else if (inLength > 0) {
          len = Math.min(len, inLength);
        } else {
          len = Math.min(len, post);
        }

        // ---- read input chunks ----
        if (pre > 0) {
          Util.clear(reInBuf);
          if (complex) {
            Util.clear(imInBuf);
          }
          pre -= len;
        } else if (inLength > 0) {
          if (pr.bool[PR_REVERSE]) { // ---- read reversed ----
            reInF.seekFrame(inOff - framesRead - len);
            reInF.readFrames(reInBuf, 0, len);
            for (ch = 0; ch < reInStream.channels; ch++) {
              convBuf1 = reInBuf[ch];
              for (i = 0, j = len - 1; i < j; i++, j--) {
                f1 = convBuf1[j];
                convBuf1[j] = convBuf1[i];
                convBuf1[i] = f1;
              }
            }
            if (pr.bool[PR_HASIMINPUT]) {
              imInF.seekFrame(inOff - framesRead - len);
              imInF.readFrames(imInBuf, 0, len);
              for (ch = 0; ch < imInStream.channels; ch++) {
                convBuf1 = imInBuf[ch];
                for (i = 0, j = len - 1; i < j; i++, j--) {
                  f1 = convBuf1[j];
                  convBuf1[j] = convBuf1[i];
                  convBuf1[i] = f1;
                }
              }
            } else if (complex) {
              Util.clear(imInBuf);
            }
          } else { // ---- read normal ----
            reInF.readFrames(reInBuf, 0, len);
            if (pr.bool[PR_HASIMINPUT]) {
              imInF.readFrames(imInBuf, 0, len);
            } else if (complex) {
              Util.clear(imInBuf);
            }
          }
          inLength -= len;
          framesRead += len;
        } else {
          Util.clear(reInBuf);
          if (complex) {
            Util.clear(imInBuf);
          }
          post -= len;
        }
        progOff += len;
        // .... progress ....
        setProgression((float) progOff / (float) progLen);
        // .... check running ....
        if (!threadRunning) break topLevel;

        // ---- save dry signal ----
        for (ch = 0; ch < outChanNum; ch++) {
          convBuf1 = reInBuf[ch];
          convBuf2 = reOutBuf[ch];
          for (i = 0; i < len; i++) {
            convBuf2[i] = convBuf1[i] * dryGain;
          }
          if (complex) {
            convBuf1 = imInBuf[ch];
            convBuf2 = imOutBuf[ch];
            for (i = 0; i < len; i++) {
              convBuf2[i] = convBuf1[i] * dryGain;
            }
          }
        }

        // ---- rectify + apply input gain ----
        for (ch = 0; ch < reInStream.channels; ch++) {
          convBuf1 = reInBuf[ch];
          convBuf2 = imInBuf[ch];
          // ---- rectify ----
          if (pr.bool[PR_RECTIFY]) {
            if (complex) {
              if (polarIn) {
                for (i = 0; i < len; i++) {
                  convBuf2[i] = 0.0f;
                }
              } else {
                for (i = 0; i < len; i++) {
                  d1 = convBuf1[i];
                  d2 = convBuf2[i];
                  convBuf1[i] = (float) Math.sqrt(d1 * d1 + d2 * d2);
                  convBuf2[i] = 0.0f;
                }
              }
            } else {
              for (i = 0; i < len; i++) {
                convBuf1[i] = Math.abs(convBuf1[i]);
              }
            }
          }
          // ---- apply input gain ----
          Util.mult(convBuf1, 0, len, inGain);
          if (complex & !polarIn) {
            Util.mult(convBuf2, 0, len, inGain);
          }
        }

        // ---- heart of the dragon ----
        for (ch = 0; ch < outChanNum; ch++) {
          convBuf1 = reInBuf[ch];
          convBuf2 = imInBuf[ch];

          switch (pr.intg[PR_OPERATOR]) {
            case OP_NONE: // ================ None ================
              for (i = 0; i < len; i++) {
                reOutBuf[ch][i] += wetGain * convBuf1[i];
              }
              if (complex) {
                for (i = 0; i < len; i++) {
                  imOutBuf[ch][i] += wetGain * convBuf2[i];
                }
              }
              break;

            case OP_SIN: // ================ Cosinus ================
              if (complex) {
                for (i = 0; i < len; i++) {
                  reOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf1[i] * Math.PI);
                  imOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf2[i] * Math.PI);
                }
              } else {
                for (i = 0; i < len; i++) {
                  reOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf1[i] * Math.PI);
                }
              }
              break;

            case OP_SQR: // ================ Square ================
              if (complex) {
                for (i = 0; i < len; i++) {
                  reOutBuf[ch][i] +=
                      wetGain * (convBuf1[i] * convBuf1[i] - convBuf2[i] * convBuf2[i]);
                  imOutBuf[ch][i] -= wetGain * (convBuf1[i] * convBuf2[i] * 2);
                }
              } else {
                for (i = 0; i < len; i++) {
                  reOutBuf[ch][i] += wetGain * (convBuf1[i] * convBuf1[i]);
                }
              }
              break;

            case OP_SQRT: // ================ Square root ================
              if (complex) {
                d3 = phi[ch];
                k = wrap[ch];
                d4 = k * Constants.PI2;
                for (i = 0; i < len; i++) {
                  d1 =
                      wetGain
                          * Math.pow(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i], 0.25);
                  d2 = Math.atan2(convBuf2[i], convBuf1[i]);
                  if (d2 - d3 > Math.PI) {
                    k--;
                    d4 = k * Constants.PI2;
                  } else if (d3 - d2 > Math.PI) {
                    k++;
                    d4 = k * Constants.PI2;
                  }
                  d2 += d4;
                  d3 = d2;
                  d2 /= 2;
                  reOutBuf[ch][i] += (float) (d1 * Math.cos(d2));
                  imOutBuf[ch][i] += (float) (d1 * Math.sin(d2));
                }
                phi[ch] = d3;
                wrap[ch] = k;

              } else {
                for (i = 0; i < len; i++) {
                  f1 = convBuf1[i];
                  if (f1 > 0) {
                    reOutBuf[ch][i] += wetGain * (float) Math.sqrt(f1);
                  } // else undefiniert
                }
              }
              break;

            case OP_RECT2POLARW: // ================ Rect->Polar (wrapped) ================
              for (i = 0; i < len; i++) {
                d1 = wetGain * Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
                d2 = Math.atan2(convBuf2[i], convBuf1[i]);
                reOutBuf[ch][i] += (float) d1;
                imOutBuf[ch][i] += (float) d2;
              }
              break;

            case OP_RECT2POLAR: // ================ Rect->Polar ================
              d3 = phi[ch];
              k = wrap[ch];
              d4 = k * Constants.PI2;
              for (i = 0; i < len; i++) {
                d1 = wetGain * Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
                d2 = Math.atan2(convBuf2[i], convBuf1[i]);
                if (d2 - d3 > Math.PI) {
                  k--;
                  d4 = k * Constants.PI2;
                } else if (d3 - d2 > Math.PI) {
                  k++;
                  d4 = k * Constants.PI2;
                }
                d2 += d4;
                reOutBuf[ch][i] += (float) d1;
                imOutBuf[ch][i] += (float) d2;
                d3 = d2;
              }
              phi[ch] = d3;
              wrap[ch] = k;
              break;

            case OP_POLAR2RECT: // ================ Polar->Rect ================
              for (i = 0; i < len; i++) {
                f1 = wetGain * convBuf1[i];
                reOutBuf[ch][i] += f1 * (float) Math.cos(convBuf2[i]);
                imOutBuf[ch][i] += f1 * (float) Math.sin(convBuf2[i]);
              }
              break;

            case OP_LOG: // ================ Log ================
              if (complex) {
                d3 = phi[ch];
                k = wrap[ch];
                d4 = k * Constants.PI2;
                d5 = carry[ch];
                for (i = 0; i < len; i++) {
                  d1 = Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
                  d2 = Math.atan2(convBuf2[i], convBuf1[i]);
                  if (d2 - d3 > Math.PI) {
                    k--;
                    d4 = k * Constants.PI2;
                  } else if (d3 - d2 > Math.PI) {
                    k++;
                    d4 = k * Constants.PI2;
                  }
                  if (d1 > 0.0) {
                    d5 = Math.log(d1);
                  }
                  d2 += d4;
                  reOutBuf[ch][i] += (float) d5;
                  imOutBuf[ch][i] += (float) d2;
                  d3 = d2;
                }
                phi[ch] = d3;
                wrap[ch] = k;
                carry[ch] = d5;

              } else {
                for (i = 0; i < len; i++) {
                  f1 = convBuf1[i];
                  if (f1 > 0) {
                    reOutBuf[ch][i] += wetGain * (float) Math.log(f1);
                  } // else undefiniert
                }
              }
              break;

            case OP_EXP: // ================ Exp ================
              if (complex) {
                for (i = 0; i < len; i++) {
                  d1 = wetGain * Math.exp(convBuf1[i]);
                  reOutBuf[ch][i] += (float) (d1 * Math.cos(convBuf2[i]));
                  imOutBuf[ch][i] += (float) (d1 * Math.sin(convBuf2[i]));
                }
              } else {
                for (i = 0; i < len; i++) {
                  reOutBuf[ch][i] += wetGain * (float) Math.exp(convBuf1[i]);
                }
              }
              break;

            case OP_NOT: // ================ NOT ================
              for (i = 0; i < len; i++) {
                lo = ~((long) (convBuf1[i] * 2147483647.0));
                reOutBuf[ch][i] += wetGain * (float) ((lo & 0xFFFFFFFFL) / 2147483647.0);
              }
              if (complex) {
                for (i = 0; i < len; i++) {
                  lo = ~((long) (convBuf2[i] * 2147483647.0));
                  imOutBuf[ch][i] += wetGain * (float) ((lo & 0xFFFFFFFFL) / 2147483647.0);
                }
              }
              break;
          }
        } // for outChan
        progOff += len;
        // .... progress ....
        setProgression((float) progOff / (float) progLen);
        // .... check running ....
        if (!threadRunning) break topLevel;

        // ---- write output chunk ----
        if (reFloatF != null) {
          for (ch = 0; ch < outChanNum; ch++) {
            reFloatF[ch].writeFloats(reOutBuf[ch], 0, len);
            if (pr.bool[PR_HASIMOUTPUT]) {
              imFloatF[ch].writeFloats(imOutBuf[ch], 0, len);
            }
          }
        } else {
          reOutF.writeFrames(reOutBuf, 0, len);
          if (pr.bool[PR_HASIMOUTPUT]) {
            imOutF.writeFrames(imOutBuf, 0, len);
          }
        }
        // check max amp
        for (ch = 0; ch < outChanNum; ch++) {
          convBuf1 = reOutBuf[ch];
          for (i = 0; i < len; i++) {
            f1 = Math.abs(convBuf1[i]);
            if (f1 > maxAmp) {
              maxAmp = f1;
            }
          }
          if (pr.bool[PR_HASIMOUTPUT]) {
            convBuf1 = imOutBuf[ch];
            for (i = 0; i < len; i++) {
              f1 = Math.abs(convBuf1[i]);
              if (f1 > maxAmp) {
                maxAmp = f1;
              }
            }
          }
        }

        progOff += len;
        framesWritten += len;
        // .... progress ....
        setProgression((float) progOff / (float) progLen);
      } // while not framesWritten

      // ----==================== normalize output ====================----

      if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
        peakGain = new Param(maxAmp, Param.ABS_AMP);
        gain =
            (float)
                (Param.transform(
                        pr.para[PR_GAIN],
                        Param.ABS_AMP,
                        new Param(1.0 / peakGain.value, peakGain.unit),
                        null))
                    .value;
        f1 = pr.bool[PR_HASIMOUTPUT] ? ((1.0f + getProgression()) / 2) : 1.0f;
        normalizeAudioFile(reFloatF, reOutF, reOutBuf, gain, f1);
        if (pr.bool[PR_HASIMOUTPUT]) {
          normalizeAudioFile(imFloatF, imOutF, imOutBuf, gain, 1.0f);
        }
        maxAmp *= gain;

        for (ch = 0; ch < outChanNum; ch++) {
          reFloatF[ch].cleanUp();
          reFloatF[ch] = null;
          reTempFile[ch].delete();
          reTempFile[ch] = null;
          if (pr.bool[PR_HASIMOUTPUT]) {
            imFloatF[ch].cleanUp();
            imFloatF[ch] = null;
            imTempFile[ch].delete();
            imTempFile[ch] = null;
          }
        }
      }
      // .... check running ....
      if (!threadRunning) break topLevel;

      // ---- Finish ----

      reOutF.close();
      reOutF = null;
      reOutStream = null;
      if (imOutF != null) {
        imOutF.close();
        imOutF = null;
        imOutStream = null;
      }
      reInF.close();
      reInF = null;
      reInStream = null;
      if (pr.bool[PR_HASIMINPUT]) {
        imInF.close();
        imInF = null;
        imInStream = null;
      }
      reOutBuf = null;
      imOutBuf = null;
      reInBuf = null;
      imInBuf = null;

      // inform about clipping/ low level
      handleClipping(maxAmp);
    } catch (IOException e1) {
      setError(e1);
    } catch (OutOfMemoryError e2) {
      reOutBuf = null;
      imOutBuf = null;
      reInBuf = null;
      imInBuf = null;
      convBuf1 = null;
      convBuf2 = null;
      System.gc();

      setError(new Exception(ERR_MEMORY));
    }

    // ---- cleanup (topLevel) ----
    convBuf1 = null;
    convBuf2 = null;

    if (reInF != null) {
      reInF.cleanUp();
      reInF = null;
    }
    if (imInF != null) {
      imInF.cleanUp();
      imInF = null;
    }
    if (reOutF != null) {
      reOutF.cleanUp();
      reOutF = null;
    }
    if (imOutF != null) {
      imOutF.cleanUp();
      imOutF = null;
    }
    if (reFloatF != null) {
      for (ch = 0; ch < reFloatF.length; ch++) {
        if (reFloatF[ch] != null) {
          reFloatF[ch].cleanUp();
          reFloatF[ch] = null;
        }
        if (reTempFile[ch] != null) {
          reTempFile[ch].delete();
          reTempFile[ch] = null;
        }
      }
    }
    if (imFloatF != null) {
      for (ch = 0; ch < imFloatF.length; ch++) {
        if (imFloatF[ch] != null) {
          imFloatF[ch].cleanUp();
          imFloatF[ch] = null;
        }
        if (imTempFile[ch] != null) {
          imTempFile[ch].delete();
          imTempFile[ch] = null;
        }
      }
    }
  } // process()
Пример #5
0
 protected void compute() {
   n = (int) ni[0].parseInput();
   t0 = ni[1].parseInput();
   deltat = ni[2].parseInput();
   x1 = ni[3].parseInput();
   x2 = ni[4].parseInput();
   sigma = ni[5].parseInput();
   // generate data points
   t = new DatanVector(n);
   y = new DatanVector(n);
   dy = new DatanVector(n);
   rand = DatanRandom.standardNormal(n);
   for (int i = 0; i < n; i++) {
     t.setElement(i, t0 + (double) i * deltat);
     y.setElement(i, x1 * Math.pow(t.getElement(i), x2) + sigma * rand[i]);
     dy.setElement(i, sigma);
   }
   // find 1st approximation of unknowns by method of log-log plot
   tlog = new double[n];
   ylog = new double[n];
   dellog = new double[n];
   int npos = 0;
   for (int i = 0; i < n; i++) {
     if (t.getElement(i) > 0. && y.getElement(i) > 0.) {
       tlog[npos] = Math.log(t.getElement(i));
       ylog[npos] = Math.log(y.getElement(i));
       dellog[npos] = 1.;
       npos++;
     }
   }
   DatanVector vtlog = new DatanVector(npos);
   DatanVector vylog = new DatanVector(npos);
   DatanVector vdellog = new DatanVector(npos);
   for (int j = 0; j < npos; j++) {
     vtlog.setElement(j, tlog[j]);
     vylog.setElement(j, ylog[j]);
     vdellog.setElement(j, dellog[j]);
   }
   LsqPol lp = new LsqPol(vtlog, vylog, vdellog, 2);
   x = lp.getResult();
   x.setElement(0, Math.exp(x.getElement(0)));
   df.writeLine(" x = " + x.toString());
   // perform fit
   int[] list = {1, 1};
   powerlaw = new Powerlaw();
   LsqNon ln = new LsqNon(t, y, dy, x, list, powerlaw);
   x = ln.getResult();
   x1 = x.getElement(0);
   x2 = x.getElement(1);
   cov = ln.getCovarianceMatrix();
   delx1 = Math.sqrt(cov.getElement(0, 0));
   delx2 = Math.sqrt(cov.getElement(1, 1));
   rho = cov.getElement(1, 0) / (delx1 * delx2);
   m = ln.getChiSquare();
   p = 1. - StatFunct.cumulativeChiSquared(m, n - 1);
   // curve of fitted exponential
   xpl = new double[1001];
   ypl = new double[1001];
   dpl = (double) (n - 1) * deltat / 1000.;
   for (int i = 0; i < 1001; i++) {
     xpl[i] = t0 + (double) i * dpl;
     ypl[i] = x1 * Math.pow(xpl[i], x2);
   }
   // prepare data points for plotting
   datx = new double[n];
   daty = new double[n];
   datsx = new double[n];
   datsy = new double[n];
   datrho = new double[n];
   for (int i = 0; i < n; i++) {
     datx[i] = t.getElement(i);
     daty[i] = y.getElement(i);
     datsx[i] = 0.;
     datsy[i] = dy.getElement(i);
     datrho[i] = 0.;
   }
   // display data and fitted curve
   caption =
       "x_1#="
           + String.format(Locale.US, "%5.2f", x1)
           + ", x_2#="
           + String.format(Locale.US, "%5.2f", x2)
           + ", &D@x_1#="
           + String.format(Locale.US, "%5.2f", delx1)
           + ", &D@x_2#="
           + String.format(Locale.US, "%5.2f", delx2)
           + ", &r@="
           + String.format(Locale.US, "%5.2f", rho)
           + ", M="
           + String.format(Locale.US, "%5.2f", m)
           + ", P="
           + String.format(Locale.US, "%6.4f", p);
   new GraphicsWithDataPointsAndPolyline(
       getClass().getName(),
       "",
       xpl,
       ypl,
       1,
       .3,
       datx,
       daty,
       datsx,
       datsy,
       datrho,
       "t",
       "y",
       caption);
 }
Пример #6
0
 public double evaluate(double x) {
   return Math.log(x * x + 1) - Math.exp(0.4 * x) * Math.cos(Math.PI * x);
 }
Пример #7
0
 // handy static methods
 public static double log10(double val) {
   return Math.log(val) * LOG10SCALE;
 }
Пример #8
0
/**
 * Includes a static function for selecting and labeling graph axis tic labels. given a numeric
 * range and a maximum number of tics, this class can produce a list of labels with the nicest round
 * numbers not exceeding a given maximum number of labels. the label generation code was extracted
 * from the public domain <a href="http://ptolemy.eecs.berkeley.edu/">Ptolomy project</a> at UC
 * Berkeley, taken from ptolemy/plot/PlotBox.java.
 *
 * <p>We added another static method to compute and draw an axis into a given AWT Graphics object. i
 * extracted the code for producing linear labels and threw out the vast majority of code that
 * attempted to produce log scale labels since that code was very broken. it was noted int the
 * Ptolomy code that the log label generation was itself based on a file named xgraph.c by David
 * Harrisonmy, and the comments say that the original code breaks down in certain cases. my drawAxis
 * method can still draw nicely labeling log scale axes because i simply use the linear scale label
 * generation code from Ptolomy and plot the tics in their proper locations on a log scale. the
 * resulting code produced exactly the same results as the Ptolemy code for log scales in those
 * ranges where the Ptolemy code did work, so this design is much better in all cases and uses only
 * a fraction of the original complexity. still, it can probably be further improved though the
 * exact problem is not well defined.
 *
 * @author M.Green and S.Chekanov
 */
public class Axis {
  private static final boolean DEBUG = false;
  public static final int X_AXIS = 0, Y_AXIS = 1;
  // For use in calculating log base 10. A log times this is a log base 10.
  private static final double LOG10SCALE = 1 / Math.log(10);

  // handy static methods
  public static double log10(double val) {
    return Math.log(val) * LOG10SCALE;
  }

  public static double exp10(double val) {
    return Math.exp(val / LOG10SCALE);
  }

  public static float flog10(double val) {
    return (float) log10(val);
  }

  public static float fexp10(double val) {
    return (float) exp10(val);
  }

  /**
   * Calculation of the separation length between tics. Some smart rounding algorithms are needed to
   * get the scaling properly in case of data going to 10.3 or so... Useful stuff stolen from the
   * Gnuplot sources, thank you guys!!
   */
  public static double calculateTicSep(double min, double max, int maxNumberOfTicks) {
    double xnorm, tic, posns;
    double lrange = log10(Math.abs(min - max));
    double fl = Math.floor(lrange);
    xnorm = Math.pow(10.0, lrange - fl);
    posns = maxNumberOfTicks / xnorm;

    if (posns > 40) tic = 0.05; // eg 0, .05, .10, ...
    else if (posns > 20) tic = 0.1; // eg 0, .1, .2, ...
    else if (posns > 10) tic = 0.2; // eg 0,0.2,0.4,...
    else if (posns > 4) tic = 0.5; // 0,0.5,1,
    else if (posns > 1) tic = 1; // 0,1,2,....
    else if (posns > 0.5) tic = 2; // 0, 2, 4, 6
    else if (posns > 0.2) tic = 10; // 0, 10, 100, 6
    else tic = Math.ceil(xnorm);

    tic *= Math.pow(10.0, fl);

    return tic;
  }

  /** Precompute number of ticks */
  public static int calculateTicNumber(
      double ticMinVal, double ticMaxVal, double xStep, boolean isLog) {

    int n = 0;

    // System.out.println("\n-- calculateTicNumber=");
    // System.out.println("Min="+Double.toString(ticMinVal));
    // System.out.println("Max="+Double.toString(ticMaxVal));
    // System.out.println("Max="+Double.toString(xStep));

    if (isLog == false) {
      double xStart = xStep * Math.ceil(ticMinVal / xStep);
      for (double xpos = xStart; xpos <= ticMaxVal; xpos += xStep) n++;
    } else {
      int t1 = 0;
      int t2 = 0;
      if (ticMinVal > 0) t1 = (int) Math.floor(log10(ticMinVal) - 0.5);
      if (ticMinVal < 0) t1 = -1 * (int) Math.floor(log10(-1 * ticMinVal) - 0.5);
      if (ticMaxVal > 0) t2 = (int) Math.floor(log10(ticMaxVal) + 1.0);
      if (ticMaxVal < 0) t2 = -1 * (int) Math.floor(log10(-1 * ticMaxVal) + 1.0);
      for (int i = t1; i < t2 + 1; i++) n++;
    }

    // System.out.println("Nr of ticks="+Integer.toString(n));

    return n;
  }

  /**
   * this is the central method of this class. takes axis range parameters and produces a list of
   * string representations of nicely rounded numbers within the given range. these strings are
   * intended for use as axis tic labels. note: to find out where to plot each tic label simply use
   * <br>
   * <code>float ticval = Float.parseFloat(ticstring);</code>
   *
   * @param ticMinVal no tics will be created for less than this value.
   * @param ticMaxVal no tics will be created for greater than this value.
   * @param maxTics returned vector will contain no more labels than this number.
   * @param isLog set to true in case of log10 numbers
   * @return a Vector containing formatted label strings which should also be parsable into floating
   *     point numbers (in order to plot them).
   */
  public static Vector<String> computeTicks(
      double ticMinVal, double ticMaxVal, int maxTicks, boolean isLog) {
    // double xStep = roundUp((ticMaxVal-ticMinVal)/maxTicks);

    double xStep = calculateTicSep(ticMinVal, ticMaxVal, maxTicks);

    int numfracdigits = numFracDigits(xStep);

    // Compute x starting point so it is a multiple of xStep.
    double xStart = xStep * Math.ceil(ticMinVal / xStep);
    Vector xgrid = null;
    Vector<String> labels = new Vector<String>();
    // Label the axis. The labels are quantized so that
    // they don't have excess resolution.

    if (!isLog) {
      for (double xpos = xStart; xpos <= ticMaxVal; xpos += xStep) {
        String snum = formatNum(xpos, numfracdigits);
        labels.addElement(snum);
      }
      // log scale: special case
    } else {

      int t1 = 0;
      int t2 = 0;
      if (ticMinVal > 0) t1 = (int) Math.floor(log10(ticMinVal) - 0.5);
      if (ticMinVal < 0) t1 = -1 * (int) Math.floor(log10(-1 * ticMinVal) - 0.5);
      if (ticMaxVal > 0) t2 = (int) Math.floor(log10(ticMaxVal) + 1.0);
      if (ticMaxVal < 0) t2 = -1 * (int) Math.floor(log10(-1 * ticMaxVal) + 1.0);

      // System.out.println("min = " + xmin + ", max = " + xmax);
      for (int i = t1; i < t2 + 1; i++) {
        double pp = Math.pow(10.0, i);
        // System.out.println(pp);
        labels.addElement(Double.toString(pp));
      }
    }

    return labels;
  }

  /**
   * high-level method for drawing a chart axis line plus labeled tic marks. introduces a dependancy
   * on AWT because it takes a Graphics parameter. perhaps this method belongs in some higher-level
   * class but i added it here since it's highly related with the tic lable generation code.
   *
   * @author Melinda Green
   * @param axis is one of Axis.X_AXIS or Axis.Y_AXIS.
   * @param maxTics is the maximum number of labeled tics to draw. note: the actual number drawn may
   *     be less.
   * @param lowVal is the smallest value tic mark that may be drawn. note: the lowest valued tic
   *     label may be greater than this limit.
   * @param highVal is the largest value tic mark that may be drawn. note: the highest valued tic
   *     label may be less than this limit.
   * @param screenStart is the coordinate in the low valued direction.
   * @param screenEnd is the coordinate in the high valued direction.
   * @param offset is the coordinate in the direction perpendicular to the specified direction.
   * @param logScale is true if a log scale axis is to be drawn, false for a linear scale.
   * @param screenHeight is needed to flip Y coordinates.
   * @param g is the AWT Graphics object to draw into. note: all drawing will be done in the current
   *     color of the given Graphics object.
   */
  public static void drawAxis(
      int axis,
      int maxTics,
      int ticLength,
      float lowVal,
      float highVal,
      int screenStart,
      int screenEnd,
      int screenOffset,
      boolean logScale,
      int screenHeight,
      Graphics g) {
    if (logScale && (lowVal == 0 || highVal == 0))
      throw new IllegalArgumentException("Axis.drawAxis: zero range value not allowed in log axes");
    if (axis == X_AXIS) // horizontal baseline
    g.drawLine(screenStart, screenHeight - screenOffset, screenEnd, screenHeight - screenOffset);
    else
      // vertical baseline
      g.drawLine(screenOffset, screenStart, screenOffset, screenEnd);
    Vector tics = Axis.computeTicks(lowVal, highVal, maxTics, logScale); // nice
    // round
    // numbers
    // for
    // tic
    // labels
    int last_label_end = axis == X_AXIS ? -88888 : 88888;
    String dbgstr = "tics:    ";
    for (Enumeration e = tics.elements(); e.hasMoreElements(); ) {
      String ticstr = (String) e.nextElement();
      if (DEBUG) dbgstr += ticstr + ", ";
      float ticval = Float.parseFloat(ticstr);
      int tic_coord = screenStart;
      Dimension str_size = stringSize(ticstr, g);
      tic_coord +=
          plotValue(ticval, lowVal, highVal, screenStart, screenEnd, logScale, screenHeight);
      if (axis == X_AXIS) { // horizontal axis == vertical tics
        g.drawLine(
            tic_coord,
            screenHeight - screenOffset,
            tic_coord,
            screenHeight - screenOffset + ticLength);
        if (tic_coord - str_size.width / 2 > last_label_end) {
          g.drawString(
              ticstr,
              tic_coord - str_size.width / 2,
              screenHeight - screenOffset + str_size.height + 5);
          last_label_end = tic_coord + str_size.width / 2 + str_size.height / 2;
        }
      } else { // vertical axis == horizontal tics
        tic_coord = screenHeight - tic_coord; // flips Y coordinates
        g.drawLine(screenOffset - ticLength, tic_coord, screenOffset, tic_coord);
        if (tic_coord - str_size.height / 3 < last_label_end) {
          g.drawString(
              ticstr,
              screenOffset - ticLength - str_size.width - 5,
              tic_coord + str_size.height / 3);
          last_label_end = tic_coord - str_size.height;
        }
      }
    }
    if (DEBUG) System.out.println(dbgstr);
  } // end drawAxis

  /**
   * lower level method to determine a screen location where a given value should be plotted given
   * range, type, and screen information. the "val" parameter is the data value to be plotted
   *
   * @author Melinda Green
   * @param val is a data value to be plotted.
   * @return pixel offset (row or column) to draw a screen representation of the given data value.
   *     i.e. <i>where</i> along an axis in screen coordinates the caller should draw a
   *     representation of the given value.
   * @see drawAxis(int,int,int,float,float,int,int,int,boolean,int,Graphics)
   */
  public static int plotValue(
      float val,
      float lowVal,
      float highVal,
      int screenStart,
      int screenEnd,
      boolean logScale,
      int screenHeight) {
    if (logScale && (lowVal == 0 || highVal == 0 || val == 0))
      throw new IllegalArgumentException("Axis.drawAxis: zero range value not allowed in log axes");
    int screen_range = screenEnd - screenStart; // in pixels
    if (logScale) {
      float log_low = flog10(lowVal), log_high = flog10(highVal), log_val = flog10(val);
      float log_range = log_high - log_low;
      float pixels_per_log_unit = screen_range / log_range;
      return (int) ((log_val - log_low) * pixels_per_log_unit + .5);
    } else {
      float value_range = highVal - lowVal; // in data value units
      float pixels_per_unit = screen_range / value_range;
      return (int) ((val - lowVal) * pixels_per_unit + .5);
    }
  }

  /*
   * Given a number, round up to the nearest power of ten times 1, 2, or 5.
   *
   * Note: The argument must be strictly positive.
   */
  private static double roundUp(double val) {
    int exponent = (int) Math.floor(log10(val));
    val *= Math.pow(10, -exponent);
    if (val > 5.0) val = 10.0;
    else if (val > 2.0) val = 5.0;
    else if (val > 1.0) val = 2.0;
    val *= Math.pow(10, exponent);
    return val;
  }

  /*
   * Return the number of fractional digits required to display the given
   * number. No number larger than 15 is returned (if more than 15 digits are
   * required, 15 is returned).
   */
  private static int numFracDigits(double num) {
    int numdigits = 0;
    while (numdigits <= 15 && num != Math.floor(num)) {
      num *= 10.0;
      numdigits += 1;
    }
    return numdigits;
  }

  // Number format cache used by formatNum.
  // Note: i'd have put the body of the formatNum method below into
  // a synchronized block for complete thread safety but that causes
  // an abscure null pointer exception in the awt event thread.
  // go figure.
  private static NumberFormat numberFormat = null;

  /*
   * Return a string for displaying the specified number using the specified
   * number of digits after the decimal point. NOTE: java.text.NumberFormat is
   * only present in JDK1.1 We use this method as a wrapper so that we can
   * cache information.
   */
  private static String formatNum(double num, int numfracdigits) {
    if (numberFormat == null) {
      // Cache the number format so that we don't have to get
      // info about local language etc. from the OS each time.
      // numberFormat = NumberFormat.getInstance();
      numberFormat = NumberFormat.getInstance(Locale.ENGLISH);
      // force to not include commas because we want the strings
      // to be parsable back into numeric values. - DRG
      numberFormat.setGroupingUsed(false);
    }
    numberFormat.setMinimumFractionDigits(numfracdigits);
    numberFormat.setMaximumFractionDigits(numfracdigits);
    return numberFormat.format(num);
  }

  /**
   * handy little utility for determining the length in pixels the given string will use if drawn
   * into the given Graphics object. Note: perhaps belongs in some utility package.
   */
  public static Dimension stringSize(String str, Graphics g) {
    if (g instanceof Graphics2D) {
      java.awt.geom.Rectangle2D bounds =
          g.getFont().getStringBounds(str, ((Graphics2D) g).getFontRenderContext());
      return new Dimension((int) (bounds.getWidth() + .5), (int) (bounds.getHeight() + .5));
    } else
      return new Dimension(g.getFontMetrics().stringWidth(str), g.getFontMetrics().getHeight());
  }

  //
  // TEST CODE FROM HERE DOWN
  //

  private static class TestPanel extends JPanel {
    private float curLowVal, curHighVal;
    private boolean logScale;

    public TestPanel(float initialLow, float initialHigh) {
      curLowVal = initialLow;
      curHighVal = initialHigh;
    }

    public void setLogScale(boolean logScale) {
      this.logScale = logScale;
      repaint();
    }

    public void setLow(float val) {
      curLowVal = val;
      repaint();
    }

    public void setHigh(float val) {
      curHighVal = val;
      repaint();
    }

    public void paint(Graphics g) {
      super.paint(g);
      drawAxis(
          Axis.X_AXIS,
          10,
          5,
          curLowVal,
          curHighVal,
          50,
          getWidth() - 50,
          50,
          logScale,
          getHeight(),
          g);
      drawAxis(
          Axis.Y_AXIS,
          10,
          5,
          curLowVal,
          curHighVal,
          50,
          getHeight() - 50,
          50,
          logScale,
          getHeight(),
          g);
      g.drawString("Current Slider Range: " + curLowVal + " --> " + curHighVal, 10, 20);
    }
  }

  private static void addField(
      Container into,
      Component c,
      GridBagConstraints gbc,
      int x,
      int y,
      int w,
      int h,
      int wx,
      int wy) {
    gbc.gridx = x;
    gbc.gridy = y;
    gbc.gridwidth = w;
    gbc.gridheight = h;
    gbc.weightx = wx;
    gbc.weighty = wy;
    into.add(c, gbc);
  }

  /** simple example program for Axis class. */
  public static void main(String args[]) {

    /*
     * final float INITIAL_MIN_LOW=1, INITIAL_MAX_HIGH=1000; final TestPanel
     * axis = new TestPanel(INITIAL_MIN_LOW, INITIAL_MAX_HIGH); final JFrame
     * frame = new JFrame("Axis Test"); JPanel mainpanel = new JPanel(new
     * BorderLayout()); mainpanel.add("Center", axis); JPanel controls = new
     * JPanel(); final JCheckBox logScale = new JCheckBox("Log");
     * logScale.addActionListener(new ActionListener() { public void
     * actionPerformed(ActionEvent ae) {
     * axis.setLogScale(logScale.isSelected()); } });
     * logScale.setSelected(true); axis.setLogScale(true);
     *
     * final JTextField minlow = new JTextField(""+INITIAL_MIN_LOW, 6);
     * final FloatSlider lowSlider = new FloatSlider(JSlider.HORIZONTAL,
     * INITIAL_MIN_LOW, 100, 1, 1000, 2000, false); final FloatSlider
     * highSlider = new FloatSlider(JSlider.HORIZONTAL, INITIAL_MAX_HIGH,
     * 100, 1, 1000, 2000, false); final JTextField maxhigh = new
     * JTextField(""+INITIAL_MAX_HIGH, 6); GridBagLayout gridbag = new
     * GridBagLayout(); controls.setLayout(gridbag); GridBagConstraints con
     * = new GridBagConstraints(); con.fill = GridBagConstraints.BOTH;
     * con.insets = new Insets(0, 10, 0, 0); addField(controls, logScale,
     * con, 0, 0, 1, 1, 5, 100); addField(controls, new
     * JLabel("min low value"), con, 1, 0, 1, 1, 10, 100);
     * addField(controls, minlow, con, 2, 0, 1, 1, 10, 100);
     * addField(controls, lowSlider, con, 3, 0, 1, 1, 50, 100);
     * addField(controls, highSlider, con, 4, 0, 1, 1, 50, 100);
     * addField(controls, new JLabel("max high value"), con, 5, 0, 1, 1, 10,
     * 100); addField(controls, maxhigh, con, 6, 0, 1, 1, 10, 100);
     * mainpanel.add("South", controls); KeyListener limitsWatcher = new
     * KeyAdapter() { public void keyTyped(KeyEvent ke) { if(ke.getKeyChar()
     * == KeyEvent.VK_ENTER) { float newminlow =
     * Float.parseFloat(minlow.getText()); float newmaxhigh =
     * Float.parseFloat(maxhigh.getText()); lowSlider.setAll(newminlow,
     * newmaxhigh, lowSlider.getFloatValue()); highSlider.setAll(newminlow,
     * newmaxhigh, highSlider.getFloatValue()); } } };
     * minlow.addKeyListener(limitsWatcher);
     * maxhigh.addKeyListener(limitsWatcher); AdjustmentListener
     * slider_watcher = new AdjustmentListener() { public void
     * adjustmentValueChanged(AdjustmentEvent ae) { if (ae.getSource() ==
     * lowSlider) axis.setLow((float)lowSlider.getFloatValue()); else
     * axis.setHigh((float)highSlider.getFloatValue()); } };
     * lowSlider.addAdjustmentListener(slider_watcher);
     * highSlider.addAdjustmentListener(slider_watcher);
     * frame.getContentPane().add(mainpanel); frame.setSize(new
     * Dimension(1000, 400));
     * frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     * frame.setVisible(true);
     */
  } // end main
}