Android-da Matrix: nima, matritsa turlari va transformatsiyalar bilan ishlash

Android-da Matrix nima?

Matrix (android.graphics.Matrix) — ikki o'lchovli koordinatalarni o'zgartirish uchun ishlatiladigan 3×3 matematik matritsani ifodalovchi Android SDK sinfidir. Matrix Android-dagi barcha grafik o'zgartirishlar uchun asosiy qurilish blokidir — Canvas ni siljitish va masshtablashdan tortib Bitmap ning murakkab perspektiv deformatsiyalarigacha.

iOS dan farqli o'laroq, u yerda alohida CGAffineTransform (affin) va CATransform3D (3D) tuzilmalari ishlatiladi, Android affin va perspektiv o'zgartirishlarni bitta Matrix sinfida birlashtiradi. 3×3 matritsasi standart affin operatsiyalarini (oxirgi qator [0, 0, 1]) hamda oxirgi qatorda ixtiyoriy qiymatlar bo'lgan perspektiv deformatsiyalarni ifodalashga imkon beradi. Bu ko'proq moslashuvchanlik beradi, lekin matritsa matematikasini tushunishni talab qiladi.

Matrix Canvas API bilan chambarchas bog'langan. Dasturchi canvas.translate(), canvas.scale() yoki canvas.rotate() ni chaqirganda, bu usullar ichki ravishda grafik kontekstining matritsasini o'zgartiradi. Canvas ning joriy matritsasini canvas.getMatrix() orqali olish va maxsus matritsani canvas.setMatrix() yoki canvas.concat() orqali qo'lda qo'llash mumkin.

Matrix o'zgartirish turlari

Matrix to'rtta asosiy affin o'zgartirish turini qo'llab-quvvatlaydi: translate, scale, rotate, skew (egish). Har bir tur oldindan ko'paytirish (pre), keyin ko'paytirish (post) va o'rnatish (set) usullariga ega. preTranslate va postTranslate o'rtasidagi farq matritsalarni ko'paytirish tartibidadir, bu birlashtirilganda yakuniy o'zgartirishga ta'sir qiladi.

Translate — siljitish

Translate barcha nuqtalarning o'rnini berilgan dx, dy siljishiga o'zgartiradi. Musbat dx o'ngga, dy — pastga siljitadi (Android ekran koordinata tizimida Y o'qi pastga yo'naltirilgan). Translate ob'ektning shaklini o'zgartirmaydi — faqat uning pozitsiyasini. Bu elementlarni joylashtirish uchun eng oddiy va eng ko'p ishlatiladigan operatsiyadir.

Scale — masshtablash

Scale ob'ektning o'lchamini sx (X bo'ylab) va sy (Y bo'ylab) koeffitsientlari bilan o'zgartiradi. px, py parametrlari masshtablashning tayanch nuqtasini (pivot point) belgilaydi. Agar px, py ko'rsatilmasa, masshtablash koordinata boshiga (0, 0) nisbatan bajariladi. sx = sy bo'lganda ob'ekt bir tekisda masshtablanadi. Manfiy qiymatlar aks ettirishni yaratadi.

Rotate — aylantirish

Rotate ob'ektni tayanch nuqtasi (px, py) atrofida berilgan burchakka (gradusda) aylantiradi. Musbat gradus qiymati soat yo'nalishi bo'yicha aylanishga mos keladi (iOS/macOS dan farqli o'laroq, u erda musbat burchak soat yo'nalishiga teskari). Agar px, py ko'rsatilmasa, aylanish koordinata boshi atrofida bajariladi.

Skew — egish

Skew (siljitish) ob'ektni X o'qi (kx) yoki Y o'qi (ky) bo'ylab egib deformatsiyalaydi. 1.0 qiymati 45 gradusga egadi. Skew egish effektlarini yaratish, uch o'lchovli ko'rinishni (pseudo-3D) taqlid qilish va perspektiv deformatsiyasi uchun ishlatiladi.

3×3 matritsasining tuzilishi

