# FIKO CAD SMART MEASURE SYSTEM
## CATIA/SolidWorks Seviyesinde Profesyonel Olcum Sistemi

---

## 1. AKILLI OLCUM MODU (Smart Measure)

### 1.1 Secim Bazli Otomatik Olcum Tipi

```typescript
/**
 * CATIA'nin "Smart Measure" ozelligine karsilik gelir.
 * Secime gore otomatik olcum tipi tespit eder.
 */
export class SmartMeasureMode {

    /**
     * Tek secim durumu - Kumpas modu
     */
    detectSingleSelection(selection: GeometryReference): MeasurementType {
        switch (selection.type) {
            case ReferenceType.POINT:
            case ReferenceType.VERTEX:
                return MeasurementType.COORDINATE;      // Koordinat goster

            case ReferenceType.EDGE:
                if (this.isCircularEdge(selection)) {
                    return MeasurementType.RADIUS;      // R goster
                }
                if (this.isArcEdge(selection)) {
                    return MeasurementType.ARC_LENGTH;  // Yay uzunlugu
                }
                return MeasurementType.LENGTH;          // Kenar uzunlugu

            case ReferenceType.FACE:
                if (this.isCylindricalFace(selection)) {
                    return MeasurementType.DIAMETER;    // Cap goster
                }
                if (this.isSphericalFace(selection)) {
                    return MeasurementType.SPHERE_RADIUS;
                }
                if (this.isConicalFace(selection)) {
                    return MeasurementType.CONE_ANGLE;
                }
                return MeasurementType.AREA;            // Alan goster

            case ReferenceType.CIRCLE:
                return MeasurementType.DIAMETER;        // Cap goster

            case ReferenceType.ARC:
                return MeasurementType.ARC_PROPERTIES;  // R + yay uzunlugu + aci

            case ReferenceType.CYLINDER:
                return MeasurementType.DIAMETER;        // Silindir capi

            case ReferenceType.CONE:
                return MeasurementType.CONE_PROPERTIES; // Aci + cap

            case ReferenceType.SPHERE:
                return MeasurementType.SPHERE_RADIUS;   // Kure yaricapi

            default:
                return MeasurementType.UNKNOWN;
        }
    }

    /**
     * Cift secim durumu - Cetvel modu
     */
    detectDoubleSelection(
        selA: GeometryReference,
        selB: GeometryReference
    ): MeasurementType {

        // Nokta - Nokta
        if (isPoint(selA) && isPoint(selB)) {
            return MeasurementType.POINT_TO_POINT;
        }

        // Nokta - Cizgi
        if (isPoint(selA) && isEdge(selB) || isEdge(selA) && isPoint(selB)) {
            return MeasurementType.POINT_TO_LINE;
        }

        // Nokta - Yuzey
        if (isPoint(selA) && isFace(selB) || isFace(selA) && isPoint(selB)) {
            return MeasurementType.POINT_TO_PLANE;
        }

        // Cizgi - Cizgi
        if (isEdge(selA) && isEdge(selB)) {
            if (this.areParallel(selA, selB)) {
                return MeasurementType.LINE_TO_LINE_PARALLEL;
            }
            if (this.areCoplanar(selA, selB)) {
                return MeasurementType.ANGLE;
            }
            return MeasurementType.LINE_TO_LINE_SKEW;
        }

        // Yuzey - Yuzey
        if (isFace(selA) && isFace(selB)) {
            if (this.arePlanesParallel(selA, selB)) {
                return MeasurementType.PLANE_TO_PLANE;
            }
            return MeasurementType.DIHEDRAL_ANGLE;
        }

        // Daire/Silindir - Daire/Silindir
        if (isCircular(selA) && isCircular(selB)) {
            return MeasurementType.CENTER_TO_CENTER;
        }

        // Genel durum - Minimum mesafe
        return MeasurementType.MINIMUM_DISTANCE;
    }
}
```

---

## 2. OLCUM TIPLERI VE GORUNTULEME

