NSAffineTransform — यह क्या है, ट्रांसफ़ॉर्मेशन के प्रकार और उन्हें कैसे लागू करें

NSAffineTransform क्या है?

NSAffineTransform AppKit फ्रेमवर्क का एक वर्ग है, जो केवल macOS पर उपलब्ध है। यह 3×3 मैट्रिक्स के माध्यम से द्वि-आयामी स्थान में एक एफ़ाइन ट्रांसफ़ॉर्मेशन को दर्शाता है। Core Graphics के CGAffineTransform (जो iOS पर उपलब्ध है) के विपरीत, NSAffineTransform CGAffineTransform संरचना पर एक ऑब्जेक्ट-ओरिएंटेड रैपर है, जो NSBezierPath, NSPoint और NSSize के साथ काम करने के लिए सुविधाजनक विधियाँ जोड़ता है।

एफ़ाइन ट्रांसफ़ॉर्मेशन विमान का एक ऐसा रूपांतरण है जो "बिंदु एक रेखा पर स्थित है" संबंध और रेखाओं की समानांतरता को संरक्षित करता है। दूसरे शब्दों में, एफ़ाइन ट्रांसफ़ॉर्मेशन के बाद, समानांतर रेखाएँ समानांतर रहती हैं और सीधी रेखाएँ सीधी रहती हैं। हालाँकि, दूरियाँ, कोण और क्षेत्रफल बदल सकते हैं: स्केलिंग, घूर्णन और कतरनी एफ़ाइन ट्रांसफ़ॉर्मेशन के विशेष मामले हैं।

iOS पर, NSAffineTransform का समतुल्य Core Graphics का CGAffineTransform संरचना है। दोनों API एक ही गणितीय मॉडल पर आधारित हैं — 3×3 एफ़ाइन ट्रांसफ़ॉर्मेशन मैट्रिक्स जहाँ अंतिम पंक्ति हमेशा [0, 0, 1] होती है। अंतर यह है कि NSAffineTransform एक वर्ग है (Objective-C में retain/release के साथ), जबकि CGAffineTransform Swift और C में एक संरचना (मूल्य प्रकार) है।

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

NSAffineTransform चार मूल प्रकार के ट्रांसफ़ॉर्मेशन का समर्थन करता है: translate (स्थानांतरण), scale (स्केलिंग), rotate (घूर्णन), और shear (कतरनी)। प्रत्येक प्रकार को एक अलग विधि द्वारा दर्शाया जाता है और इसे मौजूदा ट्रांसफ़ॉर्मेशन ऑब्जेक्ट पर लागू किया जा सकता है या नया बनाने के लिए उपयोग किया जा सकता है।

Translate — स्थानांतरण

Translate ऑब्जेक्ट के सभी बिंदुओं के निर्देशांकों में एक ऑफ़सेट जोड़ता है। पैरामीटर deltaX और deltaY क्रमशः क्षैतिज और ऊर्ध्वाधर स्थानांतरण की मात्रा निर्धारित करते हैं। धनात्मक deltaX मान दाईं ओर स्थानांतरित करता है, deltaY ऊपर की ओर। Translate ऑब्जेक्ट के आकार या रूप को नहीं बदलता — केवल उसकी स्थिति को।

Scale — स्केलिंग

Scale बिंदु निर्देशांकों को दिए गए गुणांक से गुणा करता है। एकसमान स्केलिंग (एक पैरामीटर) के साथ, ऑब्जेक्ट आनुपातिक रूप से बढ़ता या घटता है। असमान स्केलिंग के साथ, आकार विकृत होता है। गुणांक 1.0 आकार को अपरिवर्तित छोड़ता है, 1.0 से अधिक बढ़ाता है, 0.0 से 1.0 तक घटाता है। ऋणात्मक मान दर्पण प्रतिबिंब बनाते हैं।

Rotate — घूर्णन

Rotate ऑब्जेक्ट को मूल बिंदु के चारों ओर दिए गए कोण पर घुमाता है। धनात्मक घूर्णन कोण वामावर्त दिशा में घूर्णन से मेल खाता है। rotateByDegrees डिग्री (0–360) स्वीकार करता है, rotateByRadians रेडियन (0–2π) स्वीकार करता है। घूर्णन हमेशा बिंदु (0, 0) के सापेक्ष किया जाता है, इसलिए किसी भी बिंदु के चारों ओर घूर्णन के लिए, rotate को translate के साथ संयोजित करने की आवश्यकता होती है।

3×3 मैट्रिक्स प्रतिनिधित्व

