# Kumpas ve Cetvel Sistemi - Geliştirme Haritası

## 🎯 Odak Alanı: Yerel CAD Programı için Profesyonel Ölçüm Araçları

---

## 📅 Phase 1: Mevcut Sistem Mükemmelleştirme (Mevcut)

### ✅ Kumpas (Tekil Ölçüm) - İyileştirmeler

#### 1. Nokta Seçimi Geliştirmeleri
```typescript
// Snap-to-vertex sistemi
const snapToVertex = (mousePosition: Vector2, vertices: Vector3[]): Vector3 | null => {
    const threshold = 5; // piksel
    let closestVertex: Vector3 | null = null;
    let minDistance = Infinity;

    vertices.forEach(vertex => {
        const screenPos = worldToScreen(vertex);
        const distance = mousePosition.distanceTo(screenPos);

        if (distance < threshold && distance < minDistance) {
            minDistance = distance;
            closestVertex = vertex;
        }
    });

    return closestVertex;
};

// Midpoint detection
const detectMidpoint = (p1: Vector3, p2: Vector3, mousePos: Vector2): Vector3 | null => {
    const midpoint = new Vector3().addVectors(p1, p2).multiplyScalar(0.5);
    const screenMid = worldToScreen(midpoint);

    if (mousePos.distanceTo(screenMid) < 10) {
        return midpoint;
    }
    return null;
};

// Center detection (for circles and arcs)
const detectCenter = (geometry: BufferGeometry): Vector3 | null => {
    // Circle geometry detection
    if (isCircleGeometry(geometry)) {
        return geometry.userData.center;
    }

    // Arc center calculation
    if (isArcGeometry(geometry)) {
        return calculateArcCenter(geometry);
    }

    return null;
};
```

#### 2. Yüzey Analizi İyileştirmeleri
```typescript
// Curvature analysis
const surfaceCurvature = (mesh: Mesh, point: Vector3): { gaussian: number, mean: number } => {
    const normal = getNormalAtPoint(mesh, point);
    const curvatureTensor = calculateCurvatureTensor(mesh, point);

    return {
        gaussian: curvatureTensor.k1 * curvatureTensor.k2,
        mean: (curvatureTensor.k1 + curvatureTensor.k2) / 2
    };
};

// Surface defect detection
const detectSurfaceDefects = (mesh: Mesh): Defect[] => {
    const defects: Defect[] = [];
    const vertices = mesh.geometry.attributes.position;

    for (let i = 0; i < vertices.count; i++) {
        const vertex = new Vector3().fromBufferAttribute(vertices, i);
        const localCurvature = surfaceCurvature(mesh, vertex);

        if (localCurvature.gaussian > curvatureThreshold) {
            defects.push({
                position: vertex,
                type: 'bump',
                severity: localCurvature.gaussian
            });
        }
    }

    return defects;
};

// Thickness measurement at point
const measureThickness = (mesh: Mesh, point: Vector3, direction: Vector3): number => {
    const raycaster = new Raycaster(point, direction);
    const intersections = raycaster.intersectObject(mesh);

    if (intersections.length >= 2) {
        return intersections[0].distance - intersections[1].distance;
    }

    return 0;
};
```

#### 3. Çizgi Analizi Geliştirmeleri
```typescript
// Arc length calculation
const calculateArcLength = (geometry: BufferGeometry): number => {
    const points = extractPoints(geometry);
    let totalLength = 0;

    for (let i = 1; i < points.length; i++) {
        totalLength += points[i].distanceTo(points[i - 1]);
    }

    return totalLength;
};

// Radius of curvature
const radiusOfCurvature = (p1: Vector3, p2: Vector3, p3: Vector3): number => {
    const a = p1.distanceTo(p2);
    const b = p2.distanceTo(p3);
    const c = p3.distanceTo(p1);

    const area = triangleArea(p1, p2, p3);
    const radius = (a * b * c) / (4 * area);

    return radius;
};

// Tangent at point
const tangentAtPoint = (geometry: BufferGeometry, pointIndex: number): Vector3 => {
    const points = extractPoints(geometry);

    if (pointIndex > 0 && pointIndex < points.length - 1) {
        return new Vector3().subVectors(
            points[pointIndex + 1],
            points[pointIndex - 1]
        ).normalize();
    }

    return new Vector3();
};
```

