एंड्रॉइड में पाई चार्ट ड्रा?

Question

मुझे पाई चार्ट (गतिशील मान) खींचने की आवश्यकता है। तृतीय पक्ष API का उपयोग किये बिना चार्ट बनाने के लिए।

Answer 1

आप एक चार्टइंजिन के org.achartengine.chart.PieChart का उपयोग कर सकते हैं जो roundChart फैलाता है।
अधिक जानकारी के लिए आप achartengine-0.7.0-javadocs/org/achartengine/chart/PieChart.html

पर जा सकते हैं जब आप aChartEngine.org

Answer 2

नीचे से javadocs डाउनलोड यह उपलब्ध हो जाएगा आसान पाई-चार्ट से पता चलता है और आप और अधिक सुविधाओं के लिए विस्तार करने के लिए है ... मान [] और रंग सरणी बराबर होना चाहिए ....

public class Demo extends Activity { 
    /** Called when the activity is first created. */ 
    float values[]={300,400,100,500}; 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main); 
     LinearLayout linear=(LinearLayout) findViewById(R.id.linear); 
     values=calculateData(values); 
     linear.addView(new MyGraphview(this,values)); 

    } 
    private float[] calculateData(float[] data) { 
     // TODO Auto-generated method stub 
     float total=0; 
     for(int i=0;i<data.length;i++) 
     { 
      total+=data[i]; 
     } 
     for(int i=0;i<data.length;i++) 
     { 
     data[i]=360*(data[i]/total);    
     } 
     return data; 

    } 
    public class MyGraphview extends View 
    { 
     private Paint paint=new Paint(Paint.ANTI_ALIAS_FLAG); 
     private float[] value_degree; 
     private int[] COLORS={Color.BLUE,Color.GREEN,Color.GRAY,Color.CYAN,Color.RED}; 
     RectF rectf = new RectF (10, 10, 200, 200); 
     int temp=0; 
     public MyGraphview(Context context, float[] values) { 

      super(context); 
      value_degree=new float[values.length]; 
      for(int i=0;i<values.length;i++) 
      { 
       value_degree[i]=values[i]; 
      } 
     } 
     @Override 
     protected void onDraw(Canvas canvas) { 
      // TODO Auto-generated method stub 
      super.onDraw(canvas); 

      for (int i = 0; i < value_degree.length; i++) {//values2.length; i++) { 
       if (i == 0) { 
        paint.setColor(COLORS[i]); 
        canvas.drawArc(rectf, 0, value_degree[i], true, paint); 
       } 
       else 
       { 
         temp += (int) value_degree[i - 1]; 
         paint.setColor(COLORS[i]); 
         canvas.drawArc(rectf, temp, value_degree[i], true, paint); 
       } 
      } 
     } 

    } 
} 

Answer 3

मैं एक काफी सरल पुस्तकालय खुला स्रोत जो आप सबसे अधिक संभावना उपयोग अपने उद्देश्यों (https://github.com/saulpower/ExpandablePieChart) पूरा करने के लिए कर सकता है कि नहीं है।

Answer 4

एक पाई चार्ट खींचने के लिए मूल कार्य, इनपुट रंगों की एक सरणी है, और मूल्यों की एक सरणी है। वे सरणी एक ही आकार के होना चाहिए। स्लाइसों को प्रत्येक स्लाइड के मूल्यों और सभी मानों के योग के आधार पर गणना की जाती है। अगर आप फ्लोट मानों में भी बदल सकते हैं। यह समाधान हल्के सहायक कार्य के रूप में प्रदान किया जाता है। इसका उपयोग करना आसान है, और इसके लिए आपको कक्षा को परिभाषित करने की आवश्यकता नहीं है।

public static void drawPieChart(Bitmap bmp, int[] colors, int[] slices){ 
    //canvas to draw on it 
    Canvas canvas = new Canvas(bmp); 
    RectF box = new RectF(2, 2,bmp.getWidth()-2 , bmp.getHeight()-2); 

    //get value for 100% 
    int sum = 0; 
    for (int slice : slices) { 
     sum += slice; 
    } 
    //initalize painter 
    Paint paint = new Paint(); 
    paint.setAntiAlias(true); 

    paint.setStyle(Paint.Style.STROKE); 
    paint.setStrokeWidth(1f); 
    paint.setStyle(Style.FILL_AND_STROKE); 
    float start = 0; 
    //draw slices 
    for(int i =0; i < slices.length; i++){ 
     paint.setColor(colors[i]); 
     float angle; 
     angle = ((360.0f/sum) * slices[i]); 
     canvas.drawArc(box, start, angle, true, paint); 
     start += angle; 
    } 
} 

Answer 5

रमेश द्वारा उत्तर लगभग ठीक काम करता है। हालांकि अंत में सफेद गड़बड़ फ्लोट से int तक कास्टिंग करने से त्रुटियों को गोल करके होती है। बस "temp" के प्रकार को फ्लोट करने के लिए बदलें, और "temp + = value_degree [i-1]" पर अंत में कास्ट को हटाएं (और यह सही है।

Answer 6

यदि आप एक सुंदर चार्ट प्लॉट करने के लिए कुछ ढूंढ रहे हैं तो मैं सुझाव दूंगा कि आप MPAndroidChart का उपयोग करें। यदि आप कुछ हल्के वजन की तलाश में हैं तो आप इसका इस्तेमाल कर सकते हैं।

public class PieDataSet { 

    private List<PieEntry> mPieEntries; 
    private Paint mCurrentPaint; 

    public PieDataSet(List<PieEntry> entries) { 
     mPieEntries = entries; 
     mCurrentPaint = new Paint(); 
    } 

    public void draw(Canvas canvas, float x, float y, float radius){ 

     RectF target = new RectF(x - radius, y - radius, x + radius, y + radius); 

     float startAngle = 0; 
     for(PieEntry entry : mPieEntries){ 
      int arc = (int)(entry.getValue() * 360); 

      mCurrentPaint.setColor(entry.getColor()); 
      canvas.drawArc(target, startAngle, arc, true, mCurrentPaint); 
      startAngle = startAngle + arc; 
     } 
    } 

    public static class PieEntry { 
     private float mValue; 
     private int mColor; 

     public PieEntry(float value, int color){ 
      mValue = value; 
      mColor = color; 
     } 


     //region Getters {} 
     public float getValue() { 
      return mValue; 
     } 

     public int getColor() { 
      return mColor; 
     } 
     //endregion 

     //region Setters {} 
     public void setValue(float mValue) { 
      this.mValue = mValue; 
     } 

     public void setColor(int mColor) { 
      this.mColor = mColor; 
     } 
     //endregion 
    } 
} 

तुम बस PieDataSet.PieEntry वस्तुओं की एक सूची बनाने के लिए, तो एक PieDataSet पैदा करते हैं। एक बार आपके पास PieDataSet ऑब्जेक्ट बनाया गया है, तो आप कैनवास पर पाई चार्ट खींचने के लिए बस pieDataSet.draw(canvas, x, y, radius) पर कॉल कर सकते हैं।

कुछ ध्यान में रखना है यह सुनिश्चित करना है कि आपके डेटा सेट मान 1.0f (100%) तक जोड़ दें, अन्यथा आपके पास वांछित परिणाम नहीं होगा।