### 2.1 Koordinat Gosterimi (CATIA tarzinda)

```typescript
/**
 * CATIA'nin koordinat okuma ozelligi
 * Tek nokta secildiginde X, Y, Z degerlerini gosterir
 */
export class CoordinateDimension extends Dimension {

    private point: THREE.Vector3;
    private referenceFrame: CoordinateFrame;

    create(): DimensionResult {
        // Koordinat donusumu (eksen bazli)
        const localCoords = this.transformToLocalFrame(this.point);

        // 3 satir halinde gosterim
        const label = this.createMultiLineLabel([
            `X: ${localCoords.x.toFixed(this.precision)}`,
            `Y: ${localCoords.y.toFixed(this.precision)}`,
            `Z: ${localCoords.z.toFixed(this.precision)}`
        ]);

        return { success: true, dimension: this };
    }

    /**
     * Referans frame'e gore donusum
     * CATIA'daki gibi farkli koordinat sistemleri destegi
     */
    private transformToLocalFrame(worldPoint: THREE.Vector3): THREE.Vector3 {
        if (!this.referenceFrame) {
            return worldPoint.clone();
        }

        const local = worldPoint.clone();
        local.sub(this.referenceFrame.origin);
        local.applyQuaternion(this.referenceFrame.quaternion.clone().invert());

        return local;
    }
}
```

### 2.2 Alan Olcumu

```typescript
/**
 * Yuzey alani olcumu
 * CATIA'nin "Measure Area" fonksiyonu
 */
export class AreaDimension extends Dimension {

    private face: GeometryReference;
    private mesh: THREE.Mesh;

    protected calculateValue(): number {
        const geometry = this.mesh.geometry;
        const positions = geometry.getAttribute('position');
        const indices = geometry.getIndex();

        let totalArea = 0;
        const v0 = new THREE.Vector3();
        const v1 = new THREE.Vector3();
        const v2 = new THREE.Vector3();
        const ab = new THREE.Vector3();
        const ac = new THREE.Vector3();

        // Her ucgen icin alan hesapla
        for (let i = 0; i < indices.count; i += 3) {
            v0.fromBufferAttribute(positions, indices.getX(i));
            v1.fromBufferAttribute(positions, indices.getX(i + 1));
            v2.fromBufferAttribute(positions, indices.getX(i + 2));

            // World space'e donustur
            v0.applyMatrix4(this.mesh.matrixWorld);
            v1.applyMatrix4(this.mesh.matrixWorld);
            v2.applyMatrix4(this.mesh.matrixWorld);

            // Ucgen alani = |AB x AC| / 2
            ab.subVectors(v1, v0);
            ac.subVectors(v2, v0);
            totalArea += ab.cross(ac).length() / 2;
        }

        return totalArea;
    }

    protected formatValue(value: number): string {
        const unit = this._options.unit || 'mm';
        const unitSquared = `${unit}\u00B2`; // mm², cm², vb.

        return `${value.toFixed(this._options.precision)} ${unitSquared}`;
    }
}
```

### 2.3 Yay Uzunlugu ve Ozellikleri

```typescript
/**
 * Yay olcumu - CATIA/SolidWorks tarzinda
 * Yay uzunlugu, merkez, yaricap, aci
 */
export class ArcDimension extends Dimension {

    private arcRef: GeometryReference;

    create(): DimensionResult {
        // Yay parametrelerini hesapla
        const arcLength = this.calculateArcLength();
        const radius = this.arcRef.radius!;
        const center = this.arcRef.center!;
        const angle = this.calculateSweepAngle();

        // Merkez isareti
        this.createCenterMark(center);

        // Yaricap cizgisi
        this.createRadiusLine(center, radius);

        // Yay uzunlugu etiketi (yay uzerinde)
        this.createArcLengthLabel(arcLength);

        // Aci yayı ve etiketi
        this.createAngleArc(angle);

        return { success: true, dimension: this };
    }

    private calculateArcLength(): number {
        const radius = this.arcRef.radius!;
        const startAngle = this.arcRef.startAngle!;
        const endAngle = this.arcRef.endAngle!;

        // L = R * theta (theta radyan cinsinden)
        const theta = Math.abs(endAngle - startAngle);
        return radius * theta;
    }

    private calculateSweepAngle(): number {
        const startAngle = this.arcRef.startAngle!;
        const endAngle = this.arcRef.endAngle!;

        // Derece cinsinden
        return Math.abs(endAngle - startAngle) * (180 / Math.PI);
    }
}
```

