# BREP Topoloji Sistemi - FikoYT

## 🎯 Genel Bakış

**FikoBrep** - Gelişmiş Mesh-to-BREP (Boundary Representation) analiz ve dönüşüm sistemi

Bu sistem:
- ✅ Mesh geometrisini BREP topolojisine dönüştürür
- ✅ Yüzey/eğri tiplerini otomatik tanır (plane, cylinder, sphere, cone)
- ✅ Topolojik ilişkileri çıkarır (vertex-edge-face-shell-solid)
- ✅ STEP/IGES formatlarında kullanılan BREP yapısını oluşturur
- ✅ FikoCizimYalin grubunda attribute olarak saklanır

## 📊 Veri Yapısı Hiyerarşisi

```
BrepBody (Ana Yapı)
├── Vertices (Köşeler)
│   └── position, tolerance, edges[]
├── Edges (Kenarlar)
│   ├── startVertex, endVertex
│   ├── curve (line, arc, circle, spline, bezier)
│   └── faces[], convex, angle
├── Loops (Döngüler)
│   ├── edges[] (sıralı, CCW)
│   └── isOuter (dış döngü / delik)
├── Faces (Yüzeyler)
│   ├── surface (plane, cylinder, sphere, cone, torus, nurbs)
│   ├── loops[] (outer + holes)
│   └── normal, area, centroid, color
├── Shells (Kabuklar)
│   ├── faces[]
│   └── isClosed, volume
└── Solids (Katılar)
    ├── outerShell
    ├── voids[]
    └── volume, centerOfMass
```

## 🔧 Kullanım

### 1. FikoCizimYalin'da BREP Analizi

```typescript
import { FikoCizimYalin } from './FikoCizimYalin';

// Mesh geometry'den FikoCizimYalin oluştur
const cizim = new FikoCizimYalin(sahne, "Parça1", meshGeom, edgesGeom, vertexGeom);

// BREP analizini al (lazy evaluation - ilk çağrıda hesaplanır)
const brepAnalysis = cizim.brepAnalysis;

// BREP istatistikleri
const stats = cizim.brepStats;
console.log(`Vertex: ${stats.vertices}`);
console.log(`Edge: ${stats.edges}`);
console.log(`Face: ${stats.faces}`);
console.log(`Shell: ${stats.shells}`);
console.log(`Solid: ${stats.solids}`);

// Topoloji bilgisi
const topology = cizim.brepTopology;
console.log(`Manifold: ${topology.manifold}`); // Her edge max 2 face'e bağlı
console.log(`Watertight: ${topology.watertight}`); // Su geçirmez mi
console.log(`Genus: ${topology.genus}`); // Delik sayısı

// Feature'lar (yüzey tipleri)
const features = cizim.brepFeatures;
console.log(`Düzlem sayısı: ${features.planes}`);
console.log(`Silindir sayısı: ${features.cylinders}`);
console.log(`Küre sayısı: ${features.spheres}`);

// Geometrik özellikler
const geometry = cizim.brepGeometry;
console.log(`Convex edges: ${geometry.convexEdges}`);
console.log(`Sharp edges: ${geometry.sharpEdges}`);

// BREP'i konsolda debug et
cizim.debugBrep();
```

### 2. Sağ Menüden BREP Analizi

```typescript
// FikoCizimYalin'da sağ tık → "BREP Topoloji Analizi" 🔬
// Otomatik analiz yapılır ve alert ile gösterilir
```

### 3. Manuel BREP Analizi

```typescript
import { FikoBrep } from './FikoBrep/FikoBrep';

const brepEngine = new FikoBrep();

const analysis = brepEngine.meshtenBrepOlustur(meshGeometry, {
    tolerance: 1e-6,                // Geometrik tolerans
    recognizeSurfaces: true,        // Yüzey tanıma yap
    recognizeCurves: true,          // Eğri tanıma yap
    simplify: false,                // Basitleştirme yapma
    mergeCoplanarFaces: true        // Eş düzlemli yüzeyleri birleştir
});

// BREP body
const brep = analysis.brep;

// Vertex'lere erişim
brep.vertices.forEach((vertex, id) => {
    console.log(`${id}: ${vertex.position.toArray()}`);
});

// Edge'lere erişim
brep.edges.forEach((edge, id) => {
    console.log(`${id}: ${edge.curve.type} - ${edge.length.toFixed(2)}mm`);
});

// Face'lere erişim
brep.faces.forEach((face, id) => {
    console.log(`${id}: ${face.surface.type} - ${face.area.toFixed(2)}mm²`);
});
```

## 🎨 Yüzey Tanıma Algoritmaları

### 1. Düzlem (Plane) - Least Squares Fitting

