Android में Matrix: यह क्या है, मैट्रिक्स के प्रकार और ट्रांसफ़ॉर्मेशन के साथ कार्य

Android में Matrix क्या है?

Matrix (android.graphics.Matrix) — Android SDK का एक वर्ग है जो द्वि-आयामी निर्देशांकों को बदलने के लिए उपयोग की जाने वाली गणितीय 3×3 मैट्रिक्स का प्रतिनिधित्व करता है। Matrix Android में सभी ग्राफ़िक ट्रांसफ़ॉर्मेशन के लिए मूलभूत निर्माण खंड है — Canvas की गति और स्केलिंग से लेकर Bitmap की जटिल परिप्रेक्ष्य विकृतियों तक।

iOS के विपरीत, जो अलग-अलग CGAffineTransform (एफ़ाइन) और CATransform3D (3D) संरचनाओं का उपयोग करता है, Android एफ़ाइन और परिप्रेक्ष्य ट्रांसफ़ॉर्मेशन को एक ही Matrix वर्ग में जोड़ता है। 3×3 मैट्रिक्स मानक एफ़ाइन संचालन (अंतिम पंक्ति [0, 0, 1]) और परिप्रेक्ष्य विकृतियों दोनों का प्रतिनिधित्व करने की अनुमति देता है जब अंतिम पंक्ति में मनमाने मान होते हैं। यह अधिक लचीलापन प्रदान करता है लेकिन मैट्रिक्स गणित की समझ की आवश्यकता होती है।

Matrix Canvas API के साथ गहराई से एकीकृत है। जब डेवलपर canvas.translate(), canvas.scale() या canvas.rotate() को कॉल करता है, तो ये विधियाँ आंतरिक रूप से ग्राफ़िक संदर्भ की मैट्रिक्स को संशोधित करती हैं। canvas.getMatrix() के माध्यम से वर्तमान Canvas मैट्रिक्स प्राप्त किया जा सकता है और canvas.setMatrix() या canvas.concat() के माध्यम से मैन्युअल रूप से कस्टम मैट्रिक्स लागू किया जा सकता है।

Matrix ट्रांसफ़ॉर्मेशन के प्रकार

Matrix चार बुनियादी प्रकार के एफ़ाइन ट्रांसफ़ॉर्मेशन का समर्थन करता है: translate, scale, rotate, skew (तिरछा)। प्रत्येक प्रकार में प्री-गुणन (pre), पोस्ट-गुणन (post) और सेट (set) के लिए विधियाँ हैं। preTranslate और postTranslate के बीच अंतर मैट्रिक्स गुणन के क्रम में है, जो संचालन के संयोजन पर अंतिम ट्रांसफ़ॉर्मेशन को प्रभावित करता है।

स्थानांतरण — गति

Translate सभी बिंदुओं की स्थिति को दिए गए विस्थापन dx, dy से बदलता है। धनात्मक dx दाईं ओर खिसकाता है, dy — नीचे की ओर (Android स्क्रीन समन्वय प्रणाली में, Y अक्ष नीचे की ओर इंगित करता है)। Translate वस्तु के आकार को नहीं बदलता — केवल उसकी स्थिति को। यह तत्वों को स्थापित करने के लिए सबसे सरल और सबसे अधिक उपयोग किया जाने वाला संचालन है।

स्केलिंग — आकार बदलना

Scale किसी वस्तु का आकार गुणांक sx (X के अनुदिश) और sy (Y के अनुदिश) से बदलता है। पैरामीटर px, py स्केलिंग का पिवट बिंदु निर्दिष्ट करते हैं। यदि px, py निर्दिष्ट नहीं हैं, तो स्केलिंग मूल बिंदु (0, 0) के सापेक्ष की जाती है। जब sx = sy, वस्तु समान रूप से स्केल होती है। ऋणात्मक मान प्रतिबिंब बनाते हैं।

घूर्णन — घुमाना

Rotate किसी वस्तु को पिवट बिंदु (px, py) के चारों ओर दिए गए कोण (डिग्री में) पर घुमाता है। धनात्मक डिग्री मान दक्षिणावर्त घूर्णन के अनुरूप होते हैं (iOS/macOS के विपरीत, जहाँ धनात्मक कोण वामावर्त होता है)। यदि px, py निर्दिष्ट नहीं हैं, तो घूर्णन मूल बिंदु के चारों ओर किया जाता है।

तिरछा — झुकाव

Skew (कतरनी) किसी वस्तु को X अक्ष (kx) या Y अक्ष (ky) के अनुदिश झुकाकर विकृत करता है। मान 1.0 45 डिग्री पर झुकाता है। Skew का उपयोग झुकाव प्रभाव, छद्म-3D दृश्य और परिप्रेक्ष्य विकृति बनाने के लिए किया जाता है।

3×3 मैट्रिक्स की संरचना

