pt — यह क्या है, Points और iOS में स्केलिंग

iOS में pt क्या है?

pt (point) — iOS में माप की एक तार्किक इकाई जो डेवलपर को इंटरफ़ेस को अमूर्त निर्देशांकों में वर्णित करने की अनुमति देती है, जो डिस्प्ले के भौतिक रिज़ॉल्यूशन से स्वतंत्र होते हैं। Apple ने 2010 में iPhone 4 और Retina डिस्प्ले के लॉन्च के साथ points की अवधारणा पेश की। Retina से पहले, डेवलपर सीधे पिक्सेल का उपयोग करते थे — एक UI पिक्सेल एक भौतिक पिक्सेल के बराबर होता था।

iOS का निर्देशांक तंत्र points पर बना है: बिंदु (0,0) स्क्रीन के ऊपरी बाएँ कोने में है, X अक्ष दाईं ओर जाता है, Y अक्ष नीचे की ओर। प्रत्येक डिवाइस वर्ग के लिए पॉइंट्स में स्क्रीन का आकार स्थिर रहता है: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (पोर्ट्रेट), 1024×768 pt (लैंडस्केप)। भौतिक रिज़ॉल्यूशन 1179×2556 px (iPhone 15 Pro) हो सकता है — लेकिन डेवलपर points के साथ काम करता है।

Apple Human Interface Guidelines के अनुसार, points UIKit का मूलभूत अमूर्तन है। सभी फ्रेमवर्क — UIKit, SwiftUI, Core Graphics, SpriteKit — points में काम करते हैं। पिक्सेल में रूपांतरण UIScreen.nativeScale के माध्यम से रेंडरिंग चरण में स्वचालित रूप से होता है।

स्केल फ़ैक्टर: @1x, @2x, @3x

स्केल फ़ैक्टर यह निर्धारित करता है कि एक तार्किक बिंदु के अनुरूप कितने भौतिक पिक्सेल हैं। Apple तीन स्तरों का उपयोग करता है: @1x — 1 pt = 1 px (बिना Retina के iPad mini, पुराने मॉडल), @2x — 1 pt = 2 px (2020 से पहले के अधिकांश iPhone, iPad Retina), @3x — 1 pt = 3 px (iPhone X और नए, iPhone 15 Pro सहित)।

स्केल फ़ैक्टर UIScreen.main.scale (UIKit के लिए) और @Environment(\.displayScale) (SwiftUI के लिए) के माध्यम से उपलब्ध है। इसका उपयोग एसेट लोड करते समय किया जाता है: सिस्टम स्वचालित रूप से Assets.xcassets से @2x या @3x प्रत्यय वाली छवि चुनता है। डेवलपर को Retina डिवाइसों पर @1x छवियाँ लोड नहीं करनी चाहिए — इससे प्रदर्शन और गुणवत्ता कम होती है।

CGPoint और पॉइंट्स में निर्देशांक

CGPoint संरचना iOS और macOS में निर्देशांक दर्शाने के लिए मूल प्रकार है। इसमें दो फ़ील्ड हैं: x (CGFloat) और y (CGFloat), मान पॉइंट्स में निर्दिष्ट किए जाते हैं। CGPoint सभी Apple फ्रेमवर्क में उपयोग किया जाता है: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position)।

// CGPoint — पॉइंट्स में निर्देशांक के साथ कार्य
import UIKit

// एक बिंदु बनाना
let point = CGPoint(x: 100.0, y: 200.0)
print("निर्देशांक: \(point.x), \(point.y)")

// गणितीय संचालन
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// बिंदुओं के बीच की दूरी
func distance(from a: CGPoint, to b: CGPoint) -> CGFloat {
    let dx = b.x - a.x
    let dy = b.y - a.y
    return sqrt(dx * dx + dy * dy)
}

// पॉइंट्स को पिक्सेल में बदलना
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

उदाहरण में toPixels विधि UIScreen.main.scale के माध्यम से पॉइंट्स को भौतिक पिक्सेल में बदलने का प्रदर्शन करती है। UIKit में यह रूपांतरण रेंडरिंग के दौरान स्वचालित रूप से होता है, लेकिन Core Graphics और Metal के साथ काम करते समय डेवलपर को स्पष्ट पिक्सेल रूपांतरण की आवश्यकता हो सकती है। सभी एनिमेशन गणनाएँ, टकराव का पता लगाना और लेआउट पॉइंट्स में किए जाते हैं।

UIFont.pointSize और टाइपोग्राफ़ी