Matrix 3×3 matritsasining elementlarini ichki 9 ta suzuvchi nuqtali qiymatlar massivida (float[9]) saqlaydi. Saqlash tartibi — column-major (ustunlar bo'ylab), standart matematik ko'rinishga mos keladi. Alohida elementlarga kirish konstantalar orqali amalga oshiriladi: Matrix.MSCALE_X, Matrix.MSKEW_Y, Matrix.MTRANS_X va boshqalar.

Matritsa elementlari

Matritsa quyidagicha tashkil etilgan: birinchi ikki ustun (MSCALE_X, MSKEW_X, MSKEW_Y, MSCALE_Y) masshtablash, aylantirish va egish uchun javobgardir. Uchinchi ustun (MTRANS_X, MTRANS_Y, MPERSP_2) — siljitish va perspektiv uchun. Affin o'zgartirish uchun MPERSP_0 va MPERSP_1 0 ga, MPERSP_2 esa 1 ga teng.

Matritsa qiymatlarini olish uchun getValues(float[] values) ishlatiladi, u 9 elementli massivni to'ldiradi. O'rnatish uchun — setValues(float[] values). Bu translate, scale, rotate va skew standart usullaridan tashqari murakkab maxsus o'zgartirishlar uchun matritsani to'g'ridan-to'g'ri boshqarish imkonini beradi.

Matritsa turini tekshirish

Matrix joriy holatni tasniflash uchun bir nechta usullarni taqdim etadi. isIdentity() matritsaning birlik ekanligini tekshiradi. isAffine() — faqat affin o'zgartirishlarni o'z ichiga olganligini (MPERSP_0 = 0, MPERSP_1 = 0, MPERSP_2 = 1). Bu tekshirishlar optimallashtirish uchun foydalidir: agar matritsa birlik bo'lsa, transformatsiyani o'tkazib yuborish mumkin.

Matrix bilan asosiy operatsiyalar

Matrix bir nechta operatsiyalar toifasini qo'llab-quvvatlaydi: o'rnatish (set), oldindan ko'paytirish (pre), keyin ko'paytirish (post), birlashtirish (concat), inversiya (invert) va xaritalash (map). Har bir toifa murakkab o'zgartirishlarni qurishda o'z vazifasini hal qiladi.

Pre va Post operatsiyalari

preTranslate joriy matritsani chapdan siljitish matritsasiga ko'paytiradi: result = translate × current. postTranslate o'ngdan ko'paytiradi: result = current × translate. Farq qo'llash tartibida: pre-operatsiyalar joriy transformatsiyalardan oldin, post-operatsiyalar esa keyin qo'llaniladi. preScale, postScale, preRotate, postRotate va preSkew, postSkew ham xuddi shunday ishlaydi.

Inversiya va birlashtirish

invert(Matrix inverse) teskari matritsani hisoblaydi. Agar manba matritsasi degenerativ bo'lsa (determinant nolga teng), false qaytariladi. concat(Matrix other) joriy matritsani berilgan matritsaga ko'paytiradi: set = set × other. Teskari tartib uchun setConcat(other, this) dan foydalaning.

Map — nuqtalar va to'rtburchaklarga qo'llash

mapRect(RectF rect) to'rtburchakni o'zgartiradi va natijani yangi RectF da qaytaradi. mapPoints(float[] dst, float[] src) nuqtalar massivini o'zgartiradi. mapVectors(float[] dst, float[] src) vektorlarni o'zgartiradi — siljitish (translate) hisobga olinmagan holda. mapRect transformatsiyadan keyin bounding box ni hisoblash uchun foydalidir.

Canvas va Bitmap da qo'llanilishi

Matrix Android grafikasining ikkita asosiy stsenariysida faol ishlatiladi: Canvas transformatsiyasi va Bitmap transformatsiyasi. Ikkala holatda ham Matrix grafik natija qanday o'zgarishini aniqlaydi.

Canvas transformatsiyasi Matrix orqali

Canvas joriy matritsani to'liq almashtirish uchun canvas.setMatrix(matrix) va joriy o'zgartirishni berilganiga ko'paytirish uchun canvas.concat(matrix) usullarini taqdim etadi. Matrix qo'llanilgandan so'ng, barcha keyingi chizish — drawBitmap, drawRect, drawPath chaqiruvlari — o'zgartirilgan koordinatalar tizimida bajariladi. Canvas shuningdek save() va restore() orqali saqlangan holatlar to'plamini saqlaydi.

Bitmap transformatsiyasi Matrix orqali

Bitmap.createBitmap(Bitmap source, int x, int y, int width, int height, Matrix matrix, boolean filter) berilgan o'zgartirishni qo'llagan holda yangi Bitmap yaratadi. Bu asl Bitmap ni yo'qotmasdan masshtablangan, aylantirilgan yoki deformatsiyalangan tasvir nusxalarini yaratish uchun kuchli vositadir. filter parametri piksel interpolyatsiyasida tekislashni boshqaradi.

setPolyToPoly — perspektiv o'zgartirishlar

setPolyToPoly(float[] src, int srcIndex, float[] dst, int dstIndex, int pointCount) — CGAffineTransform da to'g'ridan-to'g'ri o'xshashi bo'lmagan Matrix ning noyob imkoniyati. Berilgan nuqtalarni bir ko'pburchakdan ikkinchisiga o'zgartiruvchi matritsani hisoblaydi. pointCount = 4 bo'lganda, perspektiv deformatsiyasi bilan Bitmap qo'llash imkonini beruvchi to'liq perspektiv (projective) o'zgartirish yaratiladi.

Kotlin da kod misollari

Kotlin da Android ilovasida grafik transformatsiyasi uchun Matrix dan foydalanishning amaliy misollarini ko'rib chiqamiz.

Asosiy affin o'zgartirishlar

Misol birlashtirilgan o'zgartirish uchun Matrix yaratadi: (100, 50) siljitish, 1.5 marta masshtablash va 45 gradus aylantirish. preRotate va preScale dan keyin postTranslate ishlatilishi operatsiyalarni qo'llash tartibini o'zgartiradi.

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

// Nuqtalarga qo'llash
val pts = floatArrayOf(0f, 0f, 100f, 100f)
matrix.mapPoints(pts)

// To'rtburchakka qo'llash
val rect = RectF(0f, 0f, 200f, 100f)
matrix.mapRect(rect)

Canvas transformatsiyasi save va restore bilan

Misol doirani uning markazi atrofida aylantirish va masshtablash uchun onDraw da Canvas ga Matrix qo'llanilishini ko'rsatadi. Canvas holatini saqlash va tiklash transformatsiyaning keyingi chizish elementlariga ta'sir qilmasligini kafolatlaydi.

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 orqali perspektiv deformatsiyasi

Misol Bitmap ning perspektiv deformatsiyasini yaratish uchun setPolyToPoly dan foydalanadi. To'rtta manba nuqtasi (asl to'rtburchakning burchaklari) trapetsiya hosil qiluvchi to'rtta maqsad nuqtasiga xaritalanadi. Natija — fazoda egilgan tasvir effekti.

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
    )
}