pt — cosa sono, Points e ridimensionamento in iOS

Cosa sono i pt in iOS?

pt (point) — unità di misura logica in iOS che consente allo sviluppatore di descrivere l'interfaccia in coordinate astratte, indipendenti dalla risoluzione fisica del display. Apple ha introdotto il concetto di points con il lancio dell'iPhone 4 e del display Retina nel 2010. Prima di Retina, gli sviluppatori usavano direttamente i pixel — un pixel dell'interfaccia corrispondeva a un pixel fisico.

Il sistema di coordinate iOS è basato sui punti: il punto (0,0) si trova nell'angolo superiore sinistro dello schermo, l'asse X va verso destra, l'asse Y verso il basso. La dimensione dello schermo in punti rimane costante per ogni classe di dispositivi: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (ritratto), 1024×768 pt (paesaggio). La risoluzione fisica può essere 1179×2556 px (iPhone 15 Pro) — ma lo sviluppatore lavora con i punti.

Secondo le Apple Human Interface Guidelines, i punti sono l'astrazione fondamentale di UIKit. Tutti i framework — UIKit, SwiftUI, Core Graphics, SpriteKit — operano in punti. La conversione in pixel avviene automaticamente durante il rendering tramite UIScreen.nativeScale.

Fattori di scala: @1x, @2x, @3x

Il fattore di scala determina quanti pixel fisici corrispondono a un punto logico. Apple usa tre livelli: @1x — 1 pt = 1 px (iPad mini senza Retina, modelli vecchi), @2x — 1 pt = 2 px (la maggior parte degli iPhone precedenti al 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X e successivi, incluso iPhone 15 Pro).

Il fattore di scala è disponibile tramite UIScreen.main.scale (per UIKit) e @Environment(\.displayScale) (per SwiftUI). Viene utilizzato durante il caricamento delle risorse: il sistema seleziona automaticamente l'immagine con il suffisso @2x o @3x da Assets.xcassets. Lo sviluppatore non deve caricare immagini @1x su dispositivi Retina — ciò riduce prestazioni e qualità.

CGPoint e coordinate in punti

La struttura CGPoint è il tipo base per rappresentare coordinate in iOS e macOS. Contiene due campi: x (CGFloat) e y (CGFloat), i valori sono specificati in punti. CGPoint viene utilizzato in tutti i framework Apple: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — lavoro con le coordinate in punti
import UIKit

// Creazione di un punto
let point = CGPoint(x: 100.0, y: 200.0)
print("Coordinate: \(point.x), \(point.y)")

// Operazioni matematiche
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Distanza tra punti
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)
}

// Conversione di punti in pixel
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

Il metodo toPixels nell'esempio mostra la conversione di punti in pixel fisici tramite UIScreen.main.scale. In UIKit questa conversione avviene automaticamente durante il rendering, ma in Core Graphics e quando si lavora con Metal, lo sviluppatore potrebbe aver bisogno di una conversione esplicita in pixel. Tutti i calcoli di animazioni, rilevamento collisioni e layout vengono eseguiti in punti.

UIFont.pointSize e tipografia

La proprietà UIFont.pointSize restituisce la dimensione del carattere in punti — è l'unità tipografica standard in iOS, ereditata dalla stampa (1 pt = 1/72 pollice). Apple utilizza pt per i caratteri fin dalle prime versioni di Mac OS. In iOS, la dimensione del carattere è specificata in punti tramite UIFont.systemFont(ofSize:) o tramite SwiftUI Font.system(size:).

// Lavoro con UIFont.pointSize in Swift
import UIKit

// Creazione di un carattere con dimensione in pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Lettura di pointSize
print("Dimensione titolo: \(titleFont.pointSize) pt")

// Dynamic Type — ridimensionamento automatico
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Ridimensionato: \(scaledFont.pointSize) pt")

// Confronto dimensioni caratteri
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics è un meccanismo di ridimensionamento dinamico dei caratteri aggiunto in iOS 11. Regola automaticamente pointSize in base alle impostazioni di accessibilità dell'utente (Settings > Display & Brightness > Text Size). Senza UIFontMetrics, i caratteri non vengono ridimensionati, violando i requisiti di accessibilità WCAG.

pt vs px: differenze

La differenza tra pt e px è fondamentale per capire lo sviluppo iOS. pt è un'unità logica, px è un'unità fisica. Un punto può corrispondere a 1, 2 o 3 pixel a seconda del fattore di scala. Lo sviluppatore opera in punti, il sistema li converte in pixel nella fase di rasterizzazione.

Conclusione chiave: la dimensione dell'interfaccia in punti è la stessa su tutti i dispositivi della stessa classe. Uno schermo largo 375 pt — questo vale sia per iPhone SE che per iPhone 14 (modello base). L'unica differenza è quanti pixel fisici entrano in quei 375 pt. Questo garantisce un'interfaccia utente uniforme senza adattamento manuale per ogni dispositivo.

pt in SwiftUI

In SwiftUI, lo sviluppatore non opera esplicitamente con i punti — tutte le dimensioni sono specificate tramite Dp (punti indipendenti dal dispositivo, equivalenti a pt). SwiftUI applica automaticamente il fattore di scala durante il rendering ma fornisce accesso ad esso tramite il valore di ambiente displayScale.

// SwiftUI — lavoro con punti e fattore di scala
import SwiftUI

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

    var body: some View {
        VStack(spacing: 16) {
            Text("Titolo")
                .font(.system(size: 28, weight: .bold))

            Text("Testo di esempio del corpo")
                .font(.body)

            HStack {
                Text("Fattore di scala:")
                    .font(.caption)
                Text("\(displayScale, specifier: "%.1f")")
                    .font(.caption.weight(.bold))
            }
        }
        .padding(20)
        .frame(width: 300)
    }
}

SwiftUI astrae pt a livello di framework. .font(.body) utilizza automaticamente Dynamic Type — la dimensione del carattere si adatta alle impostazioni dell'utente. SwiftUI non consente di specificare la dimensione del carattere in pixel — solo tramite Font e il sistema tipografico. Questo garantisce l'accessibilità dell'interfaccia senza sforzo aggiuntivo da parte dello sviluppatore.