# Fiko Ölçüm Sistemi - Derin Analiz

## 🎯 Sistem Genel Bakış

FikoYT ölçüm sistemi, Three.js tabanlı 3D CAD modelleri üzerinde hassas ölçümler yapabilen kapsamlı bir araçtır.

**Ana Komponentler:**
- **FikoOlcumComponent** - Ana ölçüm yöneticisi
- **KumpasComponent** - Tekil nesne ölçümleri (nokta, çizgi, yüzey)
- **CetvelComponent** - İki nokta arası mesafe ölçümleri
- **FikoYT-Fonksiyonlar** - Matematiksel hesaplama motoru

## 🔍 Kumpas (Tekil Ölçüm) Sistemi

### Ölçüm Tipleri ve Filtreler

```typescript
secim1Turu: "Her Şey" | "Sadece Nokta" | "Sadece Çizgi" | "Sadece Yüzey" | "Sadece Gruplar" | "Nokta Koy"
```

**Raycaster Parametreleri:**
```typescript
// Her Şey modu
params = {
    Mesh: { threshold: 0.2 },
    Line: { threshold: 0.5 },
    LOD: { threshold: 0.3 },
    Points: { threshold: 0.5 },
    Sprite: { threshold: 0.1 }
}

// Sadece Nokta modu
params = {
    Points: { threshold: 1 },
    Mesh/Line/LOD/Sprite: { threshold: 0 }
}
```

### Nokta Ölçümü

**Koordinat Dönüşümü:**
```typescript
// 3D koordinatı al
let koor = new FikoVektor3D(
    secilen.geometry.attributes['position'].getX(index),
    secilen.geometry.attributes['position'].getY(index),
    secilen.geometry.attributes['position'].getZ(index)
);

// Eksene göre dönüştür
let koor1: FikoVektor3D = koor.clone();
koor1.sub(kumpasEksen.merkez);
koor1.applyQuaternion(kumpasEksen.quaternion.clone().invert());
```

**Sonuç Formatı:**
```typescript
sonuc = {
    nokta: {
        vektor: FikoVektor3D,
        x: "12.3456",
        y: "23.4567",
        z: "34.5678"
    }
}
```

### Yüzey Ölçümü

**Hesaplanan Değerler:**
1. **Yüzey Alanı** - m² cinsinden
2. **Ağırlık Merkezi** - 3D koordinat
3. **Düzlem Denklemi** - Normal vektör ve mesafe
4. **Düzlemsellik Testi** - Tüm noktalar aynı düzlemde mi?

**Matematiksel Hesaplamalar:**
```typescript
// Ağırlık merkezi
agirlikMerkeziKoor = secilen.localToWorld(agirlikMerkezi(geometry));

// Düzlem denklemi
duzlemKoor = yuzeyDuzlemAl(geometry);
duzlemKoor.applyMatrix4(kumpasEksen.matrixWorld.clone().invert());

// Düzlemsellik kontrolü
miDuzlemsel = miYuzeyDuzlemsel(geometry);
```

### Çizgi Ölçümü

**Ölçülen Parametreler:**
1. **Uzunluk** - mm cinsinden
2. **Yön Vektörü** - Normalize edilmiş yön
3. **Çember Tespiti** - Eğer çizgi bir yay ise

**Çember Analizi:**
```typescript
let miCem = miCember(geometry);
if (miCem) {
    sonuc.cizgi.cember = {
        yariCap: miCem.yaricap,
        cap: miCem.cap,
        merkez: miCem.merkez,
        aci: sokToleransa(miCem.aci, 0.010),
        nokta1: miCem.nokta1,
        nokta2: miCem.nokta2
    }
}
```

## 📏 Cetvel (Mesafe Ölçüm) Sistemi

### İki Noktalı Seçim

**Sıralı Seçim Mantığı:**
1. İlk nokta seçilir → FikoSecim2 aktifleşir
2. İkinci nokta seçilir → Hesaplama yapılır
3. Sistem sıfırlanır → Yeni ölçüm için hazır

### Mesafe Hesaplama Algoritmaları

