Update

Author: davras5

js/elevation.js

@@ -129,8 +129,10 @@ export async function preloadTiles(pointsLV95, onProgress) {
 }
 
 // =============================================
-// Grid creation
+// Grid creation (orientation-aligned)
 // =============================================
+
+/** Ray-casting point-in-polygon test */
 function pointInPolygon(x, y, polygon) {
   let inside = false;
   for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
@@ -143,33 +145,129 @@ function pointInPolygon(x, y, polygon) {
   return inside;
 }
 
+/** Cross product of vectors OA and OB (for convex hull) */
+function cross(o, a, b) {
+  return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+}
+
+/** Monotone chain convex hull — returns points in CCW order, no duplicates */
+function convexHull(points) {
+  const pts = points.slice().sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const n = pts.length;
+  if (n <= 2) return pts.slice();
+
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) lower.pop();
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = n - 1; i >= 0; i--) {
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], pts[i]) <= 0) upper.pop();
+    upper.push(pts[i]);
+  }
+  lower.pop();
+  upper.pop();
+  return lower.concat(upper);
+}
+
 /**
- * Create a grid of sample points inside a polygon (LV95 coordinates).
- * Uses axis-aligned grid at GRID_SPACING (1m).
+ * Minimum area bounding rectangle via rotating calipers on the convex hull.
+ * Returns the rotation angle (radians) of the longest edge.
+ */
+function getBuildingAngle(coordsLV95) {
+  const hull = convexHull(coordsLV95);
+  if (hull.length < 3) return 0;
+
+  let bestArea = Infinity;
+  let bestAngle = 0;
+  let bestLongestEdgeAngle = 0;
+
+  for (let i = 0; i < hull.length; i++) {
+    const j = (i + 1) % hull.length;
+    const edgeAngle = Math.atan2(hull[j][1] - hull[i][1], hull[j][0] - hull[i][0]);
+    const cos = Math.cos(-edgeAngle), sin = Math.sin(-edgeAngle);
+
+    // Rotate all hull points to align this edge with x-axis
+    let rxMin = Infinity, rxMax = -Infinity, ryMin = Infinity, ryMax = -Infinity;
+    for (const p of hull) {
+      const rx = p[0] * cos - p[1] * sin;
+      const ry = p[0] * sin + p[1] * cos;
+      if (rx < rxMin) rxMin = rx;
+      if (rx > rxMax) rxMax = rx;
+      if (ry < ryMin) ryMin = ry;
+      if (ry > ryMax) ryMax = ry;
+    }
+
+    const area = (rxMax - rxMin) * (ryMax - ryMin);
+    if (area < bestArea) {
+      bestArea = area;
+      bestAngle = edgeAngle;
+      // Determine longest edge of this bounding rectangle
+      const w = rxMax - rxMin, h = ryMax - ryMin;
+      bestLongestEdgeAngle = w >= h ? edgeAngle : edgeAngle + Math.PI / 2;
+    }
+  }
+
+  return bestLongestEdgeAngle;
+}
+
+/**
+ * Create grid points aligned to the building's orientation.
+ *
+ * 1. Compute orientation from minimum area bounding rectangle
+ * 2. Rotate polygon to align with axes
+ * 3. Generate regular grid in rotated space
+ * 4. Filter points inside the polygon
+ * 5. Rotate points back to original orientation
  */
 export function createGridPoints(coordsLV95, spacing = GRID_SPACING) {
+  // Compute centroid
+  let cx = 0, cy = 0;
+  for (const pt of coordsLV95) { cx += pt[0]; cy += pt[1]; }
+  cx /= coordsLV95.length;
+  cy /= coordsLV95.length;
+
+  // Get building orientation angle
+  const angle = getBuildingAngle(coordsLV95);
+  const cosA = Math.cos(-angle), sinA = Math.sin(-angle);
+
+  // Rotate polygon to align with axes (around centroid)
+  const rotated = coordsLV95.map((p) => {
+    const dx = p[0] - cx, dy = p[1] - cy;
+    return [cx + dx * cosA - dy * sinA, cy + dx * sinA + dy * cosA];
+  });
+
+  // Bounding box of rotated polygon, snapped to grid
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const pt of coordsLV95) {
+  for (const pt of rotated) {
     if (pt[0] < minX) minX = pt[0];
     if (pt[0] > maxX) maxX = pt[0];
     if (pt[1] < minY) minY = pt[1];
     if (pt[1] > maxY) maxY = pt[1];
   }
+  minX = Math.floor(minX / spacing) * spacing;
+  minY = Math.floor(minY / spacing) * spacing;
+  maxX = Math.ceil(maxX / spacing) * spacing;
+  maxY = Math.ceil(maxY / spacing) * spacing;
 
+  // Generate grid in rotated space, filter by polygon containment
+  const cosB = Math.cos(angle), sinB = Math.sin(angle);
   const points = [];
+
   for (let gx = minX + spacing / 2; gx < maxX; gx += spacing) {
     for (let gy = minY + spacing / 2; gy < maxY; gy += spacing) {
-      if (pointInPolygon(gx, gy, coordsLV95)) {
-        points.push([gx, gy]);
+      if (pointInPolygon(gx, gy, rotated)) {
+        // Rotate back to original orientation
+        const dx = gx - cx, dy = gy - cy;
+        points.push([cx + dx * cosB - dy * sinB, cy + dx * sinB + dy * cosB]);
       }
     }
   }
 
   // Fallback: centroid if grid is empty (very small footprint)
   if (points.length === 0) {
-    let cx = 0, cy = 0;
-    for (const pt of coordsLV95) { cx += pt[0]; cy += pt[1]; }
-    points.push([cx / coordsLV95.length, cy / coordsLV95.length]);
+    points.push([cx, cy]);
   }
   return points;
 }
@@ -198,6 +296,7 @@ export function polygonAreaLV95(ring) {
  * @returns {object|null} Volume result or null if no data
  */
 export function computeVolumeSync(coordsLV95) {
+  const gridAngle = getBuildingAngle(coordsLV95);
   const gridPoints = createGridPoints(coordsLV95);
   if (gridPoints.length === 0) return null;
 
@@ -278,6 +377,7 @@ export function computeVolumeSync(coordsLV95) {
     grid_points: dtmValues.length,
     grid_cells: cells,
     grid_spacing: GRID_SPACING,
+    grid_angle: gridAngle,
   };
 }
 

js/main.js

@@ -127,7 +127,7 @@ function cacheProgressEls() {
 function updateProgress(progress, startTime) {
   if (!progressEls.barFill) cacheProgressEls();
 
-  const { processed, total, succeeded, failed } = progress;
+  const { processed, total, succeeded, failed, noFootprint, noHeight, currentId } = progress;
   const pct = total > 0 ? ((processed / total) * 100).toFixed(1) : 0;
 
   progressEls.barFill.style.width = `${pct}%`;
@@ -141,9 +141,15 @@ function updateProgress(progress, startTime) {
   const etaMin = Math.floor(etaSeconds / 60);
   const etaSec = etaSeconds % 60;
   progressEls.eta.textContent = processed < total
-    ? `Geschatzt: ${etaMin}min ${etaSec}s verbleibend`
+    ? `Geschätzt: ${etaMin}min ${etaSec}s verbleibend`
     : "Abschluss...";
-  progressEls.stats.textContent = `Erfolgreich: ${succeeded} | Fehlgeschlagen: ${failed}`;
+
+  // Detailed breakdown
+  const parts = [`Erfolgreich: ${succeeded}`];
+  if (noFootprint) parts.push(`Kein Grundriss: ${noFootprint}`);
+  if (noHeight) parts.push(`Keine Höhe: ${noHeight}`);
+  if (failed - (noFootprint || 0) - (noHeight || 0) > 0) parts.push(`Fehler: ${failed - noFootprint - noHeight}`);
+  progressEls.stats.textContent = parts.join(" | ");
 }
 
 function showResults() {

js/map.js

@@ -17,13 +17,15 @@ function ensureGridCellsConverted() {
   if (gridCellsGeoJSON || !rawGridCells || rawGridCells.length === 0) return;
   const half = GRID_SPACING / 2;
   const features = rawGridCells.map((c) => {
-    const sw = fromLV95(c.x - half, c.y - half);
-    const se = fromLV95(c.x + half, c.y - half);
-    const ne = fromLV95(c.x + half, c.y + half);
-    const nw = fromLV95(c.x - half, c.y + half);
+    const cos = Math.cos(c.angle), sin = Math.sin(c.angle);
+    // Compute 4 corners of the rotated square in LV95
+    const corners = [[-half, -half], [half, -half], [half, half], [-half, half]].map(([dx, dy]) =>
+      fromLV95(c.x + dx * cos - dy * sin, c.y + dx * sin + dy * cos)
+    );
+    corners.push(corners[0]); // close ring
     return {
       type: "Feature",
-      geometry: { type: "Polygon", coordinates: [[sw, se, ne, nw, sw]] },
+      geometry: { type: "Polygon", coordinates: [corners] },
       properties: { h: Math.round(c.h * 10) / 10 },
     };
   });
@@ -147,10 +149,13 @@ export function plotResults(data) {
     });
   }
 
-  // Grid cells — store raw LV95 data, convert lazily on first toggle
+  // Grid cells — store raw LV95 data with angle, convert lazily on first toggle
   rawGridCells = data.buildings
     .filter((b) => b.grid_cells)
-    .flatMap((b) => b.grid_cells);
+    .flatMap((b) => {
+      const angle = b.grid_angle || 0;
+      return b.grid_cells.map((c) => ({ ...c, angle }));
+    });
   gridCellsGeoJSON = null;
 
   const emptyGeoJSON = { type: "FeatureCollection", features: [] };

js/processor.js

@@ -25,6 +25,7 @@ export async function processRows(rows, onProgress) {
   cancelled = false;
   const total = rows.length;
   let processed = 0, succeeded = 0, failed = 0;
+  let noFootprint = 0, noHeight = 0;
 
   async function processOne(row) {
     if (cancelled) return null;
@@ -72,6 +73,7 @@ export async function processRows(rows, onProgress) {
       if (!footprint) {
         result.status = STATUS.NO_FOOTPRINT;
         failed++;
+        noFootprint++;
         return result;
       }
 
@@ -92,6 +94,7 @@ export async function processRows(rows, onProgress) {
         result.status = STATUS.NO_HEIGHT_DATA;
         result.area_footprint_m2 = Math.round(polygonAreaLV95(lv95Coords) * 100) / 100;
         failed++;
+        noHeight++;
         return result;
       }
 
@@ -171,7 +174,7 @@ export async function processRows(rows, onProgress) {
       results[idx] = r;
       processed++;
       releaseSlot();
-      onProgress({ processed, total, succeeded, failed });
+      onProgress({ processed, total, succeeded, failed, noFootprint, noHeight, currentId: rows[idx]?.id || "" });
     });
     allPromises.push(promise);
   }