`
woshixushigang
  • 浏览: 576085 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类

通过创建一个位图的XY Chart来学习Android绘图类Rect,Paint,Bitmap,Canvas（附源码）

AndroidFPGoJavaScriptOS 
阅读更多

通过创建一个位图的XY Chart来学习Android绘图类Rect,Paint,Bitmap,Canvas（附源码）

　　绘制一个XY集是一种很常见的任务,基于Android平台的绘制很简单，它让所有的GUI在XML中定义的（虽然它也可以通过代码创建）模型是相当不错的。大部分的图形处理一个样本查看，但在大多数情况下，图应该是一个部分的实施走上屏幕布局XML定义为一所以在这里展示我们ImageView布局对象。

　　在Android环境中，有一整套程序的图形通常是位图实现像素，Canvas是用来绘制位图的画布，通过这一点我们可以得出元（文字，线条等）它描述了漆的颜色，款式等。

 下面是效果图

　　图形界面我们通过Xml定义。

　　1.XML的GUI布局 

<?xml version="1.0" encoding="utf-8"?>

<TableLayout

    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_height="fill_parent"
    android:layout_width="fill_parent"
    android:background="#4B088A">
 
    <TableRow android:layout_width="fill_parent"
    android:layout_height="wrap_content"
     android:padding="20px">
  
     <TextView 
android:id="@+id/some"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="Some layout  items here"
    android:layout_marginLeft="10px"
    android:layout_marginRight="10px"
    android:textColor="#ff8000"
    android:textStyle="bold"
    />

    </TableRow>

<View    
  android:layout_width="fill_parent"
android:layout_height="1dip"
android:background="#FFE6E6E6"
/>
   
    <TableRow>

    <ImageView 
android:id="@+id/testy_img"
android:layout_marginLeft="20px"
android:padding="20px"
    />

   </TableRow>

<View    
  android:layout_width="fill_parent"
android:layout_height="1dip"
android:background="#FFE6E6E6" />

    <TableRow android:layout_width="fill_parent"

    android:layout_height="wrap_content"
     android:padding="20px">

     <TextView 
android:id="@+id/more"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="More layout items here"
    android:layout_marginLeft="10px"
    android:layout_marginRight="10px"
   android:textColor="#ff8000"
    android:textStyle="bold"
    />

    </TableRow>

</TableLayout>

 

这个布局文件是TableLayout布局，它定义了三行，行之间通过一条线割开

 

2.图表的实现

　　为了实现我们的图表，我们首先创建一个位图，然后关联到我们的布局文件，有了位图，我们就可以绘制图表，做缩放，色彩和数据显示 等效果。

 

　　2.1绘制位图

　　首先我们使布局连接到XML对象的，那么我们创建位图。我们通过quicky_XY方法来实现所有的绘制，最后显示在屏幕上。

public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);

  ImageView image = (ImageView) findViewById(R.id.testy_img);

  Bitmap emptyBmap = Bitmap.createBitmap(250, 200, Config.ARGB_8888);

  int width = emptyBmap.getWidth();
  int height = emptyBmap.getHeight();
  Bitmap charty = Bitmap.createBitmap(width, height,
    Bitmap.Config.ARGB_8888);

  charty = quicky_XY(emptyBmap);

  image.setImageBitmap(charty);
 }

 

　　2.2绘制网格

　　有了位图后，将它与Canvas相关联

　　Canvas canvas = new Canvas(bitmap)

然后将所有的元素绘制到Canvas上，我们需要定义一些用于放置标签和数据点空间的网格。

public static void draw_the_grid(Canvas this_g, Vector these_labels) {
  double rounded_max = 0.0;
  double rounded_min = 0.0;
  double rounded_max_temp;
  Object curElt;
  String[] cur_elt_array;
  int left_margin_d, right_margin_d;

  if (draw_only_this_idx == -1)
   curElt = these_labels.elementAt(0); // default it to 1st one if non
  // set
  else
   curElt = these_labels.elementAt(draw_only_this_idx); // now just the
  // 1st elt

  cur_elt_array = (String[]) curElt;

  rounded_max = get_ceiling_or_floor(
    Double.parseDouble(cur_elt_array[2]), true);
  rounded_min = get_ceiling_or_floor(
    Double.parseDouble(cur_elt_array[3]), false);

  // ok so now we have the max value of the set just get a cool ceiling
  // and we go on
  final Paint paint = new Paint();
  paint.setTextSize(15);

  left_margin_d = getCurTextLengthInPixels(paint, Double
    .toString(rounded_max));
  // keep the position for later drawing -- leave space for the legend
  int p_height = 170;
  int p_width = 220;
  int[] tmp_draw_sizes = { 2 + left_margin_d, 25,
    p_width - 2 - left_margin_d, p_height - 25 - 5 };
  drawSizes = tmp_draw_sizes; // keep it for later processing

  // with the mzrgins worked out draw the plotting grid
  paint.setStyle(Paint.Style.FILL);
  paint.setColor(Color.WHITE);

  // Android does by coords
  this_g
    .drawRect(drawSizes[0], drawSizes[1], drawSizes[0]
      + drawSizes[2], drawSizes[1] + drawSizes[3], paint);

  paint.setColor(Color.GRAY);

  // finally draw the grid

  paint.setStyle(Paint.Style.STROKE);
  this_g
    .drawRect(drawSizes[0], drawSizes[1], drawSizes[0]
      + drawSizes[2], drawSizes[1] + drawSizes[3], paint);

  for (int i = 1; i < 5; i++) {
   this_g.drawLine(drawSizes[0],
     drawSizes[1] + (i * drawSizes[3] / 5), drawSizes[0]
       + drawSizes[2], drawSizes[1]
       + (i * drawSizes[3] / 5), paint);
   this_g.drawLine(drawSizes[0] + (i * drawSizes[2] / 5),
     drawSizes[1], drawSizes[0] + (i * drawSizes[2] / 5),
     drawSizes[1] + drawSizes[3], paint);
  }

  // good for one value
  print_axis_values_4_grid(this_g, cur_elt_array[1], Double
    .toString(rounded_max), Double.toString(rounded_min),
    cur_elt_array[0], 2, 0);

 } // --- end of draw_grid ---

 

　　2.3绘图和缩放

　　　　这些数据点需要一到屏幕上的坐标数据范围正确的映射遍历数据点和调用drawLine接连两个点会完成我们的图表。数据点通过数据为载体，现在将调用plot_array_list

private static Point  scale_point(int this_x , double this_y  , Point drawPoint ,
            int scr_x  , int scr_y  , int scr_width  , int src_height  ,
            double maxX  , double minX  , double  maxY  , double minY  )
       {
           int temp_x, temp_y;
           Point temp = new Point();  
          
           if (maxY == minY)  //skip bad data
               return null;

           //don't touch it if is nothing
           try
           {
                   temp_x = scr_x + (int)( ((double)this_x - minX) *
((double)scr_width / (maxX - minX)) );
                   temp_y = scr_y + (int)( (maxY - this_y) *
((double)src_height / (maxY - minY)) );
               
                   temp.x = temp_x;
                   temp.y= temp_y;
                   drawPoint = temp;
           }
           catch  (Exception e)
           {
       
              return (null);
           }
          
           return temp;
          
       } // --- end of scale_point --


    public static boolean plot_array_list(Canvas this_g, Vector this_array_list ,
Vector these_labels , String this_title , int only_this_idx )
    {
             int idx;
             int lRow ;
             int nParms;
             int  i, points_2_plot, shifted_idx ;
             int prev_x, prev_y ;
             int cur_x=0, cur_y=0 ;
             //Dim ShowMarker As Object
             Point cur_point = new Point();
            cur_point.set(0,0);
    
             double cur_maxX, cur_minX, cur_maxY=20, cur_minY=0, cur_rangeY;
             int cur_start_x, cur_points_2_plot;
  
            int POINTS_TO_CHANGE = 30;
            double cur_OBD_val;
 
             //Object curElt; 
             String curElt;
             String[] cur_elt_array;
             Object curElt2; 
             String[] cur_elt_array2;
    
             final Paint paint = new Paint();

             try // catch in this block for some thing
             {      
                   points_2_plot = this_array_list.size();
                   {
                        cur_start_x = 0;
                        cur_points_2_plot = points_2_plot;
                        cur_maxX = cur_points_2_plot;
                        cur_minX = 0;
                   }
 
                   //'Create the plot points for this series from the ChartPoints array:
  
                   curElt = (String)this_array_list.elementAt(0);
                  
                   //the lines have to come out good
                    paint.setStyle(Paint.Style.STROKE);
//                 
                   //for(  nParms = 0 ; nParms < cur_elt_array.length ; nParms++ )
                   nParms = only_this_idx;
                   {
   
                       //get cur item labels
                        curElt2 = these_labels.elementAt(nParms);
                        cur_elt_array2  = (String[]) curElt2;
                       
                        cur_maxY = get_ceiling_or_floor
(Double.parseDouble(cur_elt_array2[2]) , true);
                        cur_minY = get_ceiling_or_floor
(Double.parseDouble(cur_elt_array2[3]) , false);
                       
                        cur_points_2_plot = this_array_list.size();
                        cur_maxX = cur_points_2_plot;
   
                      curElt = (String)this_array_list.elementAt(0);
                      cur_OBD_val = Double.parseDouble( curElt);
                     
                      cur_point = scale_point(0, cur_OBD_val, cur_point,
                              drawSizes[0], drawSizes[1], drawSizes[2], drawSizes[3],
                              cur_maxX, cur_minX, cur_maxY,
      cur_minY); //'(CInt(curAxisValues.Mins(nParms - 2) / 5) + 1) * 5)
                      
                       cur_x = cur_point.x;
                       cur_y = cur_point.y;

                       paint.setColor(Color.GREEN);
                      
                      // the point is only cool when samples are low
                       if ( cur_points_2_plot < POINTS_TO_CHANGE)
                         this_g.drawRect(cur_x-2, cur_y-2, cur_x-2 + 4,
cur_y-2+ 4 , paint);
                      
                       prev_x = cur_x;
                       prev_y = cur_y;

                       //'go and plot point for this parm -- pont after the 1st one
                       for (lRow = cur_start_x +1 ; lRow< cur_start_x +
cur_points_2_plot -1 ; lRow++)
                       {       
                           curElt = (String)this_array_list.elementAt(lRow);
                          
                           cur_OBD_val = Double.parseDouble( curElt);
                                
                            //'work out an approx if cur Y values not avail(e.g. nothing)
                           // if (! (cur_elt_array[nParms ] == null ) )   //skip bad one
                             if( cur_OBD_val == Double.NaN) continue;  //skip bad one
                            {                 
      
                              
                                cur_point=scale_point(lRow, cur_OBD_val, cur_point, 
                                    drawSizes[0], drawSizes[1],
drawSizes[2], drawSizes[3],
                                    cur_maxX, cur_minX, cur_maxY, cur_minY);
   
                                cur_x = cur_point.x;
                                cur_y = cur_point.y;
                               
                                if ( cur_points_2_plot < POINTS_TO_CHANGE)
                                   this_g.drawRect(cur_x-2, cur_y-2, cur_x-2 +4,
cur_y-2 + 4, paint );

                               this_g.drawLine( prev_x, prev_y, cur_x, cur_y, paint);
                               prev_x = cur_x;
                               prev_y = cur_y;
                         
                            } // ' if end of this_array(lRow, nParms - 1)<> nothing
                                
                   } // end of for lrow
                              
               } // end of for nParmns

            //this_g.invalidate();
            return( true);
        }
        catch (Exception e)
        {
            return( false);
        }

    } // --- end of plot_array_list  --

 

Java完整代码：

package com.wjq.chart;

import java.util.Vector;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Typeface;
import android.graphics.Bitmap.Config;
import android.graphics.Paint.FontMetrics;
import android.os.Bundle;
import android.widget.ImageView;

public class Main extends Activity {
 static int draw_only_this_idx = -1;
 static int[] drawSizes;

 @Override
 public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);

  ImageView image = (ImageView) findViewById(R.id.testy_img);

  Bitmap emptyBmap = Bitmap.createBitmap(250, 200, Config.ARGB_8888);

  int width = emptyBmap.getWidth();
  int height = emptyBmap.getHeight();
  Bitmap charty = Bitmap.createBitmap(width, height,
    Bitmap.Config.ARGB_8888);

  charty = quicky_XY(emptyBmap);

  image.setImageBitmap(charty);
 }

 public static Bitmap quicky_XY(Bitmap bitmap) {
  // xode to get bitmap onto screen
  Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap
    .getHeight(), Config.ARGB_8888);
  Canvas canvas = new Canvas(output);

  final int color = 0xff0B0B61;
  final Paint paint = new Paint();
  final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
  final RectF rectF = new RectF(rect);
  final float roundPx = 12;

  // get the little rounded cornered outside
  paint.setAntiAlias(true);
  canvas.drawARGB(0, 0, 0, 0);
  paint.setColor(color);
  canvas.drawRoundRect(rectF, roundPx, roundPx, paint);

  // ---- NOw just draw on this bitmap

  // Set the labels info manually
  String[] cur_elt_array = new String[4];
  cur_elt_array[0] = "Voltage";
  cur_elt_array[1] = "volts";
  cur_elt_array[2] = "93"; // max
  cur_elt_array[3] = "0"; // min

  Vector labels = new Vector();
  labels.add(cur_elt_array);

  draw_the_grid(canvas, labels);

  // se the data to be plotted and we should on our way

  Vector data_2_plot = new Vector();

  data_2_plot.add("0.2");
  data_2_plot.add("1.2");
  data_2_plot.add("9.6");
  data_2_plot.add("83.2");
  data_2_plot.add("44.2");
  data_2_plot.add("20.2");
  data_2_plot.add("16.2");

  plot_array_list(canvas, data_2_plot, labels, "the title", 0);

  canvas.drawBitmap(bitmap, rect, rect, paint);

  return output;
 }

 public static void draw_the_grid(Canvas this_g, Vector these_labels) {
  double rounded_max = 0.0;
  double rounded_min = 0.0;
  double rounded_max_temp;
  Object curElt;
  String[] cur_elt_array;
  int left_margin_d, right_margin_d;

  if (draw_only_this_idx == -1)
   curElt = these_labels.elementAt(0); // default it to 1st one if non
  // set
  else
   curElt = these_labels.elementAt(draw_only_this_idx); // now just the
  // 1st elt

  cur_elt_array = (String[]) curElt;

  rounded_max = get_ceiling_or_floor(
    Double.parseDouble(cur_elt_array[2]), true);
  rounded_min = get_ceiling_or_floor(
    Double.parseDouble(cur_elt_array[3]), false);

  // ok so now we have the max value of the set just get a cool ceiling
  // and we go on
  final Paint paint = new Paint();
  paint.setTextSize(15);

  left_margin_d = getCurTextLengthInPixels(paint, Double
    .toString(rounded_max));
  // keep the position for later drawing -- leave space for the legend
  int p_height = 170;
  int p_width = 220;
  int[] tmp_draw_sizes = { 2 + left_margin_d, 25,
    p_width - 2 - left_margin_d, p_height - 25 - 5 };
  drawSizes = tmp_draw_sizes; // keep it for later processing

  // with the mzrgins worked out draw the plotting grid
  paint.setStyle(Paint.Style.FILL);
  paint.setColor(Color.WHITE);

  // Android does by coords
  this_g
    .drawRect(drawSizes[0], drawSizes[1], drawSizes[0]
      + drawSizes[2], drawSizes[1] + drawSizes[3], paint);

  paint.setColor(Color.GRAY);

  // finally draw the grid

  paint.setStyle(Paint.Style.STROKE);
  this_g
    .drawRect(drawSizes[0], drawSizes[1], drawSizes[0]
      + drawSizes[2], drawSizes[1] + drawSizes[3], paint);

  for (int i = 1; i < 5; i++) {
   this_g.drawLine(drawSizes[0],
     drawSizes[1] + (i * drawSizes[3] / 5), drawSizes[0]
       + drawSizes[2], drawSizes[1]
       + (i * drawSizes[3] / 5), paint);
   this_g.drawLine(drawSizes[0] + (i * drawSizes[2] / 5),
     drawSizes[1], drawSizes[0] + (i * drawSizes[2] / 5),
     drawSizes[1] + drawSizes[3], paint);
  }

  // good for one value
  print_axis_values_4_grid(this_g, cur_elt_array[1], Double
    .toString(rounded_max), Double.toString(rounded_min),
    cur_elt_array[0], 2, 0);

 } // --- end of draw_grid ---

 private static Point scale_point(int this_x, double this_y,
   Point drawPoint, int scr_x, int scr_y, int scr_width,
   int src_height, double maxX, double minX, double maxY, double minY) {
  int temp_x, temp_y;
  Point temp = new Point();

  if (maxY == minY) // skip bad data
   return null;

  // don't touch it if is nothing
  try {
   temp_x = scr_x
     + (int) (((double) this_x - minX) * ((double) scr_width / (maxX - minX)));
   temp_y = scr_y
     + (int) ((maxY - this_y) * ((double) src_height / (maxY - minY)));

   temp.x = temp_x;
   temp.y = temp_y;
   drawPoint = temp;
  } catch (Exception e) {

   return (null);
  }

  return temp;

 } // --- end of scale_point --

 public static boolean plot_array_list(Canvas this_g,
   Vector this_array_list, Vector these_labels, String this_title,
   int only_this_idx) {
  int idx;
  int lRow;
  int nParms;
  int i, points_2_plot, shifted_idx;
  int prev_x, prev_y;
  int cur_x = 0, cur_y = 0;
  // Dim ShowMarker As Object
  Point cur_point = new Point();
  cur_point.set(0, 0);

  double cur_maxX, cur_minX, cur_maxY = 20, cur_minY = 0, cur_rangeY;
  int cur_start_x, cur_points_2_plot;

  int POINTS_TO_CHANGE = 30;
  double cur_OBD_val;

  // Object curElt;
  String curElt;
  String[] cur_elt_array;
  Object curElt2;
  String[] cur_elt_array2;

  final Paint paint = new Paint();

  try // catch in this block for some thing
  {
   points_2_plot = this_array_list.size();
   {
    cur_start_x = 0;
    cur_points_2_plot = points_2_plot;
    cur_maxX = cur_points_2_plot;
    cur_minX = 0;
   }

   // 'Create the plot points for this series from the ChartPoints
   // array:

   curElt = (String) this_array_list.elementAt(0);

   // the lines have to come out good
   paint.setStyle(Paint.Style.STROKE);
   //                  
   // for( nParms = 0 ; nParms < cur_elt_array.length ; nParms++ )
   nParms = only_this_idx;
   {

    // get cur item labels
    curElt2 = these_labels.elementAt(nParms);
    cur_elt_array2 = (String[]) curElt2;

    cur_maxY = get_ceiling_or_floor(Double
      .parseDouble(cur_elt_array2[2]), true);
    cur_minY = get_ceiling_or_floor(Double
      .parseDouble(cur_elt_array2[3]), false);

    cur_points_2_plot = this_array_list.size();
    cur_maxX = cur_points_2_plot;

    curElt = (String) this_array_list.elementAt(0);
    cur_OBD_val = Double.parseDouble(curElt);

    cur_point = scale_point(0, cur_OBD_val, cur_point,
      drawSizes[0], drawSizes[1], drawSizes[2], drawSizes[3],
      cur_maxX, cur_minX, cur_maxY, cur_minY); // '(CInt(curAxisValues.Mins(nParms
    // - 2) / 5)
    // + 1) * 5)

    cur_x = cur_point.x;
    cur_y = cur_point.y;

    paint.setColor(Color.GREEN);

    // the point is only cool when samples are low
    if (cur_points_2_plot < POINTS_TO_CHANGE)
     this_g.drawRect(cur_x - 2, cur_y - 2, cur_x - 2 + 4,
       cur_y - 2 + 4, paint);

    prev_x = cur_x;
    prev_y = cur_y;

    // 'go and plot point for this parm -- pont after the 1st one
    for (lRow = cur_start_x + 1; lRow < cur_start_x
      + cur_points_2_plot - 1; lRow++) {
     curElt = (String) this_array_list.elementAt(lRow);

     cur_OBD_val = Double.parseDouble(curElt);

     // 'work out an approx if cur Y values not avail(e.g.
     // nothing)
     // if (! (cur_elt_array[nParms ] == null ) ) //skip bad one
     if (cur_OBD_val == Double.NaN)
      continue; // skip bad one
     {

      cur_point = scale_point(lRow, cur_OBD_val, cur_point,
        drawSizes[0], drawSizes[1], drawSizes[2],
        drawSizes[3], cur_maxX, cur_minX, cur_maxY,
        cur_minY);

      cur_x = cur_point.x;
      cur_y = cur_point.y;

      if (cur_points_2_plot < POINTS_TO_CHANGE)
       this_g.drawRect(cur_x - 2, cur_y - 2,
         cur_x - 2 + 4, cur_y - 2 + 4, paint);

      this_g.drawLine(prev_x, prev_y, cur_x, cur_y, paint);
      prev_x = cur_x;
      prev_y = cur_y;

     } // ' if end of this_array(lRow, nParms - 1)<> nothing

    } // end of for lrow

   } // end of for nParmns

   // this_g.invalidate();
   return (true);
  } catch (Exception e) {
   return (false);
  }

 } // --- end of plot_array_list --

 public static void print_axis_values_4_grid(Canvas thisDrawingArea,
   String cur_units, String cur_max, String cur_min, String cur_label,
   int x_guide, int this_idx) {
  String this_str;
  double delta = (Double.valueOf(cur_max).doubleValue() - Double.valueOf(
    cur_min).doubleValue()) / 5;

  final Paint paint = new Paint();
  paint.setColor(Color.WHITE);

  paint.setTypeface(Typeface.SANS_SERIF);
  paint.setTextSize(8);

  for (int i = 0; i < 6; i++) {
   this_str = Double
     .toString((Double.valueOf(cur_min).doubleValue() + delta
       * i));
   final int point = this_str.indexOf('.');
   if (point > 0) {
    // If has a decimal point, may need to clip off after or force 2
    // decimal places
    this_str = this_str + "00";
    this_str = this_str.substring(0, point + 3);
   } else {
    this_str = this_str + ".00";
   }

   if (i == 5) {
    thisDrawingArea.drawText(this_str, x_guide - 2, drawSizes[1]
      + drawSizes[3] - (i * drawSizes[3] / 5), paint);
   } else {
    thisDrawingArea.drawText(this_str, x_guide - 2, drawSizes[1]
      + drawSizes[3] - (i * drawSizes[3] / 5) - 3, paint);
   }

  }
  paint.setTextSize(10);

  switch (this_idx) {
  case 0:
   thisDrawingArea.drawText("  " + cur_label + " - " + cur_units,
     x_guide - 2, drawSizes[1] - 15, paint);

   break;

  default:
   thisDrawingArea.drawText("  " + cur_label + " - " + cur_units,
     x_guide - 2 - 30, drawSizes[1] - 15, paint);

   break;
  }

 }

 private static int getCurTextLengthInPixels(Paint this_paint,
   String this_text) {
  FontMetrics fp = this_paint.getFontMetrics();
  Rect rect = new Rect();
  this_paint.getTextBounds(this_text, 0, this_text.length(), rect);
  return rect.width();
 }

 public static double get_ceiling_or_floor(double this_val, boolean is_max) {
  double this_min_tmp;
  int this_sign;
  int this_10_factor = 0;
  double this_rounded;

  if (this_val == 0.0) {
   this_rounded = 0.0;
   return this_rounded;
  }

  this_min_tmp = Math.abs(this_val);

  if (this_min_tmp >= 1.0 && this_min_tmp < 10.0)
   this_10_factor = 1;
  else if (this_min_tmp >= 10.0 && this_min_tmp < 100.0)
   this_10_factor = 10;
  else if (this_min_tmp >= 100.0 && this_min_tmp < 1000.0)
   this_10_factor = 100;
  else if (this_min_tmp >= 1000.0 && this_min_tmp < 10000.0)
   this_10_factor = 1000;
  else if (this_min_tmp >= 10000.0 && this_min_tmp < 100000.0)
   this_10_factor = 10000;

  // 'cover when min is pos and neg
  if (is_max) {
   if (this_val > 0.0)
    this_sign = 1;
   else
    this_sign = -1;

  } else {
   if (this_val > 0.0)
    this_sign = -1;
   else
    this_sign = 1;

  }

  if (this_min_tmp > 1)
   this_rounded = (double) (((int) (this_min_tmp / this_10_factor) + this_sign) * this_10_factor);
  else {
   this_rounded = (int) (this_min_tmp * 100.0);
   // ' cover same as above bfir number up to .001 less than tha it
   // will skip
   if (this_rounded >= 1 && this_rounded < 9)
    this_10_factor = 1;
   else if (this_rounded >= 10 && this_rounded < 99)
    this_10_factor = 10;
   else if (this_rounded >= 100 && this_rounded < 999)
    this_10_factor = 100;

   this_rounded = (double) (((int) ((this_rounded) / this_10_factor) + this_sign) * this_10_factor);
   this_rounded = (int) (this_rounded) / 100.0;

  }

  if (this_val < 0)
   this_rounded = -this_rounded;

  return this_rounded;

 }
}

 

源码下载：http://files.cnblogs.com/salam/XYChart.rar

<script type="text/javascript"></script>

<!--end: topics 文章、评论容器-->

<!--done-->

 

分享到：
| Android2.3操作系统即将发布，亮点解读
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    通过创建一个位图的XY Chart来学习Android绘图类Rect

    通过创建一个位图的XY Chart来深入学习Android绘图类Rect、Paint、Bitmap与Canvas，是一种有效掌握Android图形处理机制的方式。在这个过程中，我们将重点理解这些核心类的作用以及它们之间的相互作用，从而能够构建...

    Android canvas drawBitmap方法详解及实例

    `drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint)`是`drawBitmap()`方法的一个重载版本，其参数含义如下： 1. **Bitmap bitmap**: 这是你要绘制的位图对象，通常是从资源文件、内存缓存或者直接创建的...

    Android -自定义view-Paint和Canvas.rar

    例如，你可以创建一个自定义的进度条，使用Canvas绘制背景和进度条，通过改变Paint的颜色和位置来显示进度。或者创建一个可交互的图表视图，根据数据动态更新Canvas上的图形。 通过深入理解和实践Paint和Canvas的...

    Android应用源码之(Bitmap位图渲染与操作.zip

    - **缩放**：`Bitmap.createScaledBitmap(Bitmap source, int width, int height, boolean filter)`用于创建一个新的缩放后的Bitmap。 - **裁剪**：`Bitmap.createBitmap(Bitmap source, int x, int y, int width,...

    安卓Android源码——(Bitmap位图渲染与操作).rar

    使用`Bitmap.createBitmap()`来创建一个新的Bitmap时，可以指定其宽度、高度和颜色格式，以控制内存消耗。同时，记得在不再使用Bitmap时调用`recycle()`释放资源，但需要注意，一旦回收，不能再次使用。 3. **位图...

    Paint和Canvas使用总结

    例如，你可以创建一个`Bitmap`，然后在它的`Canvas`上画一个红色的圆： ```java Bitmap bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(bitmap); Paint paint = ...

    知识共享-Android_开发Rect(雷惊风).

    通过本文的学习，我们可以了解到在Android开发中如何利用`Rect`类来绘制各种图形元素。这些基础知识对于开发者来说非常重要，可以帮助他们更灵活地控制应用界面的设计和布局。同时，了解`Rect`与其他图形绘制工具...

    Android Canvas使用集合

    Canvas是Android中的一个类，它提供了各种绘制方法，如drawRect(), drawCircle(), drawBitmap()等，用于在SurfaceView、ImageView等组件上进行绘图。Canvas的主要功能是接受绘图命令，并将它们应用到指定的Bitmap或...

    Android应用源码之(Canvas画布).zip

    通过分析这个压缩包中的"4-7-2(Canvas画布)"文件，开发者可以学习如何创建Canvas，使用Paint设置样式，以及如何绘制基本图形和Bitmap。实践中，不断试验和调整，掌握Canvas的使用将极大地提升你在Android应用开发中...

    Android-实现在Kotlin中更方便使用canvas

    创建一个协程并在通道上发送绘图任务： ```kotlin launch(Dispatchers.Main) { val drawingChannel = Channel() drawingChannel.send { canvas.drawSomethingComplicated() } drawingChannel.receive().run() ...

    android canvas 画图

    在Android开发中，Canvas是用于在屏幕上绘制图形的重要工具，它是`android.graphics.Canvas`类的实例。本篇文章将深入探讨如何使用Android Canvas进行图形绘制，包括基本概念、常用方法以及实际应用示例。 Canvas...

    android canvas画人

    首先，我们需要创建一个Bitmap对象，然后获取Canvas实例，通常通过Bitmap的`createCanvas()`方法。接下来，我们就可以调用Canvas的各种draw方法开始绘制了。 1. **基础绘图方法**： - `drawRect(Rect rect, Paint ...

    Android自定义View中Paint、Rect、Canvas介绍（一）

    Android自定义View中Paint、Rect、Canvas是三个非常重要的组件， Paint类用于设置绘制的颜色、样式等属性，Rect类用于定义一个矩形区域，Canvas类用于实现各种图形的绘制工作。在自定义View中，我们可以使用这三个...

    把一个bitmap资源变成圆形图像工具方法

    首先，我们需要创建一个圆形的画布（Canvas），然后在这个画布上绘制Bitmap。这里的关键在于使用PorterDuffXfermode模式，它可以控制图像如何与画布上的现有内容混合。具体操作如下： 1. 创建一个与原Bitmap大小...

    Android利用canvas画各种图形(点、直线、弧、圆、椭圆、文字、矩形、多边形、曲线、圆角矩形)

    在实际开发中，通常会创建一个自定义的View类，重写`onDraw()`方法，在其中使用Canvas进行绘制。Paint对象是Canvas的得力助手，它可以设置颜色、样式、抗锯齿、纹理等多种属性，以实现更丰富的绘图效果。 除了基本...

    android bitMap

    首先创建一个新的`Bitmap` 和一个`Canvas`，然后定义一个圆形的边界，使用`drawRoundRect()` 方法绘制一个圆角矩形。接着通过`PorterDuffXfermode` 设置混合模式为`SRC_IN`，并使用`drawBitmap()` 方法将原`Bitmap` ...

    Android-使用clippath实现的CircleImageView没有Bitmap没有锯齿

    在Android的Canvas类中，`clipPath()`是一个用于剪裁绘制区域的方法，它可以将当前的绘图限制在一个特定的路径内。通过这个功能，我们可以创建出各种形状的视图，比如圆形。在实现CircleImageView时，我们可以通过`...

    Android Paint渐变色练习示例

    在Android开发中，绘制图形是常见且重要的任务之一，而`Paint`类是Android系统提供的一个核心绘图工具。本文将深入探讨如何使用`Paint`类实现渐变色效果，特别是在自定义`View`中的应用。 渐变色在UI设计中广泛使用...

    android UI类介绍

    Canvas 类是Android图形库中的基础类，它相当于一个画布，允许开发者在其上绘制各种图形和图像。在Android绘图过程中，通常需要以下四个元素： 1. 位图（Bitmap）：存储像素数据。 2. Canvas 画板：承载绘画内容，...

    Android高级应用源码-圆形，圆角图片，已经封装好的方法，直接调用！.zip

    总的来说，这个压缩包中的源码是为Android开发者提供的一个便利工具，可以帮助他们快速实现圆形和圆角图片的显示，提高开发效率。理解并掌握这些方法的实现原理，对于提升Android UI开发技能大有裨益。

Magicbox
Global site tag (gtag.js) - Google Analytics