android करन भरे हुए बहुभुज कैसे आकर्षित करें?




बहुभुज सूत्र (7)

Android में भरे हुए बहुभुज कैसे बनाएं?

https://code.i-harness.com


BTW - मुझे पता चला कि एक बार जब आप अपना रास्ता बनाना शुरू कर देते हैं, तो पथ के भीतर किसी भी चाल का मतलब यह होगा कि आकार अधूरा छोड़ दिया गया है।

जब आप इसके बारे में सोचते हैं तो यह समझ में आता है, कि एंड्रॉइड / जावा आकार को अधूरा छोड़ देगा क्योंकि मूव पॉलीगॉन में एक ब्रेक का प्रतिनिधित्व करेगा।

हालाँकि मैंने कुछ ट्यूटोरियल इस तरह से देखे हैं कि एंड्रॉइड कैनवास में भरा हुआ त्रिकोण कैसे खींचना है?

जो प्रत्येक लाइन के बाद है। भले ही यह एक अखंड बहुभुज के परिणामस्वरूप हो सकता है, Android मानता है कि एक मूव पॉलीगॉन में एक ब्रेक का प्रतिनिधित्व करता है।


आपको पेंट ऑब्जेक्ट को FILL पर सेट करना होगा

Paint paint = new Paint();
paint.setStyle(Paint.Style.FILL);

फिर आप जो चाहें आकर्षित कर सकते हैं, और यह भरा जाएगा।

canvas.drawCircle(20, 20, 15, paint);
canvas.drawRectangle(60, 20, 15, paint);

आदि।

अधिक जटिल आकृतियों के लिए आपको PATH ऑब्जेक्ट का उपयोग करने की आवश्यकता है।


एंड्रॉइड में जावा की तरह एक आसान drawPolygon(x_array, y_array, numberofpoints) कार्रवाई नहीं है। आपको पॉइंट द्वारा पॉइंट ऑब्जेक्ट पॉइंट बनाकर चलना होगा। उदाहरण के लिए, एक 3 डी डंगऑन दीवार के लिए एक भरा हुआ ट्रेपेज़ॉइड आकार बनाने के लिए, आप अपने सभी बिंदुओं को x और y सरणियों में रख सकते हैं, फिर निम्नानुसार कोड:

Paint wallpaint = new Paint();
wallpaint.setColor(Color.GRAY);
wallpaint.setStyle(Style.FILL);

Path wallpath = new Path();
wallpath.reset(); // only needed when reusing this path for a new build
wallpath.moveTo(x[0], y[0]); // used for first point
wallpath.lineTo(x[1], y[1]);
wallpath.lineTo(x[2], y[2]);
wallpath.lineTo(x[3], y[3]);
wallpath.lineTo(x[0], y[0]); // there is a setLastPoint action but i found it not to work as expected

canvas.drawPath(wallpath, wallpaint);

कुछ गहराई के लिए एक निरंतर रैखिक ढाल जोड़ने के लिए, आप निम्नानुसार कोड कर सकते हैं। नोट y [0] का उपयोग दो बार ढाल को क्षैतिज रखने के लिए किया जाता है:

 wallPaint.reset(); // precaution when resusing Paint object, here shader replaces solid GRAY anyway
 wallPaint.setShader(new LinearGradient(x[0], y[0], x[1], y[0], Color.GRAY, Color.DKGRAY,TileMode.CLAMP)); 

 canvas.drawPath(wallpath, wallpaint);

अधिक विकल्पों के लिए Paint , पाथ और Canvas प्रलेखन का संदर्भ लें, जैसे कि सरणी परिभाषित ग्रेडिएंट, आर्क्स जोड़ना और अपने बहुभुज पर एक बिटमैप रखना।


पुराना सवाल है, लेकिन जो कोई भी इस पाता है के लिए एक चाल। यदि आप ग्लिफ़ के रूप में वांछित बहुभुज के साथ एक फ़ॉन्ट शामिल करते हैं, तो आप अपने बहुभुज को आकर्षित करने के लिए drawText फ़ंक्शन का उपयोग कर सकते हैं।