### 2.4 Minimum Mesafe (Entity to Entity)

```typescript
/**
 * Iki entity arasindaki minimum mesafe
 * GPU-accelerated hesaplama
 */
export class MinimumDistanceDimension extends Dimension {

    private entityA: THREE.Object3D;
    private entityB: THREE.Object3D;
    private gpuMotor: GPUOlcumMotoru;

    async create(): Promise<DimensionResult> {
        // GPU ile minimum mesafe hesapla
        const result = await this.gpuMotor.calculateMinimumDistance(
            this.getPositions(this.entityA),
            this.getPositions(this.entityB)
        );

        if (!result.success) {
            // CPU fallback
            return this.cpuFallback();
        }

        // En yakin noktalar
        const pointA = result.closestPointA;
        const pointB = result.closestPointB;

        // Dimension cizgisi
        this.createDistanceLine(pointA, pointB);

        // Etiket
        this.createLabel(`Min: ${result.distance.toFixed(this.precision)}`);

        // En yakin noktalari isaretçilerle goster
        this.createPointMarker(pointA, 'A');
        this.createPointMarker(pointB, 'B');

        return { success: true, dimension: this };
    }

    /**
     * GPU compute shader ile minimum mesafe
     */
    private async gpuMinimumDistance(
        positionsA: Float32Array,
        positionsB: Float32Array
    ): Promise<MinDistanceResult> {
        // WebGPU compute shader
        const shader = `
            @compute @workgroup_size(64)
            fn minDistanceCompute(
                @builtin(global_invocation_id) id: vec3<u32>
            ) {
                let idx = id.x;
                if (idx >= arrayLength(&positionsA) / 3u) { return; }

                let pA = vec3<f32>(
                    positionsA[idx * 3u],
                    positionsA[idx * 3u + 1u],
                    positionsA[idx * 3u + 2u]
                );

                var localMin: f32 = 999999.0;
                var closestIdx: u32 = 0u;

                let countB = arrayLength(&positionsB) / 3u;
                for (var j: u32 = 0u; j < countB; j = j + 1u) {
                    let pB = vec3<f32>(
                        positionsB[j * 3u],
                        positionsB[j * 3u + 1u],
                        positionsB[j * 3u + 2u]
                    );

                    let dist = distance(pA, pB);
                    if (dist < localMin) {
                        localMin = dist;
                        closestIdx = j;
                    }
                }

                // Atomic minimum
                atomicMin(&result.minDistance, bitcast<u32>(localMin));
            }
        `;

        return await this.gpuMotor.execute(shader, positionsA, positionsB);
    }
}
```

---

## 3. GEOMETRI TESPIT SISTEMI

### 3.1 Otomatik Feature Recognition