### ✅ Cetvel (Mesafe Ölçüm) - İyileştirmeler

#### 1. Akıllı Seçim Sistemi
```typescript
// Auto-detect measurement type
const detectMeasurementType = (selection1: any, selection2: any): MeasurementType => {
    if (selection1.type === 'Point' && selection2.type === 'Point') {
        return 'PointToPoint';
    }

    if (selection1.type === 'Point' && selection2.type === 'Line') {
        return 'PointToLine';
    }

    if (selection1.type === 'Plane' && selection2.type === 'Plane') {
        return 'PlaneToPlane';
    }

    return 'Unknown';
};

// Chain measurement mode
const chainMeasurement = (points: Vector3[]): ChainMeasurementResult => {
    const segments: Segment[] = [];
    let totalLength = 0;

    for (let i = 1; i < points.length; i++) {
        const segment = {
            start: points[i - 1],
            end: points[i],
            length: points[i].distanceTo(points[i - 1])
        };
        segments.push(segment);
        totalLength += segment.length;
    }

    return {
        segments,
        totalLength,
        closed: points[0].distanceTo(points[points.length - 1]) < tolerance
    };
};

// Minimum distance between entities
const minimumDistance = (entity1: Entity, entity2: Entity): number => {
    let minDist = Infinity;

    if (entity1.type === 'Mesh' && entity2.type === 'Mesh') {
        // Use BVH for efficiency
        const bvh1 = createBVH(entity1.geometry);
        const bvh2 = createBVH(entity2.geometry);

        minDist = bvhDistance(bvh1, bvh2);
    }

    return minDist;
};
```

#### 2. Gelişmiş Mesafe Ölçümleri
```typescript
// Cumulative distance along path
const cumulativeDistance = (path: Vector3[]): number[] => {
    const distances = [0];
    let total = 0;

    for (let i = 1; i < path.length; i++) {
        total += path[i].distanceTo(path[i - 1]);
        distances.push(total);
    }

    return distances;
};

// Perpendicular distance
const perpendicularDistance = (point: Vector3, line: { start: Vector3, end: Vector3 }): number => {
    const lineVec = new Vector3().subVectors(line.end, line.start);
    const pointVec = new Vector3().subVectors(point, line.start);

    const projection = pointVec.clone().projectOnVector(lineVec);
    const perpendicular = pointVec.clone().sub(projection);

    return perpendicular.length();
};

// Distance along axis
const distanceAlongAxis = (point1: Vector3, point2: Vector3, axis: Vector3): number => {
    const projection = new Vector3().subVectors(point2, point1).projectOnVector(axis);
    return projection.length();
};
```

---

## 📅 Phase 2: Yeni Ölçüm Araçları (Yakında)

### 1. Açı Ölçer (Protractor)

#### Basic Angle Measurements
```typescript
// Three point angle
const threePointAngle = (vertex: Vector3, point1: Vector3, point2: Vector3): number => {
    const v1 = new Vector3().subVectors(point1, vertex).normalize();
    const v2 = new Vector3().subVectors(point2, vertex).normalize();

    const angle = Math.acos(v1.dot(v2));
    return (angle * 180) / Math.PI; // Convert to degrees
};

// Line to line angle
const lineToLineAngle = (line1: { direction: Vector3 }, line2: { direction: Vector3 }): number => {
    const angle = Math.acos(Math.abs(line1.direction.dot(line2.direction)));
    return (angle * 180) / Math.PI;
};

// Plane to plane angle
const planeToPlaneAngle = (plane1: Plane, plane2: Plane): number => {
    const angle = Math.acos(Math.abs(plane1.normal.dot(plane2.normal)));
    return (angle * 180) / Math.PI;
};

// Interior angle of polygon
const interiorAngle = (vertices: Vector3[], index: number): number => {
    const prev = vertices[(index - 1 + vertices.length) % vertices.length];
    const curr = vertices[index];
    const next = vertices[(index + 1) % vertices.length];

    return threePointAngle(curr, prev, next);
};
```