नकारात्मक पक्ष यह है कि आपको समय से पहले यह जानना होगा कि आपको किस आकार की आवश्यकता होगी। यह उल्टा है यदि आप समय से पहले जानते हैं कि आप एक अच्छा आकार पुस्तकालय शामिल कर सकते हैं। यह कोड मानता है कि आपके पास आपकी परियोजना की संपत्ति / फोंट फ़ोल्डर में आकार नामक एक फ़ॉन्ट है।

            TypeFace shapesTypeFace = Typeface.createFromAsset(getAssets(), "fonts/shapes.ttf");
            Paint stopSignPaint = new Paint();
            stopSignPaint.setColor(Color.RED);
            //set anti-aliasing so it looks nice
            stopSignPaint.setAntiAlias(true);
            stopSignPaint.setTextSize(200);
            stopSignPaint.setTypeface(shapesTypeFace);

            //will show up as a box or question mark since 
            //the current display font doesn't have this glyph. 
            //open the shapes font in a tool like Character Map 
            //to copy and paste the glyph into your IDE
            //saving it as a variable makes it much easier to work with
            String hexagonGlyph = ""
            String triangleGlyph = ""


            ....whatever code you got...


            //arguments: text, x coordinate, y coordinate, paint
             canvas.drawText(hexagonGlyph, 200, 100, stopSignPaint);

            //make it into a go sign
            stopSignPaint.setColor(Color.Green);
             canvas.drawText(hexagonGlyph, 200, 100, stopSignPaint);


            //make a tiny one
            stopSignPaint.setTextSize(20);
            stopSignPaint.setColor(Color.RED);
             canvas.drawText(hexagonGlyph, 200, 100, stopSignPaint);


             //make a triangle
             canvas.drawText(triangleGlyph, 200, 100, stopSignPaint);

मैं इसे तीन चरणों में करना पसंद करता हूं ...

चरण 1. एक नुकीला वर्ग बनाएँ ;-)

/**
 * Simple point
 */
private class Point {

    public float x = 0;
    public float y = 0;

    public Point(float x, float y) {
        this.x = x;
        this.y = y;
    }
}

चरण 2. ड्राइंग के लिए एक विधि / फ़ंक्शन जोड़ें

/**
 * Draw polygon
 *
 * @param canvas The canvas to draw on
 * @param color  Integer representing a fill color (see http://developer.android.com/reference/android/graphics/Color.html)
 * @param points Polygon corner points
 */
private void drawPoly(Canvas canvas, int color, Point[] points) {
    // line at minimum...
    if (points.length < 2) {
        return;
    }

    // paint
    Paint polyPaint = new Paint();
    polyPaint.setColor(color);
    polyPaint.setStyle(Style.FILL);

    // path
    Path polyPath = new Path();
    polyPath.moveTo(points[0].x, points[0].y);
    int i, len;
    len = points.length;
    for (i = 0; i < len; i++) {
        polyPath.lineTo(points[i].x, points[i].y);
    }
    polyPath.lineTo(points[0].x, points[0].y);

    // draw
    canvas.drawPath(polyPath, polyPaint);
}

चरण 3. ड्रा

    drawPoly(canvas, 0xFF5555ee,
            new Point[]{
                new Point(10, 10),
                new Point(15, 10),
                new Point(15, 20)
            });

हाँ, आप शायद इसे और अधिक कुशलता से कर सकते हैं, लेकिन शायद अधिक पठनीय :-) नहीं।


यह कोशिश करो, या पूर्ण डेमो देखें

    Paint paint = new Paint();
    paint.setColor(Color.parseColor("#BAB399"));
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));

एक्स पक्षों और कस्टम त्रिज्या के साथ बहुभुज ड्रा करें:

private void drawPolygon(Canvas mCanvas, float x, float y, float radius, float sides, float startAngle, boolean anticlockwise, Paint paint) {

    if (sides < 3) { return; }

    float a = ((float) Math.PI *2) / sides * (anticlockwise ? -1 : 1);
    mCanvas.save();
    mCanvas.translate(x, y);
    mCanvas.rotate(startAngle);
    Path path = new Path();
    path.moveTo(radius, 0);
    for(int i = 1; i < sides; i++) {
        path.lineTo(radius * (float) Math.cos(a * i), radius * (float) Math.sin(a * i));
    }
    path.close();
    mCanvas.drawPath(path, paint);
    mCanvas.restore();
}






android