```typescript
/**
 * CATIA'nin geometri tanimlama ozelligi
 * Mesh'ten otomatik olarak daire, yay, silindir, koni tespit eder
 */
export class GeometryRecognizer {

    private readonly CIRCLE_TOLERANCE = 0.001;
    private readonly CYLINDER_TOLERANCE = 0.002;

    /**
     * Secilen kenarın daire olup olmadigini tespit et
     */
    detectCircle(edge: EdgeGeometry): CircleDetectionResult | null {
        const points = this.extractEdgePoints(edge);

        if (points.length < 3) {
            return null;
        }

        // Least squares circle fit
        const circle = this.fitCircleToPoints(points);

        // Fit kalitesi kontrolu
        const rSquared = this.calculateRSquared(points, circle);

        if (rSquared > 0.999) { // %99.9 uyum
            return {
                detected: true,
                type: 'CIRCLE',
                center: circle.center,
                radius: circle.radius,
                normal: circle.normal,
                confidence: rSquared
            };
        }

        return null;
    }

    /**
     * Yuzey tipi tespiti (duz, silindirik, konik, kuresel)
     */
    detectSurfaceType(face: FaceGeometry): SurfaceTypeResult {
        const points = this.extractFacePoints(face);
        const normals = this.extractFaceNormals(face);

        // Duz yuzey kontrolu
        if (this.isPlanar(normals)) {
            return {
                type: 'PLANAR',
                normal: this.averageNormal(normals),
                confidence: 1.0
            };
        }

        // Silindirik yuzey kontrolu
        const cylinderFit = this.fitCylinder(points, normals);
        if (cylinderFit.confidence > 0.99) {
            return {
                type: 'CYLINDRICAL',
                axis: cylinderFit.axis,
                center: cylinderFit.center,
                radius: cylinderFit.radius,
                confidence: cylinderFit.confidence
            };
        }

        // Konik yuzey kontrolu
        const coneFit = this.fitCone(points, normals);
        if (coneFit.confidence > 0.99) {
            return {
                type: 'CONICAL',
                apex: coneFit.apex,
                axis: coneFit.axis,
                halfAngle: coneFit.halfAngle,
                confidence: coneFit.confidence
            };
        }

        // Kuresel yuzey kontrolu
        const sphereFit = this.fitSphere(points);
        if (sphereFit.confidence > 0.99) {
            return {
                type: 'SPHERICAL',
                center: sphereFit.center,
                radius: sphereFit.radius,
                confidence: sphereFit.confidence
            };
        }

        // Serbest form yuzey
        return {
            type: 'FREEFORM',
            curvature: this.analyzeCurvature(points, normals),
            confidence: 1.0
        };
    }

    /**
     * Filet/Chamfer tespiti
     */
    detectFilletOrChamfer(edge: EdgeGeometry): FilletChamferResult | null {
        const adjacent = this.getAdjacentFaces(edge);

        if (adjacent.length !== 2) {
            return null;
        }

        const [face1, face2] = adjacent;

        // Her iki yuzey de duz ise, kenar kontrolu yap
        if (this.isPlanarFace(face1) && this.isPlanarFace(face2)) {
            // Kenar analizi
            const edgeType = this.detectCircle(edge);

            if (edgeType && edgeType.type === 'CIRCLE') {
                return {
                    type: 'FILLET',
                    radius: edgeType.radius,
                    angle: this.angleBetweenFaces(face1, face2)
                };
            }

            // Chamfer kontrolu
            if (this.isStraightEdge(edge)) {
                return {
                    type: 'CHAMFER',
                    distance1: this.chamferDistance(edge, face1),
                    distance2: this.chamferDistance(edge, face2),
                    angle: this.angleBetweenFaces(face1, face2)
                };
            }
        }

        return null;
    }

    /**
     * Delik tespiti
     */
    detectHole(face: FaceGeometry): HoleDetectionResult | null {
        const surfaceType = this.detectSurfaceType(face);

        if (surfaceType.type !== 'CYLINDRICAL') {
            return null;
        }

        // Ic silindir mi dis silindir mi?
        const isInternal = this.isInternalCylinder(face);

        if (isInternal) {
            return {
                type: 'HOLE',
                diameter: surfaceType.radius! * 2,
                depth: this.calculateHoleDepth(face),
                axis: surfaceType.axis!,
                center: surfaceType.center!
            };
        }

        return null;
    }
}
```

---

## 4. DURUMA GORE OLCUM GOSTERIMI

### 4.1 Kumpas Modu (Tekil Olcum) - Tum Senaryolar