#### Advanced Angle Features
```typescript
// Bisector line
const angleBisector = (v1: Vector3, v2: Vector3): Vector3 => {
    const normalized1 = v1.clone().normalize();
    const normalized2 = v2.clone().normalize();
    return normalized1.add(normalized2).normalize();
};

// Complementary angle
const complementaryAngle = (angle: number): number => {
    return 180 - angle;
};

// Supplementary angle
const supplementaryAngle = (angle: number): number => {
    return 360 - angle;
};
```

### 2. Mezro (Multi-Point Measurement)

#### Polygon Analysis
```typescript
// Polygon area calculation
const polygonArea = (vertices: Vector3[]): number => {
    let area = 0;
    const n = vertices.length;

    for (let i = 0; i < n; i++) {
        const j = (i + 1) % n;
        area += vertices[i].x * vertices[j].y;
        area -= vertices[j].x * vertices[i].y;
    }

    return Math.abs(area) / 2;
};

// Polygon perimeter
const polygonPerimeter = (vertices: Vector3[]): number => {
    let perimeter = 0;

    for (let i = 0; i < vertices.length; i++) {
        const next = (i + 1) % vertices.length;
        perimeter += vertices[i].distanceTo(vertices[next]);
    }

    return perimeter;
};

// Check if polygon is convex
const isConvex = (vertices: Vector3[]): boolean => {
    let sign = null;
    const n = vertices.length;

    for (let i = 0; i < n; i++) {
        const p1 = vertices[i];
        const p2 = vertices[(i + 1) % n];
        const p3 = vertices[(i + 2) % n];

        const crossProduct = (p2.x - p1.x) * (p3.y - p2.y) -
                           (p2.y - p1.y) * (p3.x - p2.x);

        if (crossProduct !== 0) {
            const currentSign = crossProduct > 0;
            if (sign === null) sign = currentSign;
            else if (sign !== currentSign) return false;
        }
    }

    return true;
};
```

### 3. Yay Ölçer (Arc Measurement)

#### Arc Properties
```typescript
// Arc radius from three points
const arcRadiusFromPoints = (p1: Vector3, p2: Vector3, p3: Vector3): number => {
    const a = p1.distanceTo(p2);
    const b = p2.distanceTo(p3);
    const c = p3.distanceTo(p1);

    const area = triangleArea(p1, p2, p3);
    return (a * b * c) / (4 * area);
};

// Arc center from three points
const arcCenterFromPoints = (p1: Vector3, p2: Vector3, p3: Vector3): Vector3 => {
    // Using perpendicular bisectors
    const mid1 = new Vector3().addVectors(p1, p2).multiplyScalar(0.5);
    const mid2 = new Vector3().addVectors(p2, p3).multiplyScalar(0.5);

    const dir1 = new Vector3().subVectors(p2, p1);
    const dir2 = new Vector3().subVectors(p3, p2);

    const perp1 = new Vector3(-dir1.y, dir1.x, 0);
    const perp2 = new Vector3(-dir2.y, dir2.x, 0);

    // Intersection of perpendicular bisectors
    return lineIntersection(
        { x: mid1.x, y: mid1.y },
        { x: perp1.x, y: perp1.y },
        { x: mid2.x, y: mid2.y },
        { x: perp2.x, y: perp2.y }
    );
};

// Arc angle from three points
const arcAngle = (p1: Vector3, center: Vector3, p2: Vector3): number => {
    const v1 = new Vector3().subVectors(p1, center);
    const v2 = new Vector3().subVectors(p2, center);

    const angle = Math.acos(v1.dot(v2) / (v1.length() * v2.length()));
    return (angle * 180) / Math.PI;
};
```

