एंड्रॉइड में बिटमैप से गोलाकार क्षेत्र कैसे क्रॉप करें? (टच-आधारित)

एंड्रॉइड में टच जेस्चर से बिटमैप का फ्री-फॉर्म क्रॉपिंग

यह उदाहरण दिखाता है कि उपयोगकर्ता के टच इनपुट के आधार पर बिटमैप का मनचाहा आकार कैसे क्रॉप किया जाता है।

चरण 1: नया प्रोजेक्ट बनाएं

Android Studio में File → New Project चुनकर नया प्रोजेक्ट बनाएं।

चरण 2: लेआउट XML (कस्टम व्यू उपयोग करेगा)

res/layout/activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="https://schemas.android.com/apk/res/android"
    xmlns:tools="https://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" />

चरण 3: कस्टम व्यू के साथ MainActivity

MainActivity.java:

package app.com.sample;

import androidx.appcompat.app.AppCompatActivity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // कस्टम व्यू को कंटेंट व्यू के रूप में सेट करें
        setContentView(new CropImageView(this));
    }

    // कस्टम व्यू क्लास
    public static class CropImageView extends View {
        private Bitmap bitmap;
        private Path path = new Path();
        private Paint paint;
        private Paint cropPaint;

        public CropImageView(Context context) {
            super(context);
            // ड्रॉएबल से बिटमैप लोड करें
            bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.demo);
            
            // पथ ड्रॉइंग के लिए पेंट
            paint = new Paint();
            paint.setColor(Color.RED);
            paint.setStyle(Paint.Style.STROKE);
            paint.setStrokeWidth(5f);

            // क्रॉपिंग के लिए पेंट
            cropPaint = new Paint();
        }

        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
            
            // मूल बिटमैप ड्रॉ करें
            if (bitmap != null) {
                canvas.drawBitmap(bitmap, 0, 0, null);
            }
            
            // उपयोगकर्ता का ड्रॉ किया गया पथ दिखाएं
            canvas.drawPath(path, paint);
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            float x = event.getX();
            float y = event.getY();

            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    path.moveTo(x, y);
                    break;
                case MotionEvent.ACTION_MOVE:
                case MotionEvent.ACTION_UP:
                    path.lineTo(x, y);
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        path.close(); // पथ बंद करें
                        cropBitmap();
                    }
                    break;
            }
            invalidate(); // रीड्रॉ ट्रिगर करें
            return true;
        }

        private void cropBitmap() {
            if (bitmap == null) return;

            // नया बिटमैप बनाएं क्रॉप्ड परिणाम के लिए
            Bitmap croppedBitmap = Bitmap.createBitmap(
                bitmap.getWidth(), bitmap.getHeight(), bitmap.getConfig());
            Canvas cropCanvas = new Canvas(croppedBitmap);

            // पथ को मास्क के रूप में ड्रॉ करें
            cropPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
            cropCanvas.drawPath(path, cropPaint);
            
            // मूल बिटमैप को मास्क के साथ ड्रॉ करें
            cropCanvas.drawBitmap(bitmap, 0, 0, cropPaint);

            // मूल बिटमैप को क्रॉप्ड से बदलें
            bitmap.recycle();
            bitmap = croppedBitmap;
            
            // पथ रीसेट करें अगले क्रॉप के लिए
            path.reset();
        }
    }
}

चरण 4: Manifest

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="https://schemas.android.com/apk/res/android"
    package="app.com.sample">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

        <activity android:name=".MainActivity" android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

⚠️ सीमाएं और सुधार

• केवल गोलाकार नहीं: यह किसी भी आकार की अनुमति देता है, लेकिन गोलाकार क्रॉप के लिए पिछला उदाहरण (1005061883) बेहतर है
• कोई पूर्वावलोकन नहीं: उपयोगकर्ता को अंतिम परिणाम केवल टच अप करने के बाद दिखता है
• मेमोरी: बड़े बिटमैप के लिए OOM का खतरा

🚀 बेहतर विकल्प: UCrop लाइब्रेरी

उत्पादन-तैयार इमेज क्रॉपिंग के लिए:

// build.gradle
implementation 'com.github.yalantis:ucrop:2.2.6'

// उपयोग:
UCrop.of(sourceUri, destinationUri)
    .withAspectRatio(1, 1) // वर्गाकार क्रॉप
    .withMaxResultSize(500, 500)
    .start(this);

ऐप चलाएं

डिवाइस कनेक्ट करें, Run पर क्लिक करें। इमेज पर उंगली घुमाकर आकार बनाएं, छोड़ने पर वह क्षेत्र क्रॉप हो जाएगा।