```typescript
/**
 * Kumpas modu - Tek secim durumunda gosterilecek bilgiler
 * CATIA'nin "Measure Inertia/Properties" benzeri
 */
export interface KumpasMeasurement {
    // Temel bilgiler
    type: GeometryType;

    // Nokta icin
    coordinates?: {
        x: number;
        y: number;
        z: number;
        reference?: string; // Koordinat sistemi adi
    };

    // Kenar icin
    edge?: {
        length: number;
        direction?: THREE.Vector3;

        // Daire/yay ise
        isCircular?: boolean;
        radius?: number;
        center?: THREE.Vector3;
        arcLength?: number;
        arcAngle?: number;

        // Egrilik bilgisi
        curvature?: {
            min: number;
            max: number;
            average: number;
        };
    };

    // Yuzey icin
    face?: {
        area: number;
        centroid: THREE.Vector3;
        normal: THREE.Vector3;

        // Yuzey tipi
        surfaceType: 'PLANAR' | 'CYLINDRICAL' | 'CONICAL' | 'SPHERICAL' | 'TOROIDAL' | 'FREEFORM';

        // Silindirik ise
        diameter?: number;
        axis?: THREE.Vector3;

        // Konik ise
        halfAngle?: number;

        // Kuresel ise
        sphereRadius?: number;
        sphereCenter?: THREE.Vector3;

        // Egrilik bilgisi
        curvature?: {
            gaussian: number;
            mean: number;
            principal1: number;
            principal2: number;
        };

        // Perimeter
        perimeter?: number;
    };

    // Body icin
    body?: {
        volume: number;
        surfaceArea: number;
        centerOfMass: THREE.Vector3;
        boundingBox: THREE.Box3;

        // Inertia ozellikleri
        momentOfInertia?: {
            Ixx: number;
            Iyy: number;
            Izz: number;
            Ixy: number;
            Ixz: number;
            Iyz: number;
        };
    };
}
```

### 4.2 Cetvel Modu (Cift Secim) - Tum Senaryolar

```typescript
/**
 * Cetvel modu - Iki secim durumunda gosterilecek bilgiler
 */
export interface CetvelMeasurement {
    // Temel mesafe
    distance: number;

    // Mesafe tipi
    type: DistanceType;

    // Nokta - Nokta
    pointToPoint?: {
        point1: THREE.Vector3;
        point2: THREE.Vector3;

        // Delta degerleri
        deltaX: number;
        deltaY: number;
        deltaZ: number;

        // Projeksiyon mesafeleri
        distanceXY: number;  // Z ignore
        distanceXZ: number;  // Y ignore
        distanceYZ: number;  // X ignore
    };

    // Nokta - Cizgi
    pointToLine?: {
        point: THREE.Vector3;
        closestPointOnLine: THREE.Vector3;
        perpendicularDistance: number;

        // Cizgi uzerindeki parametre (0-1)
        parameter: number;
    };

    // Nokta - Yuzey
    pointToPlane?: {
        point: THREE.Vector3;
        closestPointOnPlane: THREE.Vector3;
        perpendicularDistance: number;
        signedDistance: number; // + veya - (normal yonune gore)
    };

    // Cizgi - Cizgi
    lineToLine?: {
        // Paralel mi?
        parallel: boolean;

        // Paralel ise
        parallelDistance?: number;

        // Paralel degilse
        angle?: number;
        intersectionPoint?: THREE.Vector3;

        // Skew lines (ayri duzlemlerde)
        skew?: boolean;
        minimumDistance?: number;
        closestPointOnLine1?: THREE.Vector3;
        closestPointOnLine2?: THREE.Vector3;
    };

    // Yuzey - Yuzey
    planeToPlane?: {
        // Paralel mi?
        parallel: boolean;

        // Paralel ise
        parallelDistance?: number;

        // Paralel degilse (dihedral angle)
        dihedralAngle?: number;
        intersectionLine?: {
            point: THREE.Vector3;
            direction: THREE.Vector3;
        };
    };

    // Merkez - Merkez (daireler, silindirler)
    centerToCenter?: {
        center1: THREE.Vector3;
        center2: THREE.Vector3;
        centerDistance: number;

        // Kenar mesafeleri (gap/interference)
        edgeDistance?: number;  // Negatif = interference
    };

    // Genel minimum mesafe
    minimumDistance?: {
        distance: number;
        point1: THREE.Vector3;
        point2: THREE.Vector3;
    };
}
```