---

## 📅 Phase 3: İleri Seviye Özellikler (Gelecek)

### 1. Otomatik Ölçüm Algılama

#### Smart Detection
```typescript
// Detect circles in mesh
const detectCircles = (mesh: Mesh): Circle[] => {
    const circles: Circle[] = [];
    const edges = extractEdges(mesh);

    // Group edges into potential circles
    const edgeGroups = groupCircularEdges(edges);

    edgeGroups.forEach(group => {
        if (isCircular(group)) {
            const circle = fitCircleToPoints(group.points);
            circles.push(circle);
        }
    });

    return circles;
};

// Detect holes
const detectHoles = (mesh: Mesh): Hole[] => {
    const holes: Hole[] = [];
    const boundaries = findBoundaryLoops(mesh);

    boundaries.forEach(boundary => {
        if (isClosedLoop(boundary)) {
            const area = polygonArea(boundary.points);
            const center = polygonCenter(boundary.points);

            holes.push({
                boundary,
                area,
                center,
                perimeter: polygonPerimeter(boundary.points)
            });
        }
    });

    return holes;
};

// Detect fillets and chamfers
const detectFillets = (mesh: Mesh): Fillet[] => {
    const fillets: Fillet[] = [];
    const edges = extractEdges(mesh);

    edges.forEach(edge => {
        const curvature = calculateEdgeCurvature(edge);

        if (curvature.radius > 0 && curvature.radius < filletThreshold) {
            fillets.push({
                edge,
                radius: curvature.radius,
                startAngle: curvature.startAngle,
                endAngle: curvature.endAngle
            });
        }
    });

    return fillets;
};
```

### 2. Hızlı Ölçüm Kısayolları

#### Measurement Shortcuts
```typescript
// Double-click for diameter
const onDoubleClick = (event: MouseEvent) => {
    const selection = getSelectionAt(event);

    if (selection.type === 'Circle' || selection.type === 'Cylinder') {
        measureDiameter(selection);
    }
};

// Shift+drag for multiple distances
const onShiftDrag = (startPoint: Vector3, endPoint: Vector3) => {
    const measurements: Measurement[] = [];

    // Find all entities intersecting the drag line
    const intersections = getIntersectionsAlongLine(startPoint, endPoint);

    // Measure distances between consecutive intersections
    for (let i = 1; i < intersections.length; i++) {
        measurements.push({
            type: 'Distance',
            start: intersections[i - 1].point,
            end: intersections[i].point
        });
    }

    return measurements;
};

// Ctrl+select for cumulative measurement
let cumulativePoints: Vector3[] = [];

const onCtrlClick = (point: Vector3) => {
    cumulativePoints.push(point);

    if (cumulativePoints.length > 1) {
        updateCumulativeMeasurement();
    }
};
```

### 3. Özel Ölçüm Şablonları

#### Measurement Templates
```typescript
// Bolt circle measurement
const boltCircleTemplate = (holes: Hole[]): BoltCircleMeasurement => {
    if (holes.length < 3) throw new Error('Need at least 3 holes');

    // Find bolt circle center
    const center = findBoltCircleCenter(holes);

    // Calculate pitch circle diameter
    const radii = holes.map(hole => hole.center.distanceTo(center));
    const pcd = 2 * (radii.reduce((a, b) => a + b) / radii.length);

    // Angular positions
    const angles = holes.map(hole => {
        const vec = new Vector3().subVectors(hole.center, center);
        return Math.atan2(vec.y, vec.x) * 180 / Math.PI;
    });

    return {
        center,
        pitchCircleDiameter: pcd,
        holeCount: holes.length,
        angularPositions: angles
    };
};

// Slot measurement
const slotTemplate = (slotGeometry: BufferGeometry): SlotMeasurement => {
    const points = extractPoints(slotGeometry);

    // Find center points of arcs
    const arc1 = findArcInPoints(points.slice(0, points.length / 2));
    const arc2 = findArcInPoints(points.slice(points.length / 2));

    // Calculate slot dimensions
    const centerDistance = arc1.center.distanceTo(arc2.center);
    const width = 2 * arc1.radius;
    const length = centerDistance + 2 * arc1.radius;

    return {
        width,
        length,
        center: new Vector3().addVectors(arc1.center, arc2.center).multiplyScalar(0.5),
        orientation: new Vector3().subVectors(arc2.center, arc1.center).normalize()
    };
};
```