एफ़ाइन ट्रांसफ़ॉर्मेशन NSAffineTransform में 3×3 मैट्रिक्स द्वारा दर्शाया जाता है जहाँ अंतिम पंक्ति हमेशा [0, 0, 1] होती है। यह मानक गणितीय प्रतिनिधित्व है जो ट्रांसफ़ॉर्मेशन के संयोजन को मैट्रिक्स के गुणनफल के रूप में प्रस्तुत करने की अनुमति देता है। मैट्रिक्स संरचना NSAffineTransformStruct के माध्यम से परिभाषित की जाती है, जिसमें छह महत्वपूर्ण घटक होते हैं: m11, m12, m21, m22, tX, tY।

m11, m12, m21, m22 घटक स्केलिंग, घूर्णन और कतरनी के लिए जिम्मेदार हैं। tX और tY घटक स्थानांतरण के लिए जिम्मेदार हैं। मानक कॉन्फ़िगरेशन (पहचान मैट्रिक्स) में, m11 = 1, m22 = 1, और शेष 0 के बराबर हैं। वर्तमान मैट्रिक्स मान प्राप्त करने के लिए, transformStruct का उपयोग किया जाता है — NSAffineTransform की वह संपत्ति जो NSAffineTransformStruct संरचना लौटाती है।

मैट्रिक्स गुणा एक गैर-क्रमविनिमेय संक्रिया है। इसका अर्थ है कि ट्रांसफ़ॉर्मेशन लागू करने का क्रम मायने रखता है: translate + rotate एक अलग परिणाम देता है rotate + translate से। संयोजन करते समय, NSAffineTransform नए मैट्रिक्स को बाईं ओर वर्तमान मैट्रिक्स से गुणा करता है: newMatrix = operation × currentMatrix। इसलिए, अंतिम जोड़ा गया ट्रांसफ़ॉर्मेशन पहले लागू होता है।

ट्रांसफ़ॉर्मेशन का संयोजन

NSAffineTransform एक ही ऑब्जेक्ट में कई ट्रांसफ़ॉर्मेशन को संयोजित करने की अनुमति देता है। translateXBy:yBy:, scaleBy:, या rotateByDegrees: का प्रत्येक कॉल आंतरिक मैट्रिक्स को संशोधित करता है — वर्तमान मैट्रिक्स को संबंधित ट्रांसफ़ॉर्मेशन के मैट्रिक्स से गुणा करता है। यह सरल संक्रियाओं के अनुक्रम से एक जटिल ट्रांसफ़ॉर्मेशन बनाने की अनुमति देता है।

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

यह जाँचने के लिए कि क्या कोई ट्रांसफ़ॉर्मेशन पहचान है (निर्देशांक नहीं बदलता), isIdentity गुण का उपयोग करें। पहचान ट्रांसफ़ॉर्मेशन एक इकाई मैट्रिक्स है — इससे गुणा करने पर बिंदु के निर्देशांक नहीं बदलते। एक नया NSAffineTransform ऑब्जेक्ट पहचान ट्रांसफ़ॉर्मेशन के रूप में बनाया जाता है। यह गुण अनुकूलन के लिए उपयोगी है: यदि ट्रांसफ़ॉर्मेशन पहचान है, तो इसे लागू करना छोड़ा जा सकता है।

ऑब्जेक्ट्स और संदर्भ पर लागू करना

NSAffineTransform को चार प्रकार के ऑब्जेक्ट्स पर लागू किया जा सकता है: NSPoint, NSSize, NSBezierPath, और NSGraphicsContext ग्राफ़िक्स संदर्भ। प्रत्येक लक्ष्य के लिए एक अलग विधि है: transformPoint:, transformSize:, transformBezierPath:, और set।

बिंदुओं और आकारों का रूपांतरण

विधि transformPoint: ट्रांसफ़ॉर्मेशन मैट्रिक्स को बिंदु के निर्देशांक वेक्टर (x, y, 1) से गुणा करती है, और बिंदु की नई स्थिति लौटाती है। transformSize: समान रूप से काम करती है लेकिन tX और tY घटकों को ध्यान में नहीं रखती — स्थानांतरण लागू नहीं होता, केवल स्केलिंग, घूर्णन और कतरनी। यह उन वेक्टरों और आकारों के रूपांतरण के लिए उपयोगी है जिन्हें स्थानांतरित नहीं किया जाना चाहिए।

NSBezierPath पथों का रूपांतरण