---

## 5. TOLERANS VE GD&T SEMBOLLER

### 5.1 Tolerans Gosterimi

```typescript
/**
 * ISO/ASME tolerans gosterimi
 */
export interface ToleranceAnnotation {
    // Temel tolerans
    nominalValue: number;

    // Tolerans tipi
    type: 'BILATERAL' | 'UNILATERAL_PLUS' | 'UNILATERAL_MINUS' | 'LIMITS';

    // Bilateral (+-)
    bilateral?: {
        upper: number;
        lower: number;
        symmetric: boolean; // +- ayni mi?
    };

    // Limits (min-max)
    limits?: {
        min: number;
        max: number;
    };

    // Fit toleransi
    fit?: {
        hole: string;    // H7, H8, vb.
        shaft: string;   // g6, h6, vb.
        type: 'CLEARANCE' | 'TRANSITION' | 'INTERFERENCE';
    };
}
```

### 5.2 GD&T Semboller (Gelecek icin)

```typescript
/**
 * GD&T sembolleri - Gelecek faz
 */
export enum GDTSymbol {
    // Form
    STRAIGHTNESS = '\u23E4',
    FLATNESS = '\u23E5',
    CIRCULARITY = '\u25CB',
    CYLINDRICITY = '\u232D',

    // Profile
    PROFILE_LINE = '\u2312',
    PROFILE_SURFACE = '\u2313',

    // Orientation
    ANGULARITY = '\u2220',
    PERPENDICULARITY = '\u27C2',
    PARALLELISM = '\u2225',

    // Location
    POSITION = '\u2295',
    CONCENTRICITY = '\u25CE',
    SYMMETRY = '\u232F',

    // Runout
    CIRCULAR_RUNOUT = '\u2197',
    TOTAL_RUNOUT = '\u21C5',

    // Modifiers
    MMC = '\u24C2',      // Maximum Material Condition
    LMC = '\u24C1',      // Least Material Condition
    RFS = '\u24C7',      // Regardless of Feature Size
    PROJECTED = '\u24C5', // Projected Tolerance Zone
    FREE_STATE = '\u24BB', // Free State
}
```

---

## 6. UI/UX TASARIMI

### 6.1 Olcum Toolbar

```
+-------------------------------------------------------+
| OLCUM ARACLARI                                        |
+-------------------------------------------------------+
| [Akilli] [Kumpas] [Cetvel] [Aci] [Yaricap] [Alan]    |
|                                                       |
| Secenekler:                                           |
| [X] Snap to Vertex                                    |
| [X] Snap to Midpoint                                  |
| [X] Snap to Center                                    |
| [ ] Show Projections                                  |
| [ ] Chain Mode                                        |
|                                                       |
| Referans: [World] [Local] [Custom...]                 |
| Hassasiyet: [0.01] mm                                 |
+-------------------------------------------------------+
```

### 6.2 Olcum Sonuc Paneli

```
+-------------------------------------------------------+
| OLCUM SONUCU                                          |
+-------------------------------------------------------+
| Tip: Silindir Capi                                    |
|                                                       |
|   CAP: 25.400 mm                                      |
|   R:   12.700 mm                                      |
|                                                       |
| Ek Bilgiler:                                          |
|   Merkez: (50.00, 25.00, 0.00)                        |
|   Eksen:  (0.00, 0.00, 1.00)                          |
|   Uzunluk: 100.00 mm                                  |
|                                                       |
| [Kaydet] [Kopyala] [Dimension Ekle]                   |
+-------------------------------------------------------+
```