---

## 🔧 Gerekli Matematiksel Formüller

### 1. Temel Geometri

#### Point Projections
```typescript
// Point to line projection
const projectPointOnLine = (point: Vector3, lineStart: Vector3, lineEnd: Vector3): Vector3 => {
    const lineVec = new Vector3().subVectors(lineEnd, lineStart);
    const pointVec = new Vector3().subVectors(point, lineStart);

    const projection = pointVec.clone().projectOnVector(lineVec);
    return new Vector3().addVectors(lineStart, projection);
};

// Point to plane projection
const projectPointOnPlane = (point: Vector3, plane: Plane): Vector3 => {
    const distance = plane.distanceToPoint(point);
    const normal = plane.normal.clone().multiplyScalar(distance);

    return new Vector3().subVectors(point, normal);
};
```

#### Circle Fitting
```typescript
// Least squares circle fit
const fitCircleToPoints = (points: Vector3[]): Circle => {
    // Calculate centroid
    const centroid = new Vector3();
    points.forEach(p => centroid.add(p));
    centroid.divideScalar(points.length);

    // Translate points to origin
    const translatedPoints = points.map(p => p.clone().sub(centroid));

    // Solve for circle parameters
    let sumX = 0, sumY = 0, sumXX = 0, sumYY = 0, sumXY = 0;
    let sumXXX = 0, sumYYY = 0, sumXXY = 0, sumXYY = 0;

    translatedPoints.forEach(p => {
        sumX += p.x;
        sumY += p.y;
        sumXX += p.x * p.x;
        sumYY += p.y * p.y;
        sumXY += p.x * p.y;
        sumXXX += p.x * p.x * p.x;
        sumYYY += p.y * p.y * p.y;
        sumXXY += p.x * p.x * p.y;
        sumXYY += p.x * p.y * p.y;
    });

    // Solve linear system for circle center and radius
    const A = [
        [sumXX, sumXY, sumX],
        [sumXY, sumYY, sumY],
        [sumX, sumY, points.length]
    ];

    const B = [
        -sumXXX - sumXYY,
        -sumXXY - sumYYY,
        -sumXX - sumYY
    ];

    const solution = solveLinearSystem(A, B);

    const center = new Vector3(
        solution[0] + centroid.x,
        solution[1] + centroid.y,
        0
    );

    const radius = Math.sqrt(
        solution[0] * solution[0] +
        solution[1] * solution[1] -
        solution[2]
    );

    return { center, radius };
};
```

### 2. Kavis ve Eğrilik

#### Curvature Calculation
```typescript
// Discrete curvature at point on mesh
const discreteCurvature = (mesh: Mesh, vertexIndex: number): Curvature => {
    const vertices = mesh.geometry.attributes.position;
    const vertex = new Vector3().fromBufferAttribute(vertices, vertexIndex);

    // Find neighboring vertices
    const neighbors = getVertexNeighbors(mesh, vertexIndex);

    // Calculate normal vectors
    const normals = [];
    for (let i = 0; i < neighbors.length; i++) {
        const next = neighbors[(i + 1) % neighbors.length];
        const prev = neighbors[(i - 1 + neighbors.length) % neighbors.length];

        const normal = triangleNormal(vertex, prev, next);
        normals.push(normal);
    }

    // Average curvature
    const avgNormal = normals.reduce((sum, n) => sum.add(n), new Vector3())
                          .divideScalar(normals.length);

    // Gaussian and mean curvature
    const gaussian = calculateGaussianCurvature(vertex, neighbors);
    const mean = calculateMeanCurvature(vertex, neighbors);

    return {
        gaussian,
        mean,
        normal: avgNormal
    };
};
```

