EarthWorks: separado en PVPlantPlatform (plataforma desde trackers) + PVPlantEarthWorks (solo volumen cut/fill). Platform reutilizable independientemente.

2026-05-03 23:52:58 +02:00
parent 2858b58d86
commit 1a22121f87
2 changed files with 408 additions and 286 deletions
@@ -0,0 +1,284 @@
+# /**********************************************************************
+# *                                                                     *
+# * Copyright (c) 2026 Javier Braña <javier.branagutierrez@gmail.com>  *
+# *                                                                     *
+# * Platform - Generación de plataforma desde trackers                  *
+# *                                                                     *
+# * Construye la superficie diseñada (plataforma) a partir de la        *
+# * disposición de trackers solares, incluyendo pendientes E-W,         *
+# * conexiones entre filas y columnas.                                  *
+# *                                                                     *
+# * Esta plataforma se usa luego en EarthWorks para calcular            *
+# * volúmenes de corte y relleno contra el terreno natural.             *
+# *                                                                     *
+# ***********************************************************************
+
+import FreeCAD
+import Part
+import math
+
+
+def get_tracker_rows(frames):
+    """
+    Agrupa trackers en filas y columnas usando la lógica de Placement.
+
+    Returns:
+        (rows, columns): listas de listas, o (None, None) si falla
+    """
+    try:
+        import PVPlantPlacement
+        return PVPlantPlacement.getRows(frames)
+    except Exception:
+        return None, None
+
+
+def build_platform(frames, slope_tolerance=10.0):
+    """
+    Construye la plataforma (superficie diseñada) a partir de una lista
+    de frames/trackers.
+
+    Args:
+        frames: lista de objetos tracker (con Placement, Setup, etc.)
+        slope_tolerance: pendiente máxima E-W en grados
+
+    Returns:
+        Part.Solid con la plataforma, o None si no se puede generar
+    """
+    rows, columns = get_tracker_rows(frames)
+    if rows is None or not rows:
+        FreeCAD.Console.PrintWarning(
+            "No se pudieron agrupar los trackers en filas/columnas\n")
+        return None
+
+    all_faces = []
+    tools = []
+
+    # --- Fase 1: Lofts longitudinales (a lo largo de cada fila) ---
+    for group in rows:
+        lines = _generate_row_lines(group, slope_tolerance)
+        tools.extend(lines["tools"])
+        if len(lines["edges"]) >= 2:
+            try:
+                loft = Part.makeLoft(lines["edges"], False, True, False)
+                if loft and not loft.isNull():
+                    all_faces.extend(loft.Faces)
+            except Exception:
+                pass
+
+    # --- Fase 2: Lofts transversales (entre columnas) ---
+    if columns:
+        for group in rows:
+            for frame in group:
+                col, idx = _find_in_columns(frame, columns)
+                tool = _find_tool(frame, tools)
+                if tool is None or idx >= len(col) - 1:
+                    continue
+
+                next_frame = col[idx + 1]
+                next_tool = _find_tool(next_frame, tools)
+                if next_tool is None:
+                    continue
+
+                try:
+                    # Conectar borde izquierdo de frame con borde izquierdo del siguiente
+                    l1 = Part.LineSegment(
+                        tool[1].Vertexes[-1].Point,
+                        next_tool[1].Vertexes[0].Point
+                    ).toShape()
+                    # Conectar borde derecho
+                    l2 = Part.LineSegment(
+                        tool[2].Vertexes[-1].Point,
+                        next_tool[2].Vertexes[0].Point
+                    ).toShape()
+                    if l1 and l2:
+                        loft = Part.makeLoft([l1, l2], False, True, False)
+                        if loft and not loft.isNull():
+                            all_faces.extend(loft.Faces)
+                except Exception:
+                    pass
+
+    if not all_faces:
+        FreeCAD.Console.PrintWarning(
+            "No se generaron caras para la plataforma\n")
+        return None
+
+    # --- Fase 3: Unir caras en un sólido ---
+    try:
+        import Utils.PVPlantUtils as utils
+        # Intentar fuse progresivo
+        platform = None
+        for face in all_faces:
+            if platform is None:
+                platform = face
+            else:
+                try:
+                    platform = platform.fuse(face)
+                except Exception:
+                    pass
+
+        if platform is None:
+            return None
+
+        # Si es una shell, convertir a sólido
+        if platform.ShapeType == "Shell":
+            try:
+                platform = Part.makeSolid(platform)
+            except Exception:
+                pass
+        elif platform.ShapeType == "Compound":
+            # Extraer caras y hacer shell
+            faces_in_compound = []
+            for sub in platform.SubShapes:
+                if sub.ShapeType == "Face":
+                    faces_in_compound.append(sub)
+            if faces_in_compound:
+                try:
+                    shell = Part.makeShell(faces_in_compound)
+                    platform = Part.makeSolid(shell)
+                except Exception:
+                    pass
+
+        return platform if not platform.isNull() else None
+
+    except Exception as e:
+        FreeCAD.Console.PrintError(
+            f"Error al unir la plataforma: {e}\n")
+        return None
+
+
+def add_platform_to_doc(platform, name="Platform"):
+    """
+    Añade la plataforma como objeto visible en el documento activo.
+
+    Args:
+        platform: Part.Shape (Solid o Compound)
+        name: nombre del objeto en el documento
+    """
+    if platform is None:
+        return None
+    doc = FreeCAD.ActiveDocument
+    if doc is None:
+        return None
+    obj = doc.addObject("Part::Feature", name)
+    obj.Shape = platform
+    obj.Label = name
+    doc.recompute()
+    return obj
+
+
+def _generate_row_lines(group, slope_tolerance):
+    """
+    Genera las líneas de borde (izquierda/derecha) para una fila de trackers.
+
+    Returns:
+        dict con:
+          - edges: lista de Part.Shape (líneas)
+          - tools: lista de [frame, izq, der] para reconexión
+    """
+    lines = {"edges": [], "tools": []}
+
+    for i, frame in enumerate(group):
+        if not hasattr(frame, "Setup"):
+            continue
+
+        aw = _angle_to_prev(group, i)
+        ae = _angle_to_next(group, i)
+        anf = (aw + ae) / 2
+        if anf > slope_tolerance:
+            anf = slope_tolerance
+
+        wdt = _get_tracker_width(frame)
+        zz = wdt * math.sin(math.radians(anf))
+
+        base_line = _get_tracker_base_line(frame)
+
+        # Borde izquierdo (sur)
+        li = base_line.copy()
+        li.Placement = frame.Placement
+        li.Placement.Rotation = frame.Placement.Rotation
+        li.Placement.Base.x -= wdt
+        li.Placement.Base.z -= zz
+        lines["edges"].append(li)
+
+        # Borde derecho (norte)
+        ld = base_line.copy()
+        ld.Placement = frame.Placement
+        ld.Placement.Rotation = frame.Placement.Rotation
+        ld.Placement.Base.x += wdt
+        ld.Placement.Base.z += zz
+        lines["edges"].append(ld)
+
+        lines["tools"].append([frame, li, ld])
+
+    return lines
+
+
+def _get_tracker_width(frame):
+    """Ancho medio del tracker (mm)."""
+    try:
+        return int(frame.Setup.Width / 2)
+    except Exception:
+        return 0
+
+
+def _get_tracker_base_line(frame):
+    """
+    Línea base longitudinal del tracker, centrada en su origen local.
+    """
+    try:
+        lng = int(frame.Setup.Length / 2)
+        return Part.LineSegment(
+            FreeCAD.Vector(-lng, 0, 0),
+            FreeCAD.Vector(lng, 0, 0)
+        ).toShape()
+    except Exception:
+        # Fallback: BoundBox
+        try:
+            bb = frame.Setup.Shape.BoundBox
+            return Part.LineSegment(
+                FreeCAD.Vector(bb.XMin, 0, 0),
+                FreeCAD.Vector(bb.XMax, 0, 0)
+            ).toShape()
+        except Exception:
+            return Part.LineSegment(
+                FreeCAD.Vector(-2000, 0, 0),
+                FreeCAD.Vector(2000, 0, 0)
+            ).toShape()
+
+
+def _angle_to_prev(group, i):
+    if i <= 0:
+        return 0
+    p0 = FreeCAD.Vector(group[i - 1].Placement.Base)
+    p1 = FreeCAD.Vector(group[i].Placement.Base)
+    return _angle_xz(p0, p1)
+
+
+def _angle_to_next(group, i):
+    if i >= len(group) - 1:
+        return 0
+    p1 = FreeCAD.Vector(group[i].Placement.Base)
+    p2 = FreeCAD.Vector(group[i + 1].Placement.Base)
+    return _angle_xz(p1, p2)
+
+
+def _angle_xz(v1, v2):
+    """Ángulo en el plano XZ entre dos vectores (grados)."""
+    dx = v2.x - v1.x
+    dz = v2.z - v1.z
+    return math.degrees(math.atan2(dz, dx))
+
+
+def _find_in_columns(frame, columns):
+    for col in columns:
+        for group in col:
+            if frame in group:
+                return group, group.index(frame)
+    return [], -1
+
+
+def _find_tool(frame, tools):
+    for t in tools:
+        if t[0] == frame:
+            return t
+    return None