Yön ve Eksen Ayrıştırması

Problem Tanımı

Bir maç zaman çizelgesinde 24 olay var ve hepsi tek bir yatay eksene diziliyor. Olaylar zamanda kümeleniyor — 22., 23. ve 24. dakikalarda üç ayrı olay. Etiketler üst üste biniyor.

Sektörde bu problemin üç standart “çözümü” var ve üçü de veri siler:

Bazı etiketleri gizle — hangilerinin gizlendiği yazılmaz.
Yalnızca “önemli” olayları göster — önem eşiği açıklanmaz.
Etiketleri döndür — okunabilirlik düşer, çakışma tam çözülmez.

İkinci bir problem saha haritalarında ortaya çıkar: takımlar devre arasında saha değiştirir. Ham koordinatlar normalize edilmezse, bir takımın ilk yarı sol kanattaki yoğunluğu ile ikinci yarı sağ kanattaki yoğunluğu ısı haritasında birbirini götürür. Grafik “bu takımın kanat tercihi yok” der; oysa veri tam tersini söylüyordur.

Ortak kök: yön, verinin bir boyutu olduğu hâlde düzenin bir boyutu değil.

Matematiksel / Mantıksal Model

Eksen ayrıştırması

Her olay $e$ , bir zaman ve bir hücum yönü taşır. Yönü düzenin bir ekseni yapmak, problemi ikiye böler:

e \mapsto (\sigma, t), \qquad \sigma = \operatorname{sign}(\text{hücum yönü}) \in \{-1, +1\}

Olaylar $\sigma$ ‘ya göre eksenin iki yanına ayrılır. Bu tek adım, olay yoğunluğunu yarıya indirir ve iki yön arasındaki çakışma olasılığını sıfırlar — farklı taraftaki iki etiket tanım gereği üst üste binemez.

Şerit paketleme

Aynı taraftaki olaylar hâlâ çakışabilir. Bir etiketin okunabilmesi için gereken en küçük dikey ayrım:

\delta_{\min} = \frac{h_{\text{etiket}}}{p}, \qquad p = \frac{H_{\text{çizim}}}{T}

$p$ dakika başına piksel. Bu sayfadaki grafikte çizim alanı $H = 610$ birim, $T = 90\,\text{dk}$ , dolayısıyla $p \approx 6.78$ birim/dk. Etiket yüksekliği $11$ birim (font boyutu) için:

\delta_{\min} = \frac{11}{6.78} \approx 1.62\ \text{dakika}

Bu türetilmiş bir eşik, tahmin değil: aşağıdaki grafikte kaydırıcıyı $1.0$ ‘a çektiğinizde — yani algoritmaya etiketin gerçekte ihtiyaç duyduğundan daha az yer gerektiğini söylediğinizde — etiketler yeniden çakışmaya başlar. $1.62$ ‘nin üzerinde hiç çakışma kalmaz.

Yerleşim, zamana göre sıralanmış olaylar üzerinde açgözlü aralık paketlemesidir:

sırala(olaylar, zamana göre)
her yön için şeritler ← []

her olay için:
    hedef ← son yerleşimi olay.t - δ_min'den eski olan ilk şerit
    hedef yoksa:
        yeni şerit aç
    olayı hedefe yerleştir
    hedefin son zamanını olay.t yap

Karmaşıklık $O(n \cdot k)$ ; $k$ = şerit sayısı, pratikte 2–4. Algoritma hiçbir olayı düşürmez — çakışmayı genişlik harcayarak çözer.

Kanonik saha çerçevesi

Isı haritaları ve pas ağları için koordinatlar tek bir yöne çevrilir:

x' = \begin{cases} x & \text{takım soldan sağa hücum ediyorsa} \\ 100 - x & \text{aksi hâlde} \end{cases}

Kural: her takım her zaman soldan sağa hücum ediyormuş gibi çizilir. Devre, ev sahibi/deplasman ve saha değişimi bu dönüşümde soğurulur.

Arayüz Kararları

Zaman ekseni dikey. Yatay eksende etiketler yazı yönüyle çakışır ve dönmek zorunda kalır. Dikey eksende etiketler yatay kalır; okunabilirlik korunur ve şeritler yatayda açılabilir — yani çakışma çözümü için doğal bir boşluk vardır.

Yön, eksenin iki yanı. Renk ikincil kodlamadır, birincil değil. Renk körü bir okuyucu için de taraf, konumdan okunur.

Bağlantı çizgisi zorunlu. Etiket şerit değiştirdiğinde eksenden uzaklaşır; hangi zamana ait olduğu ince bir yatay çizgiyle bağlanmazsa kaybolur.

Şerit taşmasında kümeleme rozeti. Şerit sayısı ekrana sığmayacak kadar artarsa (dar ekran, yoğun aralık), aynı zaman aralığındaki olaylar tek bir +3 olay rozetinde toplanır ve rozet açılabilir olur. Kritik nokta: kaç tanesinin gizlendiği yazılır. Veri sessizce düşmez.