#### Nokta-Nokta Mesafesi
```typescript
let nokta1 = secilen1.point;
let nokta2 = secilen2.point;
mesafe = nokta1.distanceTo(nokta2);
```

#### Nokta-Çizgi Mesafesi
```typescript
// Çizgi geometrisini al
let geom = [];
for (var i = strt; i < strt + syi; i++) {
    geom.push(new FikoVektor3D(
        e.geometry.attributes["position"].getX(i),
        e.geometry.attributes["position"].getY(i),
        e.geometry.attributes["position"].getZ(i)
    ));
}

// En kısa mesafeyi hesapla
mesafe = alCizgiNoktaMesafe(
    new THREE.BufferGeometry().setFromPoints(geom),
    nokta
);
```

## 🔧 Matematiksel Hesaplama Motoru

### Hacim Hesabı
```typescript
export const hesaplaHacim = (geometry: THREE.BufferGeometry) => {
    const ucgenHacmi = (p1, p2, p3) => {
        return p1.dot(p2.cross(p3)) / 6.0;
    }

    // Tüm üçgenlerin hacmini topla
    for (let i = 0; i < faces; i++) {
        p1.fromBufferAttribute(position, i * 3 + 0);
        p2.fromBufferAttribute(position, i * 3 + 1);
        p3.fromBufferAttribute(position, i * 3 + 2);
        sum += ucgenHacmi(p1, p2, p3);
    }

    return Math.abs(sum) / 100000; // m³ cinsinden
}
```

### Alan Hesabı
```typescript
export const hesaplaAlan = (geometry: THREE.BufferGeometry) => {
    const ucgenAlani = (p1, p2, p3) => {
        let v1 = p1.clone().sub(p2);
        let v2 = p1.clone().sub(p3);
        let v3 = new THREE.Vector3();
        v3.crossVectors(v1, v2);
        return v3.length() / 2;
    }

    // Tüm üçgenlerin alanını topla
    return area / 1000000; // m² cinsinden
}
```

### Ağırlık Merkezi
```typescript
export const agirlikMerkezi = (geometry: THREE.BufferGeometry) => {
    let center = new THREE.Vector3();

    // Tüm vertex koordinatlarını ortalama
    for (var i = 0; i < geometry.attributes['position'].count; i++) {
        let nokta = new FikoVektor3D(
            geometry.attributes['position'].getX(i),
            geometry.attributes['position'].getY(i),
            geometry.attributes['position'].getZ(i)
        );
        center = center.clone().add(nokta);
    }

    return center.divideScalar(geometry.attributes['position'].count);
}
```

### Düzlemsellik Testi
```typescript
export const miYuzeyDuzlemsel = (geometry: THREE.BufferGeometry) => {
    const tripleProduct = (a, b, c) => {
        return a.clone().dot(
            (new THREE.Vector3()).crossVectors(b, c)
        );
    }

    // 4 nokta koplanar mı?
    const _isCoPlanar = (a, b, c, d) => {
        let ab = b.clone().sub(a);
        let ac = c.clone().sub(a);
        let ad = d.clone().sub(a);
        return tripleProduct(ab, ac, ad) === 0;
    }

    // Tüm noktaları kontrol et
    return isCoPlanar;
}
```

### Çember Tespiti
```typescript
export const ThruPointCember = (points: FikoVektor3D[]) => {
    // 3 noktadan çember geçirme
    // Vektör matematik ile merkez ve yarıçap hesabı

    // Kenar uzunlukları
    let AB = ((XA - XB)² + (YA - YB)² + (ZA - ZB)²) ^ 0.5
    let BC = ((XB - XC)² + (YB - YC)² + (ZB - ZC)²) ^ 0.5
    let AC = ((XA - XC)² + (YA - YC)² + (ZA - ZC)²) ^ 0.5

    // Yön kosinüsleri
    let ABi = (XB - XA) / AB
    let ABj = (YB - YA) / AB
    let ABk = (ZB - ZA) / AB

    // Çember merkezi koordinatları
    let X_Centre = XA + (X2e * ABi) + (Y2e * CDi) + (Z2e * Ni)
    let Y_Centre = YA + (X2e * ABj) + (Y2e * CDj) + (Z2e * Nj)
    let Z_Centre = ZA + (X2e * ABk) + (Y2e * CDk) + (Z2e * Nk)

    return {
        yaricap: R,
        cap: 2 * R,
        merkez: new FikoVektor3D(X_Centre, Y_Centre, Z_Centre)
    }
}
```