```typescript
import { FikoBrepSurfaceRecognition } from './FikoBrep/FikoBrepSurfaceRecognition';

const recognizer = new FikoBrepSurfaceRecognition(1e-6);

// Nokta listesinden düzlem fit et
const planeResult = recognizer.fitPlane(points);

console.log('Origin:', planeResult.origin);
console.log('Normal:', planeResult.normal);
console.log('Error:', planeResult.error);
```

**Algoritma:** Kovaryans matrisi eigenvalue decomposition

**Hata Toleransı:** `tolerance * 10`

### 2. Silindir (Cylinder) - RANSAC

```typescript
const cylinderResult = recognizer.fitCylinder(points);

console.log('Axis:', cylinderResult.axis);
console.log('Radius:', cylinderResult.radius);
console.log('Center:', cylinderResult.center);
console.log('Height:', cylinderResult.height);
console.log('Error:', cylinderResult.error);
```

**Algoritma:** RANSAC (100 iterasyon) + Least Squares refinement

**Hata Toleransı:** `tolerance * 20`

### 3. Küre (Sphere) - Gauss-Newton

```typescript
const sphereResult = recognizer.fitSphere(points);

console.log('Center:', sphereResult.center);
console.log('Radius:', sphereResult.radius);
console.log('Error:', sphereResult.error);
```

**Algoritma:** Gauss-Newton iterasyonu (10 iterasyon)

**Hata Toleransı:** `tolerance * 15`

### 4. Koni (Cone) - RANSAC (TODO)

```typescript
const coneResult = recognizer.fitCone(points);

console.log('Apex:', coneResult.apex);
console.log('Axis:', coneResult.axis);
console.log('Angle:', coneResult.angle);
```

**Algoritma:** RANSAC + cone fitting (henüz implementasyonda)

**Hata Toleransı:** `tolerance * 25`

## 💾 JSON Serileştirme

### BREP'i JSON'a Çevirme

```typescript
import { FikoBrepSerializer } from './FikoBrep/FikoBrepSerializer';

// BREP body'yi JSON'a çevir
const json = FikoBrepSerializer.brepToJson(brepBody);

// JSON string olarak kaydet
const jsonString = JSON.stringify(json, null, 2);

// Dosyaya kaydet
const blob = new Blob([jsonString], { type: 'application/json' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'brep-topoloji.json';
a.click();
```

### JSON'dan BREP Yükleme

```typescript
// JSON'dan BREP body oluştur
const brep = FikoBrepSerializer.jsonToBrep(json);

console.log('Vertices:', brep.vertices.size);
console.log('Edges:', brep.edges.size);
console.log('Faces:', brep.faces.size);
```

### MeshAnalysisResult Serileştirme

```typescript
// Tam analiz sonucunu JSON'a çevir
const analysisJson = FikoBrepSerializer.analysisToJson(meshAnalysis);

// JSON formatı:
{
    "brep": { /* BrepBody */ },
    "features": {
        "planes": ["F1", "F2"],
        "cylinders": ["F3"],
        "spheres": [],
        "cones": [],
        "freeform": []
    },
    "topology": {
        "manifold": true,
        "watertight": true,
        "eulerCharacteristic": 2,
        "genus": 0
    },
    "geometry": {
        "convexEdges": ["E1", "E2"],
        "concaveEdges": [],
        "sharpEdges": ["E3"],
        "smoothEdges": []
    }
}
```

## 📐 Topolojik Kavramlar

### 1. Manifold (Manifold Mesh)

- **Tanım:** Her edge maksimum 2 face'e bağlıdır
- **Kontrol:** `topology.manifold`
- **Önemli:** CAD modelleme için gerekli

### 2. Watertight (Su Geçirmez)

- **Tanım:** Her edge tam 2 face'e bağlıdır (delik yok)
- **Kontrol:** `topology.watertight`
- **Önemli:** 3D baskı için gerekli

### 3. Euler Karakteristiği (χ)

- **Formül:** χ = V - E + F
- **Kapalı yüzey:** χ = 2 (küre)
- **Torus:** χ = 0
- **Genus (g):** g = 1 - χ/2 (delik sayısı)

### 4. Orientable (Yönlendirilebilir)

- **Tanım:** Face normalleri tutarlı yönlendirilmiş
- **Kontrol:** `topology.orientable`
- **Örnekler:** Möbius şeridi orientable değil

## 🔬 Geometrik Özellikler

### 1. Convex Edge (Dışbükey Kenar)

- **Tanım:** Komşu face normalleri arası açı < 180°
- **Kullanım:** CNC torna işlemlerinde

### 2. Concave Edge (İçbükey Kenar)

- **Tanım:** Komşu face normalleri arası açı > 180°
- **Kullanım:** Undercut tespiti

### 3. Sharp Edge (Keskin Kenar)

- **Tanım:** Açı > 30°
- **Kullanım:** Kenar yuvarlatma (chamfer/fillet) gerektirir

### 4. Smooth Edge (Düz Kenar)