UIFont.pointSize प्रॉपर्टी फ़ॉन्ट के आकार को पॉइंट्स में लौटाती है — यह iOS में टाइपोग्राफ़ी की मानक इकाई है, जो प्रिंटिंग से विरासत में मिली है (1 pt = 1/72 इंच)। Apple Mac OS के शुरुआती संस्करणों से फ़ॉन्ट के लिए pt का उपयोग कर रहा है। iOS में, फ़ॉन्ट का आकार UIFont.systemFont(ofSize:) या SwiftUI Font.system(size:) के माध्यम से पॉइंट्स में निर्दिष्ट किया जाता है।

// Swift में UIFont.pointSize के साथ कार्य
import UIKit

// pt में आकार के साथ फ़ॉन्ट बनाना
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// pointSize पढ़ना
print("शीर्षक का आकार: \(titleFont.pointSize) pt")

// Dynamic Type — स्वचालित स्केलिंग
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("स्केल किया गया: \(scaledFont.pointSize) pt")

// फ़ॉन्ट आकारों की तुलना
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics — iOS 11 में जोड़ा गया एक गतिशील फ़ॉन्ट स्केलिंग तंत्र है। यह उपयोगकर्ता की एक्सेसिबिलिटी सेटिंग्स (Settings > Display & Brightness > Text Size) के आधार पर pointSize को स्वचालित रूप से समायोजित करता है। UIFontMetrics के उपयोग के बिना, फ़ॉन्ट स्केल नहीं होते, जो WCAG एक्सेसिबिलिटी आवश्यकताओं का उल्लंघन करता है।

pt बनाम px: अंतर

pt और px के बीच का अंतर iOS डेवलपमेंट को समझने के लिए महत्वपूर्ण है। pt एक तार्किक इकाई है, px एक भौतिक इकाई है। एक बिंदु स्केल फ़ैक्टर के आधार पर 1, 2 या 3 पिक्सेल के अनुरूप हो सकता है। डेवलपर पॉइंट्स में काम करता है, सिस्टम रेस्टराइज़ेशन चरण में उन्हें पिक्सेल में बदलता है।

मुख्य निष्कर्ष: एक ही वर्ग के सभी डिवाइसों पर पॉइंट्स में इंटरफ़ेस का आकार समान होता है। 375 pt चौड़ी स्क्रीन — यह iPhone SE और iPhone 14 (बेस मॉडल) दोनों पर लागू होती है। अंतर केवल इतना है कि उन 375 pt में कितने भौतिक पिक्सेल समाते हैं। यह प्रत्येक डिवाइस के लिए मैन्युअल अनुकूलन के बिना एक समान UI सुनिश्चित करता है।

SwiftUI में pt

SwiftUI में, डेवलपर स्पष्ट रूप से पॉइंट्स में काम नहीं करता — सभी आकार Dp (डिवाइस-स्वतंत्र पॉइंट्स, pt के समतुल्य) के माध्यम से निर्दिष्ट किए जाते हैं। SwiftUI रेंडरिंग के दौरान स्वचालित रूप से स्केल फ़ैक्टर लागू करता है लेकिन पर्यावरण मान displayScale के माध्यम से इस तक पहुँच प्रदान करता है।

// SwiftUI — पॉइंट्स और स्केल फ़ैक्टर के साथ कार्य
import SwiftUI

struct ContentView: View {
    @Environment(\.displayScale) private var displayScale

    var body: some View {
        VStack(spacing: 16) {
            Text("शीर्षक")
                .font(.system(size: 28, weight: .bold))

            Text("उदाहरण मुख्य पाठ")
                .font(.body)

            HStack {
                Text("स्केल फ़ैक्टर:")
                    .font(.caption)
                Text("\(displayScale, specifier: "%.1f")")
                    .font(.caption.weight(.bold))
            }
        }
        .padding(20)
        .frame(width: 300)
    }
}

SwiftUI फ्रेमवर्क स्तर पर pt को अमूर्त करता है। .font(.body) स्वचालित रूप से Dynamic Type का उपयोग करता है — फ़ॉन्ट का आकार उपयोगकर्ता की सेटिंग्स के अनुसार समायोजित होता है। SwiftUI पिक्सेल में फ़ॉन्ट का आकार निर्दिष्ट करने की अनुमति नहीं देता — केवल Font और टाइपोग्राफ़ी सिस्टम के माध्यम से। यह डेवलपर के अतिरिक्त प्रयास के बिना इंटरफ़ेस की एक्सेसिबिलिटी सुनिश्चित करता है।