### 3. İstatistiksel Analiz

#### Fit Quality Metrics
```typescript
// R-squared for circle fit
const circleFitRSquared = (points: Vector3[], circle: Circle): number => {
    const sumSquaredTotal = calculateTotalSumOfSquares(points);
    const sumSquaredResidual = calculateResidualSumOfSquares(points, circle);

    return 1 - (sumSquaredResidual / sumSquaredTotal);
};

const calculateTotalSumOfSquares = (points: Vector3[]): number => {
    const centroid = points.reduce((sum, p) => sum.add(p), new Vector3())
                          .divideScalar(points.length);

    return points.reduce((sum, p) => {
        return sum + p.distanceToSquared(centroid);
    }, 0);
};

const calculateResidualSumOfSquares = (points: Vector3[], circle: Circle): number => {
    return points.reduce((sum, p) => {
        const distance = Math.abs(p.distanceTo(circle.center) - circle.radius);
        return sum + distance * distance;
    }, 0);
};
```

---

## 🎨 UI/UX İyileştirmeleri

### 1. Görsel Geri Bildirim

#### Measurement Visualization
```typescript
// Animate measurement creation
const animateMeasurementCreation = (
    startPoint: Vector3,
    endPoint: Vector3,
    duration: number = 300
): void => {
    const startTime = performance.now();

    const animate = (currentTime: number) => {
        const elapsed = currentTime - startTime;
        const progress = Math.min(elapsed / duration, 1);

        // Easing function
        const eased = easeOutCubic(progress);

        const currentPoint = new Vector3().lerpVectors(startPoint, endPoint, eased);
        updateMeasurementDisplay(currentPoint);

        if (progress < 1) {
            requestAnimationFrame(animate);
        }
    };

    requestAnimationFrame(animate);
};

// Highlight detected features
const highlightFeature = (feature: GeometricFeature): void => {
    // Create temporary highlight material
    const highlightMaterial = new MeshBasicMaterial({
        color: 0x00ff00,
        transparent: true,
        opacity: 0.5
    });

    // Apply to feature
    feature.object.material = highlightMaterial;

    // Pulse animation
    const pulse = () => {
        const scale = 1 + Math.sin(Date.now() * 0.005) * 0.1;
        feature.object.scale.setScalar(scale);
        requestAnimationFrame(pulse);
    };

    pulse();

    // Remove after timeout
    setTimeout(() => {
        feature.object.material = feature.originalMaterial;
        feature.object.scale.setScalar(1);
    }, 3000);
};
```

### 2. Ölçüm Kalıcılığı

#### Persistent Measurements
```typescript
// Save measurement to scene
const saveMeasurement = (measurement: Measurement): void => {
    const measurementData = {
        id: generateId(),
        type: measurement.type,
        points: measurement.points.map(p => p.toArray()),
        value: measurement.value,
        units: measurement.units,
        timestamp: Date.now(),
        layer: getCurrentLayer()
    };

    // Store in scene userData
    if (!scene.userData.measurements) {
        scene.userData.measurements = [];
    }
    scene.userData.measurements.push(measurementData);

    // Create visual representation
    const measurementObject = createMeasurementObject(measurement);
    scene.add(measurementObject);
};

// Load measurements from scene
const loadMeasurements = (): void => {
    const measurements = scene.userData.measurements || [];

    measurements.forEach(data => {
        const measurement = deserializeMeasurement(data);
        const object = createMeasurementObject(measurement);
        scene.add(object);
    });
};
```

### 3. Hızlı Erişim Araçları