## 🎨 UI/UX Özellikleri

### Modal Dialog
- **Sürüklebilir** - Draggable ile handle destekli
- **Semi-transparent** - Arka planı gösterir
- **Glow efect** - Cyan tonlarında görsel efekt

### Kursör Değişimi
```typescript
// Kumpas modu
document.body.style.cursor = "url('/cursor/kumpas-bos.png'), auto";

// Cetvel modu
document.body.style.cursor = "url('/cursor/cetvel-bos.png'), auto";
```

### Real-time Güncelleme
- **ChangeDetectorRef** - Otomatik UI güncellemeleri
- **toFixed()** - Ondalık hassasiyet kontrolü
- **Birim gösterimi** - mm, m², derece

### Sonuç Formatları

**Nokta:**
- X, Y, Z koordinatları (4 decimal)
- mm birimi

**Yüzey:**
- Alan (m², 10 decimal)
- Ağırlık merkezi (4 decimal)
- Düzlem normali (6 decimal)
- Düzlemsellik durumu

**Çizgi:**
- Uzunluk (mm, 6 decimal)
- Yön vektörü (6 decimal)
- Çember bilgileri (varsa)

## 📊 Performans Optimizasyonları

### Raycaster Threshold Değerleri
- Mesh: 0.2-1.0
- Line: 0.5-1.0
- Points: 0.5-1.0
- LOD: 0.3

### Memory Management
- **Subscription cleanup** - OnDestroy'da temizlik
- **Dispose pattern** - Three.js objeleri
- **Event listener removal** - Harita olayları

### Calculation Caching
- **Geometry cloning** - Gereksiz kopyalamadan kaçınma
- **Matrix calculations** - Dönüşüm matrislerini yeniden kullanma
- **Vector operations** - Optimizasyonlu vektör matematiği

## 🔧 Eksen Sistemi Entegrasyonu

### FikoEksen Desteği
```typescript
kumpasEksen: FikoEksen;

// Eksen seçimi için yardımcı
tiklandiEksenSec() {
    fikoRaycastEksenSec = new FikoRaycastCPUYardimci(
        anaGosterim,
        null,
        ["FikoEksen"],
        true
    );
}
```

### Koordinat Dönüşümü
- **Local to World** - `localToWorld()`
- **Quaternion inversion** - `quaternion.clone().invert()`
- **Matrix transformation** - `applyMatrix4()`

## 🎯 Hassasiyet ve Tolerans

### Tolerans Sistemi
```typescript
export const sokToleransa = (num: number, acceptableTolerance: number) => {
    var nearestRoundNumber = Number((num).toFixed(5));
    var difference = Math.abs(nearestRoundNumber - num);
    if (difference <= acceptableTolerance) {
        num = nearestRoundNumber;
    }
    return num;
}
```

### Ondalık Hassasiyet
- **Koordinatlar**: 4 decimal
- **Alanlar**: 10 decimal
- **Uzunluklar**: 6 decimal
- **Açılar**: 6 decimal
- **Normal vektörler**: 6 decimal

## 🚀 Gelecek Özellikler (Planlanan)

### Mezro (Çoklu Cetvel)
- UI'da buton mevcut
- Implementasyon bekleniyor

### Kalıcı Ölçümler
- Checkbox mevcut: "Ölçümler Kalıcı Olsun"
- MongoDB'ye kayıt sistemi

### Hesaplama Modları
- **Kesin, Olmazsa Yaklaşık**
- **Sadece Kesin**
- **Sadece Yaklaşık**

### Gelişmiş Analiz
- **Angle measurements** - Açı ölçümleri
- **Volume calculations** - Hacim hesapları
- **Moment of inertia** - Atalet momenti

---
2025-11-06