- **Tanım:** Açı < 10°
- **Kullanım:** Smooth shading için uygun

## 🚀 Performans

### Cache Sistemi

```typescript
// BREP analizi cache'lenir (dirty flag ile)
const analysis1 = cizim.brepAnalysis; // İlk çağrı - hesaplanır
const analysis2 = cizim.brepAnalysis; // İkinci çağrı - cache'den döner

// Geometry değişirse cache invalidate edilir
cizim.invalidatePropertyCache(); // BREP de invalidate edilir

// Manuel yeniden hesaplama
cizim.recomputeBrep();
```

### Optimizasyonlar

- ✅ **Lazy Evaluation:** İlk çağrıda hesaplanır
- ✅ **Dirty Flag:** Sadece gerektiğinde yeniden hesaplanır
- ✅ **Map Kullanımı:** O(1) lookup
- ✅ **RANSAC:** Max 100 iterasyon
- ✅ **Vertex Deduplication:** Position hash ile

## 🛠️ Dosyalar

| Dosya | Açıklama |
|-------|----------|
| `FikoBrep.ts` | Ana BREP sistemi - mesh-to-brep dönüşümü |
| `FikoBrepSurfaceRecognition.ts` | Yüzey tanıma algoritmaları (RANSAC, Least Squares) |
| `FikoBrepSerializer.ts` | JSON serileştirme/deserialize |
| `FikoCizimYalin.ts` | BREP entegrasyonu (attributes, getters) |

## 📝 Örnek Kullanım Senaryoları

### 1. STEP Import Analizi

```typescript
// STEP dosyasını import et
const importer = new FikoImporterSTP(sahne);
const cizim = await importer.stpDosyasiniYukle(file);

// BREP analizini çıkar
const topology = cizim.brepTopology;

if (!topology.manifold) {
    alert('Uyarı: Model manifold değil! Bazı edge\'ler 2\'den fazla face\'e bağlı.');
}

if (!topology.watertight) {
    alert('Uyarı: Model su geçirmez değil! 3D baskı için uygun değil.');
}

// Feature sayısını raporla
const features = cizim.brepFeatures;
console.log(`Model ${features.planes} düzlem, ${features.cylinders} silindir içeriyor.`);
```

### 2. CAM İşleme Analizi

```typescript
// Keskin kenarları tespit et (chamfer/fillet gerekir)
const geometry = cizim.brepGeometry;
console.log(`${geometry.sharpEdges} keskin kenar tespit edildi.`);

// Concave edge'leri tespit et (undercut riski)
console.log(`${geometry.concaveEdges} içbükey kenar tespit edildi (undercut riski).`);

// BREP body'den edge'lere eriş
const brep = cizim.brepBody;
brep.edges.forEach((edge, id) => {
    if (edge.angle > 30 && !edge.convex) {
        console.warn(`${id}: İşlenemez bölge (concave + sharp)`);
    }
});
```

### 3. Kalite Kontrolü

```typescript
// Euler karakteristiği kontrolü
const topology = cizim.brepTopology;
if (topology.eulerCharacteristic !== 2) {
    console.warn(`Topolojik hata: χ = ${topology.eulerCharacteristic} (beklenen: 2)`);
}

// Genus kontrolü (delik sayısı)
if (topology.genus > 0) {
    console.log(`Model ${topology.genus} delik içeriyor.`);
}

// Yüzey tanıma kalitesi
const analysis = cizim.brepAnalysis;
analysis.brep.faces.forEach((face, id) => {
    if (face.surface.type === 'freeform') {
        console.warn(`${id}: Tanınamayan yüzey (freeform) - manuel kontrol gerekli`);
    }
});
```

## ⚠️ Limitasyonler

- ❌ **Cone Fitting:** Henüz implemente edilmedi (placeholder)
- ❌ **Torus Fitting:** Henüz implementasyonda değil
- ❌ **NURBS Surface:** Henüz desteklenmiyor
- ❌ **Loop Extraction:** TODO
- ❌ **Shell Extraction:** TODO
- ❌ **Solid Extraction:** TODO

## 🔄 Gelecek Geliştirmeler

1. **Loop/Shell/Solid Extraction:** Face'lerden topolojik yapıları çıkar
2. **Cone/Torus Fitting:** RANSAC ile koni ve halka yüzey tanıma
3. **NURBS Surface Recognition:** Serbest form yüzeyler için NURBS fitting
4. **Boundary Loop Detection:** Face boundary'lerini otomatik tespit et
5. **Face Merging:** Eş düzlemli komşu face'leri birleştir
6. **Curve Recognition:** Edge'lerden arc/spline tanıma
7. **STEP/IGES Export:** BREP'ten STEP/IGES formatına export

---

**Güncelleme:** 2025-11-27
**Versiyon:** 1.0.0
**Durum:** İlk implementasyon tamamlandı (vertex/edge extraction, surface recognition, JSON serialization)