pt — wat het is, Points en schaling in iOS

Wat is pt in iOS?

pt (point) — logische meeteenheid in iOS waarmee de ontwikkelaar de interface kan beschrijven in abstracte coördinaten, onafhankelijk van de fysieke schermresolutie. Apple introduceerde het concept van points met de lancering van de iPhone 4 en het Retina-scherm in 2010. Vóór Retina gebruikten ontwikkelaars direct pixels — één UI-pixel was gelijk aan één fysieke pixel.

Het iOS-coördinatensysteem is gebouwd op punten: punt (0,0) bevindt zich in de linkerbovenhoek van het scherm, de X-as is naar rechts gericht, de Y-as naar beneden. De schermgrootte in punten blijft constant voor elke apparaatklasse: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (staand), 1024×768 pt (liggend). De fysieke resolutie kan 1179×2556 px zijn (iPhone 15 Pro) — maar de ontwikkelaar werkt met punten.

Volgens de Apple Human Interface Guidelines zijn punten de fundamentele abstractie van UIKit. Alle frameworks — UIKit, SwiftUI, Core Graphics, SpriteKit — werken met punten. Conversie naar pixels gebeurt automatisch tijdens het renderen via UIScreen.nativeScale.

Schaalfactoren: @1x, @2x, @3x

De schaalfactor (scale factor) bepaalt hoeveel fysieke pixels overeenkomen met één logisch punt. Apple gebruikt drie niveaus: @1x — 1 pt = 1 px (iPad mini zonder Retina, oudere modellen), @2x — 1 pt = 2 px (de meeste iPhones tot 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X en nieuwer, inclusief iPhone 15 Pro).

De waarde van de schaalfactor is beschikbaar via UIScreen.main.scale (voor UIKit) en @Environment(\.displayScale) (voor SwiftUI). Het wordt gebruikt bij het laden van assets: het systeem selecteert automatisch de afbeelding met het achtervoegsel @2x of @3x uit Assets.xcassets. De ontwikkelaar laadt geen @1x-afbeeldingen op Retina-apparaten — dit vermindert de prestaties en kwaliteit.

CGPoint en coördinaten in punten

De structuur CGPoint — het basistype voor weergave van coördinaten in iOS en macOS. Bevat twee velden: x (CGFloat) en y (CGFloat), waarden worden in punten gegeven. CGPoint wordt gebruikt in alle Apple-frameworks: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — werken met coördinaten in punten
import UIKit

// Punt aanmaken
let point = CGPoint(x: 100.0, y: 200.0)
print("Coördinaten: \(point.x), \(point.y)")

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

// Afstand tussen punten
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)
}

// Punt converteren naar pixels
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

De methode toPixels in het voorbeeld demonstreert de conversie van punten naar fysieke pixels via UIScreen.main.scale. In UIKit gebeurt deze conversie automatisch tijdens het renderen, maar in Core Graphics en bij het werken met Metal kan de ontwikkelaar een expliciete conversie naar pixels nodig hebben. Alle berekeningen van animaties, botsingsdetectie en layout worden in punten uitgevoerd.

UIFont.pointSize en typografie

De eigenschap UIFont.pointSize retourneert de lettergrootte in punten — dit is de standaard typografie-eenheid in iOS, overgenomen uit de drukkunst (1 pt = 1/72 inch). Apple gebruikt pt voor lettertypen sinds de eerste versies van Mac OS. In iOS wordt de lettergrootte in punten ingesteld via UIFont.systemFont(ofSize:) of via SwiftUI Font.system(size:).

// Werken met UIFont.pointSize in Swift
import UIKit

// Lettertype maken met grootte 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)

// pointSize lezen
print("Kopgrootte: \(titleFont.pointSize) pt")

// Dynamisch type — automatisch schalen
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Geschaald: \(scaledFont.pointSize) pt")

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

UIFontMetrics — het mechanisme voor dynamische schaling van lettertypen, toegevoegd in iOS 11. Het corrigeert automatisch de pointSize op basis van de toegankelijkheidsinstellingen van de gebruiker (Settings > Display & Brightness > Text Size). Zonder gebruik van UIFontMetrics worden lettertypen niet geschaald, wat de WCAG-toegankelijkheidseisen schendt.

pt vs px: verschillen

Het verschil tussen pt en px is cruciaal voor het begrijpen van iOS-ontwikkeling. pt — logische eenheid, px — fysieke eenheid. Eén punt kan overeenkomen met 1, 2 of 3 pixels, afhankelijk van de schaalfactor. De ontwikkelaar werkt met punten, het systeem zet ze om in pixels tijdens de rasterisatie.

Het belangrijkste gevolg: de interfacegrootte in punten is hetzelfde op alle apparaten van dezelfde klasse. Een scherm van 375 pt breed — dat is zowel de iPhone SE als de iPhone 14 (basismodel). Het verschil zit alleen in hoeveel fysieke pixels er in deze 375 pt passen. Dit zorgt voor een uniforme UI zonder handmatige aanpassing per apparaat.

pt in SwiftUI

In SwiftUI werkt de ontwikkelaar niet expliciet met punten — alle afmetingen worden gegeven via Dp (device-independent points, equivalent van pt). SwiftUI past automatisch de schaalfactor toe tijdens het renderen, maar biedt toegang via de environment value displayScale.

// SwiftUI — werken met punten en schaalfactor
import SwiftUI

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

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

            Text("Hoofdtekst van voorbeeld")
                .font(.body)

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

SwiftUI abstraheert pt op frameworkniveau. .font(.body) gebruikt automatisch Dynamic Type — de lettergrootte past zich aan de gebruikersinstellingen aan. SwiftUI staat niet toe de lettergrootte in pixels in te stellen — alleen via Font en het typografiesysteem. Dit garandeert de toegankelijkheid van de interface zonder extra inspanning van de ontwikkelaar.