विधि transformBezierPath: एक नया NSBezierPath ऑब्जेक्ट बनाती है, जिसका प्रत्येक बिंदु NSAffineTransform मैट्रिक्स के अनुसार रूपांतरित होता है। मूल पथ संशोधित नहीं होता — रूपांतरित निर्देशांकों वाली एक प्रतिलिपि बनाई जाती है। यह बड़ी संख्या में नोड्स वाले जटिल पथों के लिए एक महँगा संचालन है।

ग्राफ़िक्स संदर्भ पर लागू करना

विधि set ट्रांसफ़ॉर्मेशन को वर्तमान ग्राफ़िक्स संदर्भ (NSGraphicsContext) पर लागू करती है, इसके CTM (वर्तमान ट्रांसफ़ॉर्मेशन मैट्रिक्स) को संशोधित करती है। set को कॉल करने के बाद, इस संदर्भ में सभी बाद की ड्राइंग रूपांतरित होगी। अस्थायी ट्रांसफ़ॉर्मेशन के लिए, set से पहले और बाद में saveGraphicsState / restoreGraphicsState का उपयोग करें।

Swift कोड उदाहरण

आइए ग्राफ़िक ऑब्जेक्ट्स को रूपांतरित करने के लिए macOS एप्लिकेशन में NSAffineTransform के उपयोग के व्यावहारिक उदाहरण देखें।

ट्रांसफ़ॉर्मेशन बनाना और संयोजित करना

यह उदाहरण एक NSAffineTransform बनाता है जो स्थानांतरण, घूर्णन और स्केलिंग को जोड़ता है। पहले, ऑब्जेक्ट को (100, 50) से स्थानांतरित किया जाता है, फिर 45 डिग्री घुमाया जाता है, और अंत में 1.5 गुना बड़ा किया जाता है। क्रम मायने रखता है: स्थानांतरण के बाद घूर्णन नए मूल बिंदु के सापेक्ष घूमता है।

import AppKit

let transform = NSAffineTransform()
transform.translateXBy(100, yBy: 50)
transform.rotateByDegrees(45)
transform.scaleBy(1.5)

// बिंदु पर लागू करना
let point = NSPoint(x: 10, y: 20)
let transformedPoint = transform.transform(point)

// आकार पर लागू करना
let size = NSSize(width: 100, height: 50)
let transformedSize = transform.transform(size)

ड्राइंग के लिए संदर्भ का रूपांतरण

यह उदाहरण set और concat के माध्यम से ग्राफ़िक्स संदर्भ पर NSAffineTransform लागू करने को दर्शाता है। ट्रांसफ़ॉर्मेशन लागू करने के बाद, सभी बाद की ड्राइंग रूपांतरित समन्वय प्रणाली में की जाती है। saveGraphicsState के माध्यम से ग्राफ़िक्स स्थिति को सहेजना मूल मैट्रिक्स पर लौटने की अनुमति देता है।

func drawWithTransform(in rect: NSRect) {
    guard let ctx = NSGraphicsContext.current
    else { return }

    ctx.saveGraphicsState()

    let xfm = NSAffineTransform()
    xfm.translateXBy(rect.midX, yBy: rect.midY)
    xfm.rotateByDegrees(30)
    xfm.scaleBy(0.8)
    xfm.concat()

    // रूपांतरित समन्वय प्रणाली में आरेखण
    let path = NSBezierPath(roundedRect: NSRect(
        x: -50, y: -50,
        width: 100, height: 100
    ), xRadius: 10, yRadius: 10)
    NSColor.blue.setFill()
    path.fill()

    ctx.restoreGraphicsState()
}

NSBezierPath का रूपांतरण

यह उदाहरण रूपांतरित निर्देशांकों के साथ NSBezierPath की प्रतिलिपि बनाने को दर्शाता है। मूल पथ अपरिवर्तित रहता है, और रूपांतरित प्रतिलिपि अलग से खींची जा सकती है — यह विभिन्न स्थितियों में दोहराए जाने वाले तत्वों को बनाने के लिए उपयोगी है।

func createTransformedTriangle() -> NSBezierPath {
    let triangle = NSBezierPath()
    triangle.move(to: NSPoint(x: 0, y: 0))
    triangle.line(to: NSPoint(x: 100, y: 0))
    triangle.line(to: NSPoint(x: 50, y: 100))
    triangle.close()

    let xfm = NSAffineTransform()
    xfm.translateXBy(200, yBy: 100)
    xfm.scaleXBy(1.5, yBy: 1.5)
    xfm.rotateByDegrees(45)

    let transformed = xfm.transform(triangle)
    return transformed
}