#### Measurement Palette
```typescript
const measurementPalette = {
    tools: [
        { name: 'Kumpas', icon: '📏', action: activateCaliper },
        { name: 'Cetvel', icon: '📐', action: activateRuler },
        { name: 'Açı', icon: '📐', action: activateProtractor },
        { name: 'Mezre', icon: '📏', action: activateMultiPoint },
        { name: 'Yay', icon: '〰️', action: activateArcMeasurement }
    ],

    recent: [],

    favorites: []
};
```

---

## 📊 Performans Optimizasyonları

### 1. Spatial Indexing
```typescript
// Grid-based spatial index for fast point lookup
class SpatialGrid {
    private cells: Map<string, Vector3[]> = new Map();
    private cellSize: number;

    constructor(cellSize: number = 1) {
        this.cellSize = cellSize;
    }

    addPoint(point: Vector3): void {
        const key = this.getCellKey(point);
        if (!this.cells.has(key)) {
            this.cells.set(key, []);
        }
        this.cells.get(key)!.push(point);
    }

    findNearby(point: Vector3, radius: number): Vector3[] {
        const results: Vector3[] = [];
        const minCell = this.getCellKey(
            new Vector3(point.x - radius, point.y - radius, point.z - radius)
        );
        const maxCell = this.getCellKey(
            new Vector3(point.x + radius, point.y + radius, point.z + radius)
        );

        // Check surrounding cells
        for (let x = parseInt(minCell.split(',')[0]); x <= parseInt(maxCell.split(',')[0]); x++) {
            for (let y = parseInt(minCell.split(',')[1]); y <= parseInt(maxCell.split(',')[1]); y++) {
                for (let z = parseInt(minCell.split(',')[2]); z <= parseInt(maxCell.split(',')[2]); z++) {
                    const key = `${x},${y},${z}`;
                    const cellPoints = this.cells.get(key) || [];

                    cellPoints.forEach(p => {
                        if (p.distanceTo(point) <= radius) {
                            results.push(p);
                        }
                    });
                }
            }
        }

        return results;
    }

    private getCellKey(point: Vector3): string {
        const x = Math.floor(point.x / this.cellSize);
        const y = Math.floor(point.y / this.cellSize);
        const z = Math.floor(point.z / this.cellSize);
        return `${x},${y},${z}`;
    }
}
```

### 2. Lazy Calculation
```typescript
// Calculate measurements only when needed
class LazyMeasurement {
    private points: Vector3[];
    private _value: number | null = null;
    private _dirty: boolean = true;

    constructor(points: Vector3[]) {
        this.points = points;
    }

    get value(): number {
        if (this._dirty || this._value === null) {
            this._value = this.calculateValue();
            this._dirty = false;
        }
        return this._value;
    }

    updatePoints(newPoints: Vector3[]): void {
        this.points = newPoints;
        this._dirty = true;
    }

    private calculateValue(): number {
        // Perform expensive calculation
        return this.points[0].distanceTo(this.points[1]);
    }
}
```

---

## 🎯 Geliştirme Öncelikleri

### Immediate (Next Sprint)
1. ✅ Snap-to-vertex implementation
2. ✅ Midpoint detection
3. ✅ Perpendicular distance measurement
4. ✅ Measurement persistence
5. ✅ UI animations and feedback

### Short Term (Next Month)
1. 🔄 Angle measurement tool
2. 🔄 Multi-point measurement (Mezre)
3. 🔄 Arc measurement
4. 🔄 Auto-detection of features
5. 🔄 Measurement templates

### Medium Term (Next Quarter)
1. ⏳ Advanced surface analysis
2. ⏳ Curvature measurement
3. ⏳ Tolerance checking
4. ⏳ Measurement chains
5. ⏳ Batch measurement

### Long Term (Next 6 Months)
1. ⏳ Measurement history tracking
2. ⏳ Custom measurement scripts
3. ⏳ Measurement report generation
4. ⏳ Integration with external tools
5. ⏳ Measurement standards compliance

---

*Son Güncelleme: 2025-11-06*
*Odak: Kumpas ve Cetvel Sistemi*