scaledborder.java

著名的神经网络工具箱

                  inner_insets.left, inner_insets.top - y_values2arrow - arrow_length );
      g.drawLine( inner_insets.left + marker_length, inner_insets.top - y_values2arrow,
                  inner_insets.left, inner_insets.top - y_values2arrow - arrow_length);
      g.drawLine( inner_insets.left - marker_length, inner_insets.top - y_values2arrow,
                  inner_insets.left + marker_length, inner_insets.top - y_values2arrow );

      g.drawLine( inner_insets.left + cd.width , inner_insets.top + cd.height,
                  inner_insets.left + cd.width + x_values2arrow, inner_insets.top + cd.height );
      g.drawLine( inner_insets.left + cd.width + x_values2arrow,
                  inner_insets.top + cd.height - marker_length,
                  inner_insets.left + cd.width + x_values2arrow + arrow_length,
                  inner_insets.top + cd.height );
      g.drawLine( inner_insets.left + cd.width + x_values2arrow,
                  inner_insets.top + cd.height + marker_length,
                  inner_insets.left + cd.width + x_values2arrow + arrow_length,
                  inner_insets.top + cd.height );
      g.drawLine( inner_insets.left + cd.width + x_values2arrow,
                  inner_insets.top + cd.height - marker_length,
                  inner_insets.left + cd.width + x_values2arrow,
                  inner_insets.top + cd.height + marker_length );
    }

    if( y_label != null ) {
      Dimension yld = new Dimension(fm.getAscent()+fm.getDescent(), fm.stringWidth(y_label));
      AffineTransform T = new AffineTransform(0, -1, 1, 0, 0, 0);
      Font old = g.getFont(), f = old.deriveFont( T );
      g.setFont( f );
      g.drawString( y_label, y_label2border + fm.getAscent(), inner_insets.top + ( cd.height + yld.height )/ 2 );
      g.setFont( old );
    }

    if( x_label != null )
      g.drawString(
        x_label, inner_insets.left + ( cd.width - fm.stringWidth( x_label ) ) / 2,
        d.height - outer_insets.bottom - x_label2border - fm.getDescent() );

    if( src_rect.x == 0 && src_rect.y == 0 ){
      int v2m = fm.stringWidth("0") / y_values2marker;
      g.drawString( "0", inner_insets.left - fm.stringWidth( "0" ) - v2m - marker_length,
                         inner_insets.top + cd.height + fontAsc );
      g.drawLine( inner_insets.left, inner_insets.top + cd.height + fm.getAscent(),
                  inner_insets.left, inner_insets.top + cd.height);
      g.drawLine( inner_insets.left, inner_insets.top + cd.height,
                  inner_insets.left - fm.stringWidth( "0" ) - v2m - marker_length,
                  inner_insets.top + cd.height );
    }

    drawYValues( g, inner_insets, cd );
    drawXValues( g, inner_insets, cd );

    g.setColor( old_color );
  }

  private void drawYValues( Graphics g, Insets insets, Dimension cd ){
    if( under_construction ) System.out.println("ScaledBorder.drawYValues()");

    FontMetrics fm = g.getFontMetrics();
    int n, fontAsc = fm.getAscent(), v2m = fm.stringWidth("0") / y_values2marker;
    n = (int)( src_rect.y / src_dY );
    if( n * src_dY < src_rect.y || ( src_rect.x == 0 && src_rect.y == 0 ) ) n++;


    double v, minx = src_rect.x;
    if( x_scale != null ) minx = x_scale.getImageOf( minx );
    for(; (v = n * src_dY) <= src_rect.y + src_rect.height; n++ ){
      if( y_scale != null ) v = y_scale.getImageOf( v );
      String text = format_y.format(v);
      try{ v = format_y.parse(text).doubleValue(); }
      catch( java.text.ParseException ex ){ }
      Point p = m.getPoint( minx, v );
      if( p != null ){
        g.drawString( text,
                      insets.left - fm.stringWidth( text ) - v2m - marker_length,
                      p.y  + fontAsc / 2 );
        g.drawLine( insets.left - marker_length, p.y, insets.left, p.y );
      }
    }
  }

  public double getSrcdY( FontMetrics fm, Dimension cd ){
    if( under_construction ) System.out.println("ScaledBorder.getSrcdY()");
    if( (!do_refresh && src_dY != -1) || !auto_scale_y ) return src_dY;
    int max = cd.height / fm.getHeight();
    double minsrc_dY = 2 * src_rect.height / (double)max; // die 2 einfach mal so eingesetzt   <--------------------------
    src_dY = aBitBigger( minsrc_dY );
    if( src_dY < minimal_increment ) src_dY = minimal_increment;
    return src_dY;
  }

  private void drawXValues( Graphics g, Insets insets, Dimension cd ){
    if( under_construction ) System.out.println("ScaledBorder.drawXValues()");

    FontMetrics fm = g.getFontMetrics();
    double mx = cd.width / src_rect.width;
    int n, labelX,
        xnull = insets.left + (int)( - src_rect.x * mx );

    n = (int)( src_rect.x / src_dX );
    if( n * src_dX < src_rect.x || ( src_rect.x == 0 && src_rect.y == 0 ) ) n++;

    int fontAsc = fm.getAscent(), xLineY = insets.top + cd.height;
    labelX = xnull + (int)(n * src_dX * mx);
    while( n * src_dX <= src_rect.x + src_rect.width ){
      double v = n * src_dX;
      if( x_scale != null ) v = x_scale.getImageOf(v);
      String text = format_x.format(v);
      try{ v = format_x.parse(text).doubleValue(); }
      catch( java.text.ParseException ex ){ }
      int strW = fm.stringWidth( text );
      g.drawString( text, labelX - strW / 2, xLineY + fontAsc );
      g.drawLine( labelX, xLineY, labelX, xLineY + marker_length );
      n++;
      labelX = xnull + (int)( n * src_dX * mx);
    }
  }

  public double getSrcdX( FontMetrics fm, Dimension cd ){
    if( under_construction ) System.out.println("ScaledBorder.getSrcdX()");
    if( (!do_refresh && src_dX != - 1) || !auto_scale_x ) return src_dX;
    int digit_width = fm.stringWidth("0"),
        max = cd.width / ( digit_width * ( x_value2value + 1 ) );
    src_dX = src_rect.width / (double)max;
    int n, labelX, olsrc_dX;

    boolean ok = false;
    while( !ok ){
      src_dX = aBitBigger( src_dX );

      n = (int)( src_rect.x / src_dX );
      if( n * src_dX < src_rect.x ) n++;

      olsrc_dX = 0;

      boolean suits = true, first = true;
      while( suits && n * src_dX <= src_rect.x + src_rect.width ){
        double v = n * src_dX;
        if( x_scale != null ) v = x_scale.getImageOf( v );
        String text = format_x.format(v);
        int strW = fm.stringWidth( text );
        labelX = (int)((( n * src_dX - src_rect.x ) / src_rect.width ) * cd.width ) - strW / 2;
        if( !first && labelX <= olsrc_dX + digit_width * x_value2value ) suits = false;
        else{
          olsrc_dX = labelX + strW;
          n++;
        }
        first = false;
      }
      if( !suits ) ok = false;
      else ok = true;
    }
    if( src_dX < minimal_increment ) src_dX = minimal_increment;
    return src_dX;
  }

  /**
   * method returns to a certain minimal value the next higher value which can be
   * displayed, which looks a bit nicer
   * it returns values like ... 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, ...
   *
   * @param the double value next to which the displayable value should be found
   * @return the displayable value
   */
  public static double aBitBigger( double min ){
    if( min <= 0 ) return 1;
    double d = 1;
    if( min < d ){
      while( d * .5 > min ) {
        d *= .5;
        if( d * .4 > min ) d *= .4;
        if( d * .5 > min ) d *= .5;
      }
    }
    else{
      while( d <= min ) {
        d *= 2;
        if( d <= min ) d *= 2.5;
        if( d <= min ) d *= 2;
      }
    }
    return d;
  }

  public boolean isBorderOpaque(){
    return outer_border.isBorderOpaque();
  }

  private String stringOf( double v ){
    if( (int)v == v ) return String.valueOf( (int)v );
    return String.valueOf( v );
  }

  public Insets getBorderInsets(Component c){
    if( under_construction ) System.out.println("ScaledBorder.getBorderInsets()");
    if( !do_refresh && old_insets != null ) return old_insets;

    Graphics g = c.getGraphics();

    Insets insets = new Insets(0, 0, 0, 0);
    if( show_outer_border ) insets = outer_border.getBorderInsets( c );

    if( g == null ) return insets;

    FontMetrics fm = g.getFontMetrics();
    int fontAsc = fm.getAscent(),
        fontHeight = fm.getHeight(),
        digit_width = fm.stringWidth("0");

    if( c instanceof DArea ){
      DArea area = (DArea)c;
      DMeasures m = area.getDMeasures();
      DRectangle rect = m.getSourceOf( area.getDRectangle() );
      src_rect = (DRectangle)rect.clone();
      x_scale = area.getDMeasures().x_scale;
      y_scale = area.getDMeasures().y_scale;
    }

    // left:
    if( y_label != null ) insets.left += fm.getAscent() + fm.getDescent();
    insets.left += y_label2values * digit_width;
    getSrcdY( fm, c.getSize() );
    int n, maxWidth = 0;
    n = (int)( src_rect.y / src_dY );
    if( n * src_dY < src_rect.y ) n++;
    while( n * src_dY <= src_rect.y + src_rect.height ){
      double v = n * src_dY;
      if( y_scale != null ) v = y_scale.getImageOf( v );
      int w = fm.stringWidth( format_y.format(v) );
      if( w > maxWidth ) maxWidth = w;
      n++;
    }
    insets.left += 1 + y_label2border + maxWidth + digit_width / y_values2marker + marker_length;

    // bottom:
    insets.bottom += 1 + fontHeight + x_label2border;
    if( x_label != null ) insets.bottom += fontHeight;

    // top:
    if( show_arrows ) insets.top += y_values2arrow + arrow_length;
    insets.top += axis2border;

    // right:
    if( show_arrows ) insets.right += x_values2arrow + arrow_length;
    insets.right += axis2border;
    getSrcdX( fm, c.getSize() );
    n = (int)( src_rect.x + src_rect.width / src_dX );
    if( n < 0 ) n ++;
    int w = fm.stringWidth( format_x.format(n * src_dX) );
    if( w / 2 > insets.right ) insets.right = w / 2;

    old_insets = insets;
    return insets;
  }
}

/****************************************************************************
 * END OF FILE
 ****************************************************************************/