Matrix अपने 3×3 तत्वों को 9 फ़्लोटिंग-पॉइंट मानों (float[9]) की आंतरिक सरणी में संग्रहीत करता है। भंडारण क्रम कॉलम-मेजर (column-major) है, जो मानक गणितीय प्रतिनिधित्व के अनुरूप है। अलग-अलग तत्वों तक पहुँच स्थिरांक के माध्यम से की जाती है: Matrix.MSCALE_X, Matrix.MSKEW_Y, Matrix.MTRANS_X इत्यादि।

मैट्रिक्स के तत्व

मैट्रिक्स निम्नानुसार व्यवस्थित है: पहले दो कॉलम (MSCALE_X, MSKEW_X, MSKEW_Y, MSCALE_Y) स्केलिंग, घूर्णन और तिरछा करने के लिए जिम्मेदार हैं। तीसरा कॉलम (MTRANS_X, MTRANS_Y, MPERSP_2) स्थानांतरण और परिप्रेक्ष्य के लिए जिम्मेदार है। एफ़ाइन ट्रांसफ़ॉर्मेशन के लिए, MPERSP_0 और MPERSP_1 0 हैं, और MPERSP_2 1 है।

मैट्रिक्स मान प्राप्त करने के लिए, getValues(float[] values) का उपयोग करें, जो 9 तत्वों की एक सरणी भरता है। उन्हें सेट करने के लिए, setValues(float[] values) का उपयोग करें। यह मानक translate, scale, rotate और skew विधियों से परे जटिल कस्टम ट्रांसफ़ॉर्मेशन के लिए मैट्रिक्स में प्रत्यक्ष हेरफेर की अनुमति देता है।

मैट्रिक्स प्रकार की जाँच

Matrix वर्तमान स्थिति को वर्गीकृत करने के लिए कई विधियाँ प्रदान करता है। isIdentity() जाँचता है कि मैट्रिक्स पहचान मैट्रिक्स है या नहीं। isAffine() जाँचता है कि इसमें केवल एफ़ाइन ट्रांसफ़ॉर्मेशन हैं (MPERSP_0 = 0, MPERSP_1 = 0, MPERSP_2 = 1)। ये जाँच अनुकूलन के लिए उपयोगी हैं: यदि मैट्रिक्स पहचान है, तो ट्रांसफ़ॉर्मेशन को छोड़ा जा सकता है।

Matrix के साथ बुनियादी संचालन

Matrix संचालन की कई श्रेणियों का समर्थन करता है: सेट (set), प्री-गुणन (pre), पोस्ट-गुणन (post), संयोजन (concat), व्युत्क्रम (invert) और मैपिंग (map)। प्रत्येक श्रेणी जटिल ट्रांसफ़ॉर्मेशन बनाते समय अपने उद्देश्य की पूर्ति करती है।

Pre और Post संचालन

preTranslate वर्तमान मैट्रिक्स को बाईं ओर से स्थानांतरण मैट्रिक्स से गुणा करता है: result = translate × current. postTranslate दाईं ओर से गुणा करता है: result = current × translate. अंतर आवेदन के क्रम में है: pre-संचालन वर्तमान ट्रांसफ़ॉर्मेशन से पहले लागू होते हैं, post-संचालन बाद में। यही preScale, postScale, preRotate, postRotate और preSkew, postSkew पर भी लागू होता है।

व्युत्क्रम और संयोजन

invert(Matrix inverse) व्युत्क्रम मैट्रिक्स की गणना करता है। यदि मूल मैट्रिक्स एकवचन (सारणिक शून्य) है, तो false लौटाता है। concat(Matrix other) वर्तमान मैट्रिक्स को दिए गए मैट्रिक्स से गुणा करता है: set = set × other. उल्टे क्रम के लिए, setConcat(other, this) का उपयोग करें।

Map — बिंदुओं और आयतों पर लागू करना

mapRect(RectF rect) एक आयत को रूपांतरित करता है और परिणाम एक नए RectF में लौटाता है। mapPoints(float[] dst, float[] src) बिंदुओं की एक सरणी को रूपांतरित करता है। mapVectors(float[] dst, float[] src) सदिशों को रूपांतरित करता है — स्थानांतरण को ध्यान में रखे बिना। mapRect ट्रांसफ़ॉर्मेशन के बाद बाउंडिंग बॉक्स की गणना के लिए उपयोगी है।

Canvas और Bitmap में अनुप्रयोग

Matrix का सक्रिय रूप से दो प्रमुख Android ग्राफ़िक्स परिदृश्यों में उपयोग किया जाता है: Canvas ट्रांसफ़ॉर्मेशन और Bitmap ट्रांसफ़ॉर्मेशन। दोनों मामलों में, Matrix यह निर्धारित करता है कि ग्राफ़िक आउटपुट कैसे संशोधित किया जाएगा।

Matrix के माध्यम से Canvas ट्रांसफ़ॉर्मेशन