---

## 7. PERFORMANS OPTIMIZASYONLARI

### 7.1 GPU Accelerated Minimum Distance

```wgsl
// WebGPU compute shader - Minimum mesafe
@group(0) @binding(0) var<storage, read> positionsA: array<vec3<f32>>;
@group(0) @binding(1) var<storage, read> positionsB: array<vec3<f32>>;
@group(0) @binding(2) var<storage, read_write> result: MinDistResult;

struct MinDistResult {
    distance: atomic<u32>,
    indexA: atomic<u32>,
    indexB: atomic<u32>
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) id: vec3<u32>) {
    let countA = arrayLength(&positionsA);
    let countB = arrayLength(&positionsB);

    if (id.x >= countA) { return; }

    let pA = positionsA[id.x];
    var localMinDist: f32 = 1e10;
    var localMinIdx: u32 = 0u;

    for (var j: u32 = 0u; j < countB; j = j + 1u) {
        let d = distance(pA, positionsB[j]);
        if (d < localMinDist) {
            localMinDist = d;
            localMinIdx = j;
        }
    }

    // Atomic compare and swap
    let distAsUint = bitcast<u32>(localMinDist);
    var old = atomicLoad(&result.distance);

    loop {
        if (distAsUint >= old) { break; }
        let exchanged = atomicCompareExchangeWeak(&result.distance, old, distAsUint);
        if (exchanged.exchanged) {
            atomicStore(&result.indexA, id.x);
            atomicStore(&result.indexB, localMinIdx);
            break;
        }
        old = exchanged.old_value;
    }
}
```

### 7.2 Cache Sistemi

```typescript
/**
 * Geometri analiz cache
 * Ayni geometri icin tekrar hesaplama yapma
 */
export class GeometryAnalysisCache {
    private cache: Map<string, CachedAnalysis> = new Map();
    private readonly TTL_MS = 5000; // 5 saniye

    getCached(geometryId: string): CachedAnalysis | null {
        const cached = this.cache.get(geometryId);

        if (!cached) return null;

        // TTL kontrolu
        if (Date.now() - cached.timestamp > this.TTL_MS) {
            this.cache.delete(geometryId);
            return null;
        }

        return cached;
    }

    setCached(geometryId: string, analysis: CachedAnalysis): void {
        // Cache boyut kontrolu
        if (this.cache.size > 1000) {
            this.evictOldest();
        }

        this.cache.set(geometryId, {
            ...analysis,
            timestamp: Date.now()
        });
    }
}
```

---

## 8. IMPLEMENTASYON ONCELIKLERI

### Phase 1 - Temel (1-2 hafta)
1. [x] SmartMeasureMode - Otomatik tip tespiti
2. [x] CoordinateDimension - Koordinat gosterimi
3. [x] AreaDimension - Yuzey alani
4. [x] MinimumDistanceDimension - Min mesafe

### Phase 2 - Geometri Tespiti (2-3 hafta)
1. [ ] GeometryRecognizer - Daire/silindir/koni tespiti
2. [ ] ArcDimension - Yay ozellikleri
3. [ ] FilletChamferDetection - Filet/chamfer tespiti
4. [ ] HoleDetection - Delik tespiti

### Phase 3 - Ileri Ozellikler (3-4 hafta)
1. [ ] ChainDimension - Zincir olculer
2. [ ] BaselineDimension - Baseline olculer
3. [ ] OrdinateDimension - Koordinat olculer
4. [ ] CurvatureAnalysis - Egrilik analizi

### Phase 4 - Tolerans ve GD&T (Gelecek)
1. [ ] ToleranceAnnotation - Tolerans gosterimi
2. [ ] GDTSymbols - GD&T sembolleri
3. [ ] FitCalculations - Gec/Siki gececek

---

*Son Guncelleme: 2025-01-18*
*Hedef: CATIA/SolidWorks seviyesinde profesyonel olcum sistemi*