Dar ekranda grafik kendi kabında kayar. Sayfa gövdesi yatay kaymaz; kaydırma görselleştirmenin kendi kapsayıcısında olur.

Doğru / Yanlış Karşılaştırması

Aşağıdaki çizelgede 24 olay var. $\delta_{\min}$ kaydırıcısını büyüttükçe her yönün kaç şerit açtığını, ve aynı olayların tek şeride zorlanması hâlinde kaç etiketin çakışacağını izleyin.

← DeplasmanEv sahibi →

δ_min4.0 dk

Ev sahibi şeridi: 3
Deplasman şeridi: 2
Tek şeritte çakışma: 12

δ_min = etiket yüksekliği ÷ dakika başına piksel. Yön ayrıştırması olmadan tüm bu olaylar tek eksene binerdi ve "tek şeritte çakışma" sayısı kadar etiket okunamazdı. Şerit paketleme, çakışmayı gizlemek yerine genişlik harcayarak çözer — hiçbir olay düşürülmez.

$\delta_{\min} = 4$ dakikada tablo şöyle: ev sahibi 3 şerit, deplasman 2 şerit, hiçbir olay kaybolmadı. Tek şeritli naif düzende ise 24 olayın 12’si komşusuyla çakışırdı — yani yarısı okunamaz ya da silinirdi.

$\delta_{\min}$	Ev şeridi	Deplasman şeridi	Tek şeritte çakışma
1 dk	1	1	0 / 24
2 dk	2	2	9 / 24
4 dk	3	2	12 / 24
6 dk	3	2	13 / 24
8 dk	3	2	22 / 24

Son sütun, yön ayrıştırmasının tek başına ne kadar iş yaptığını gösterir: aynı olaylar tek eksene bindirildiğinde $\delta_{\min} = 8$ dakikada 24 etiketin 22’si komşusuyla çakışırdı. İki şeritli düzende bu sayı sıfırdır.

Yerleşim mantığı düzeyinde fark:

Çakışanı düşür

// Tek eksen, çakışanı ele
const yerlesim = [];
let sonY = -Infinity;

for (const olay of sirala(olaylar)) {
  const y = olay.t * pxPerDk;
  if (y - sonY < ETIKET_H) continue;  // ← sessizce düşer
  yerlesim.push({ ...olay, y, x: 0 });
  sonY = y;
}
// 24 olaydan 12'si kayboldu.
// Hangileri? Grafikte yazmıyor.

Yönü ayrıştır, şeride yerleştir

// Yön eksenin bir boyutu; çakışma şeritle çözülür
const seritler = new Map();   // yön → son zamanlar
const yerlesim = [];

for (const olay of sirala(olaylar)) {
  const L = seritler.get(olay.yon) ?? [];
  let s = L.findIndex((t) => olay.t - t >= DELTA_MIN);
  if (s === -1) { s = L.length; L.push(olay.t); }
  else L[s] = olay.t;
  seritler.set(olay.yon, L);

  yerlesim.push({ ...olay, serit: s });
}
// 24 olayın 24'ü yerinde.

Saha koordinatlarında da aynı ayrım:

Ham koordinat

const noktalar = olaylar.map((o) => ({
  x: o.x,          // ham saha koordinatı
  y: o.y,
}));
// İlk yarı sol kanat + ikinci yarı sağ kanat
// → ısı haritasında birbirini götürür
// → "kanat tercihi yok" (yanlış)

Kanonik çerçeve

const solaSaga = (o) =>
  o.devre === 1 ? o.evSahibi : !o.evSahibi;

const noktalar = olaylar.map((o) => ({
  x: solaSaga(o) ? o.x : 100 - o.x,
  y: solaSaga(o) ? o.y : 100 - o.y,
}));
// Her iki yarı aynı yöne toplanır
// → gerçek kanat tercihi görünür

Alanlar arası karşılık

Şerit paketleme, “aynı eksene düşen ayrık olayları çakıştırmadan yerleştir” probleminin genel çözümü. Yön ayrıştırması ise “verinin bir kategorik boyutunu düzenin bir eksenine terfi ettir” fikri.

Alan	Eksen	Yön / kategori	Şerit ihtiyacı
Futbol	Maç dakikası	Hücum yönü	Kümelenen olaylar
Ürün analitiği	Kullanıcı zaman çizelgesi	Oturum kaynağı	Aynı saniyedeki olaylar
Finans	İşlem zamanı	Alış / satış	Yoğun işlem pencereleri
Yazılım	Commit geçmişi	Dal (branch)	Paralel dallar
Proje yönetimi	Takvim	Ekip	Çakışan görevler

Git commit grafiğinin dalları yan yana çizmesiyle maç zaman çizelgesinin hücum yönünü ayırması aynı algoritmadır. Fark yalnızca $\delta_{\min}$ ‘in neyden türetildiğinde.