Canvas वर्तमान मैट्रिक्स के पूर्ण प्रतिस्थापन के लिए canvas.setMatrix(matrix) और वर्तमान ट्रांसफ़ॉर्मेशन को दिए गए मैट्रिक्स से गुणा करने के लिए canvas.concat(matrix) प्रदान करता है। Matrix लागू करने के बाद, सभी बाद की ड्राइंग — drawBitmap, drawRect, drawPath कॉल — रूपांतरित समन्वय प्रणाली में की जाती है। Canvas save() और restore() के माध्यम से अपना स्वयं का सहेजा गया स्टेट स्टैक भी बनाए रखता है।

Matrix के माध्यम से Bitmap ट्रांसफ़ॉर्मेशन

Bitmap.createBitmap(Bitmap source, int x, int y, int width, int height, Matrix matrix, boolean filter) दिए गए ट्रांसफ़ॉर्मेशन को लागू करके एक नया Bitmap बनाता है। यह मूल Bitmap को खोए बिना स्केल की गई, घुमाई गई या विकृत छवि प्रतियाँ बनाने के लिए एक शक्तिशाली उपकरण है। पैरामीटर filter पिक्सेल इंटरपोलेशन के दौरान एंटी-अलियासिंग को नियंत्रित करता है।

setPolyToPoly — परिप्रेक्ष्य ट्रांसफ़ॉर्मेशन

setPolyToPoly(float[] src, int srcIndex, float[] dst, int dstIndex, int pointCount) — Matrix की एक अद्वितीय क्षमता जिसका CGAffineTransform में कोई सीधा समकक्ष नहीं है। यह एक मैट्रिक्स की गणना करता है जो दिए गए बिंदुओं को एक बहुभुज से दूसरे में रूपांतरित करता है। pointCount = 4 के साथ, एक पूर्ण परिप्रेक्ष्य (प्रोजेक्टिव) ट्रांसफ़ॉर्मेशन बनाया जाता है, जो परिप्रेक्ष्य विकृति के साथ Bitmap ओवरले की अनुमति देता है।

Kotlin में कोड उदाहरण

आइए Kotlin के साथ Android एप्लिकेशन में ग्राफ़िक्स ट्रांसफ़ॉर्मेशन के लिए Matrix के उपयोग के व्यावहारिक उदाहरण देखें।

बुनियादी एफ़ाइन ट्रांसफ़ॉर्मेशन

उदाहरण एक संयुक्त ट्रांसफ़ॉर्मेशन के लिए Matrix बनाता है: (100, 50) से स्थानांतरण, 1.5x स्केलिंग और 45 डिग्री घूर्णन। preRotate और preScale के बाद postTranslate का उपयोग संचालन के क्रम को बदलता है।

val matrix = Matrix()
matrix.preScale(1.5f, 1.5f)
matrix.preRotate(45f)
matrix.postTranslate(100f, 50f)

// बिंदुओं पर लागू करना
val pts = floatArrayOf(0f, 0f, 100f, 100f)
matrix.mapPoints(pts)

// आयत पर लागू करना
val rect = RectF(0f, 0f, 200f, 100f)
matrix.mapRect(rect)

save और restore के साथ Canvas ट्रांसफ़ॉर्मेशन

उदाहरण एक वृत्त को उसके केंद्र के चारों ओर घुमाने और स्केल करने के लिए onDraw में Canvas पर Matrix लागू करना प्रदर्शित करता है। Canvas स्थिति को सहेजना और पुनर्स्थापित करना सुनिश्चित करता है कि ट्रांसफ़ॉर्मेशन बाद के ड्राइंग तत्वों को प्रभावित न करे।

override fun onDraw(canvas: Canvas) {
    super.onDraw(canvas)

    val cx = width / 2f
    val cy = height / 2f
    val radius = 100f

    canvas.save()
    val matrix = Matrix()
    matrix.postTranslate(cx, cy)
    matrix.postRotate(30f)
    matrix.postScale(1.2f, 1.2f)
    canvas.concat(matrix)

    val paint = Paint().apply {
        color = Color.BLUE
        style = Paint.Style.FILL
    }
    canvas.drawCircle(0f, 0f, radius, paint)
    canvas.restore()
}

setPolyToPoly के माध्यम से परिप्रेक्ष्य विकृति

उदाहरण Bitmap की परिप्रेक्ष्य विकृति बनाने के लिए setPolyToPoly का उपयोग करता है। चार स्रोत बिंदु (मूल आयत के कोने) चार लक्ष्य बिंदुओं पर मैप किए जाते हैं जो एक समलंब बनाते हैं। परिणाम अंतरिक्ष में झुकी हुई छवि का प्रभाव है।

fun applyPerspective(
    bitmap: Bitmap,
    skew: Float
): Bitmap {
    val w = bitmap.width.toFloat()
    val h = bitmap.height.toFloat()

    val src = floatArrayOf(0f, 0f, w, 0f,
                         0f, h, w, h)
    val dst = floatArrayOf(skew, 0f, w - skew, 0f,
                         0f, h, w, h)

    val matrix = Matrix()
    matrix.setPolyToPoly(src, 0, dst, 0, 4)

    return Bitmap.createBitmap(
        bitmap, 0, 0,
        w.toInt(), h.toInt(),
        matrix, true
    )
}