# /**********************************************************************
# *                                                                     *
# * Copyright (c) 2021-2026 Javier Braña <javier.branagutierrez@gmail.com>*
# *                                                                     *
# * PVPlantPlacement - TaskPanels y comandos de placement de trackers  *
# *                                                                     *
# * La lógica de cálculo está en Civil/PVPlantPlacementCalc.py          *
# *                                                                     *
# ***********************************************************************

import FreeCAD
import Part

if FreeCAD.GuiUp:
    import FreeCADGui, os
    from PySide import QtCore, QtGui
    from PySide.QtGui import QListWidgetItem
    from PySide.QtCore import QT_TRANSLATE_NOOP
else:
    def translate(ctxt, txt): return txt
    def QT_TRANSLATE_NOOP(ctxt, txt): return txt

import PVPlantResources
import PVPlantSite
from Civil.PVPlantPlacementCalc import (
    selectionFilter, getRows, getCols, get_trend, getTrend,
    adjustToTerrain, optimized_cut, getHeadsAndSoil, moveFrameHead, ConvertObjectsTo
)

version = "0.2.0"
class _PVPlantPlacementTaskPanel:
    '''The editmode TaskPanel for Schedules'''

    def __init__(self, obj=None):
        self.site = PVPlantSite.get()
        self.Terrain = self.site.Terrain
        self.FrameSetups = None
        self.PVArea = None
        self.Area = None
        self.gap_col = .0
        self.gap_row = .0
        self.offsetX = .0
        self.offsetY = .0
        self.Dir = FreeCAD.Vector(0, -1, 0)
        self._terrain_interpolator = None
        self._frame_footprints_cache = {}
        self._isinside_cache = {}  # LRU: (frame_name, x, y) -> bool
        self._area_polygon = None  # Caché shapely del área

        # UI setup
        self.form = FreeCADGui.PySideUic.loadUi(os.path.join(PVPlantResources.__dir__, "PVPlantPlacement.ui"))
        self.form.setWindowIcon(QtGui.QIcon(os.path.join(PVPlantResources.DirIcons, "way.svg")))

        self.addFrames()
        self.maxWidth = max([frame.Width.Value for frame in self.site.Frames])

        self.form.buttonPVArea.clicked.connect(self.addPVArea)
        self.form.editGapCols.valueChanged.connect(self.update_inner_spacing)
        self.update_inner_spacing()

    def addPVArea(self):
        sel = FreeCADGui.Selection.getSelection()
        if sel:
            self.PVArea = sel[0]
            self.form.editPVArea.setText(self.PVArea.Label)

    def addFrames(self):
        for frame_setup in self.site.Frames:
            list_item = QListWidgetItem(frame_setup.Name, self.form.listFrameSetups)
            list_item.setCheckState(QtCore.Qt.Checked)

    def update_inner_spacing(self):
        self.form.editInnerSpacing.setText(f"{self.form.editGapCols.value() - self.maxWidth / 1000} m")

    def _get_or_create_frame_group(self):
        """Gestión optimizada de grupos de frames"""
        doc = FreeCAD.ActiveDocument
        main_group = doc.getObject("Frames")
        if not main_group:
            main_group = doc.addObject("App::DocumentObjectGroup", "Frames")
            main_group.Label = "Frames"

        mg = doc.getObject('MechanicalGroup')
        if mg and main_group not in mg.Group:
            mg.addObject(main_group)

        if self.form.cbSubfolders.isChecked() and self.PVArea:
            sn = f"Frames-{self.PVArea.Label}"
            sg = next((o for o in main_group.Group if o.Name == sn), None)
            if not sg:
                sg = doc.addObject("App::DocumentObjectGroup", sn)
                sg.Label = sn
                main_group.addObject(sg)
            return sg
        return main_group

    def createFrameFromPoints(self, dataframe):
        from Mechanical.Frame import PVPlantFrame
        doc = FreeCAD.ActiveDocument

        group = self._get_or_create_frame_group()

        frames = []
        placements_key = "placement" if "placement" in dataframe.columns else 0

        if placements_key == "placement":
            placements = dataframe["placement"].tolist()
            types = dataframe["type"].tolist()

            for idx, (placement, frame_type) in enumerate(zip(placements, types)):
                newrack = PVPlantFrame.makeTracker(setup=frame_type)
                newrack.Label = "Tracker"
                newrack.Visibility = False
                newrack.Placement = placement
                group.addObject(newrack)
                frames.append(newrack)

        if self.PVArea and self.PVArea.Name.startswith("FrameArea"):
            self.PVArea.Frames = frames

    def getProjected(self, shape):
        """Optimized projection calculation"""
        if shape.BoundBox.ZLength == 0:
            return Part.Face(Part.Wire(shape.Edges))

        from Utils import PVPlantUtils as utils
        wire = utils.simplifyWire(utils.getProjected(shape))
        return Part.Face(wire.removeSplitter()) if wire and wire.isClosed() else Part.Face(wire)

    def calculateWorkingArea(self):
        """Optimized working area calculation"""
        self.Area = self.getProjected(self.PVArea.Shape)
        exclusion_areas = FreeCAD.ActiveDocument.findObjects(Name="ExclusionArea")

        if exclusion_areas:
            prohibited_faces = []
            for obj in exclusion_areas:
                face = self.getProjected(obj.Shape.SubShapes[1])
                if face and face.isValid():
                    prohibited_faces.append(face)

            if prohibited_faces:
                self.Area = self.Area.cut(prohibited_faces)

        # Clear caches when area changes
        self._terrain_interpolator = None
        self._area_polygon = None
        self._isinside_cache.clear()

    def _setup_terrain_interpolator(self):
        """Cached terrain interpolator"""
        if self._terrain_interpolator is not None:
            return self._terrain_interpolator

        mesh = self.Terrain.Mesh
        points = np.array([v.Vector for v in mesh.Points])
        bbox = self.Area.BoundBox

        # Filter points within working area efficiently
        mask = ((points[:, 0] >= bbox.XMin) & (points[:, 0] <= bbox.XMax) &
                (points[:, 1] >= bbox.YMin) & (points[:, 1] <= bbox.YMax))
        filtered_points = points[mask]

        if len(filtered_points) == 0:
            self._terrain_interpolator = None
            return None

        try:
            self._terrain_interpolator = LinearNDInterpolator(
                filtered_points[:, :2], filtered_points[:, 2]
            )
        except:
            self._terrain_interpolator = None

        return self._terrain_interpolator

    def _get_frame_footprint(self, frame):
        """Cached footprint calculation"""
        frame_key = (frame.Length.Value, frame.Width.Value)
        if frame_key not in self._frame_footprints_cache:
            l, w = frame.Length.Value, frame.Width.Value
            l_med, w_med = l / 2, w / 2

            footprint = Part.makePolygon([
                FreeCAD.Vector(-l_med, -w_med, 0),
                FreeCAD.Vector(l_med, -w_med, 0),
                FreeCAD.Vector(l_med, w_med, 0),
                FreeCAD.Vector(-l_med, w_med, 0),
                FreeCAD.Vector(-l_med, -w_med, 0)
            ])
            footprint.Placement.Rotation = FreeCAD.Rotation(FreeCAD.Vector(1, 0, 0), FreeCAD.Vector(0, 1, 0))

            self._frame_footprints_cache[frame_key] = footprint

        return self._frame_footprints_cache[frame_key]

    def _calculate_terrain_adjustment_batch(self, points_data):
        """Process terrain adjustments in batches for better performance"""
        terrain_interp = self._setup_terrain_interpolator()
        results = []

        for frame_type, base_point in points_data:
            yl = frame_type.Length.Value / 2
            top_point = FreeCAD.Vector(base_point.x, base_point.y + yl, 0)
            bot_point = FreeCAD.Vector(base_point.x, base_point.y - yl, 0)

            if terrain_interp:
                # Use interpolator for faster elevation calculation
                yy = np.linspace(bot_point.y, top_point.y, 6)  # Reduced points for speed
                xx = np.full_like(yy, base_point.x)
                try:
                    zz = terrain_interp(xx, yy)
                    if not np.isnan(zz).all():
                        slope, intercept, *_ = stats.linregress(yy, zz)
                        z_top = slope * top_point.y + intercept
                        z_bot = slope * bot_point.y + intercept
                    else:
                        z_top = z_bot = 0
                except:
                    z_top = z_bot = 0
            else:
                # Fallback to direct projection (slower)
                line = Part.LineSegment(bot_point, top_point).toShape()
                try:
                    import MeshPart
                    projected = MeshPart.projectShapeOnMesh(line, self.Terrain.Mesh, FreeCAD.Vector(0, 0, 1))[0]
                    if len(projected) >= 2:
                        yy = [p.y for p in projected]
                        zz = [p.z for p in projected]
                        slope, intercept, *_ = stats.linregress(yy, zz)
                        z_top = slope * top_point.y + intercept
                        z_bot = slope * bot_point.y + intercept
                    else:
                        z_top = z_bot = 0
                except:
                    z_top = z_bot = 0

            new_top = FreeCAD.Vector(top_point.x, top_point.y, z_top)
            new_bot = FreeCAD.Vector(bot_point.x, bot_point.y, z_bot)

            new_pl = FreeCAD.Placement()
            new_pl.Base = (new_top + new_bot) / 2
            new_pl.Rotation = FreeCAD.Rotation(
                FreeCAD.Vector(-1, 0, 0), new_top - new_bot
            )

            results.append((frame_type, new_pl))

        return results

    def adjustToTerrain(self, coordinates):
        """Unified terrain adjustment function for both aligned and non-aligned arrays"""
        # Create binary array efficiently
        arr = np.array([[int(obj != 0) for obj in col] for col in coordinates], dtype=np.uint8)
        labeled_array, num_features = sclabel(arr)

        # Build DataFrame efficiently
        data = []
        for label in range(1, num_features + 1):
            cols, rows = np.where(labeled_array == label)
            for col, row in zip(cols, rows):
                frame_type, placement = coordinates[col][row]
                data.append({
                    'ID': len(data) + 1,
                    'region': label,
                    'type': frame_type,
                    'column': col,
                    'row': row,
                    'placement': placement
                })

        if not data:
            return pd.DataFrame(columns=['ID', 'region', 'type', 'column', 'row', 'placement'])

        df = pd.DataFrame(data)

        # Process terrain adjustments in batches
        points_data = [(row['type'], row['placement']) for _, row in df.iterrows()]
        adjusted_results = self._calculate_terrain_adjustment_batch(points_data)

        # Update placements in DataFrame
        for idx, (frame_type, new_placement) in enumerate(adjusted_results):
            df.at[idx, 'placement'] = new_placement

        return df

    def _get_area_polygon(self):
        """Convierte self.Area a shapely Polygon para comprobaciones rápidas"""
        if self._area_polygon is None and self.Area:
            from shapely.geometry import Polygon
            verts = self.Area.Vertexes
            if len(verts) >= 3:
                self._area_polygon = Polygon([(v.x, v.y) for v in verts])
        return self._area_polygon

    def isInside(self, frame, point):
        """
        Comprueba si un frame cabe en el área en un punto dado.
        Usa shapely para la comprobación 2D (mucho más rápido que Part.cut).
        """
        # Caché LRU: mismo frame + misma posición
        key = (frame.Name, round(point.x, 0), round(point.y, 0))
        if key in self._isinside_cache:
            return self._isinside_cache[key]

        # Prefiltro rápido por BoundBox
        fw, fl = frame.Width.Value / 2, frame.Length.Value / 2
        if (point.x - fw < self.Area.BoundBox.XMin or
            point.x + fw > self.Area.BoundBox.XMax or
            point.y - fl < self.Area.BoundBox.YMin or
            point.y + fl > self.Area.BoundBox.YMax):
            self._isinside_cache[key] = False
            return False

        # Comprobación precisa con shapely
        ap = self._get_area_polygon()
        if ap is not None:
            from shapely.geometry import box
            fp = box(point.x - fw, point.y - fl, point.x + fw, point.y + fl)
            result = ap.contains(fp)
            self._isinside_cache[key] = result
            return result

        # Fallback OCC (si shapely falla)
        try:
            frame_footprint = self._get_frame_footprint(frame)
            frame_footprint.Placement.Base = point
            cut = frame_footprint.cut([self.Area])
            result = len(cut.Vertexes) == 0
            self._isinside_cache[key] = result
            return result
        except Part.OCCError:
            self._isinside_cache[key] = False
            return False

    def getAligments(self):
        """
        Calcula las alineaciones X (columnas) y opcionalmente Y (filas)
        en función de las referencias seleccionadas.
        Retorna (x_range, y_range). y_range vacío si no hay referencia vertical.
        """
        sel = FreeCADGui.Selection.getSelectionEx()
        if not sel or not sel[0].SubObjects:
            return np.array([], dtype=np.float64), np.array([], dtype=np.float64)

        sub_objects = sel[0].SubObjects

        if len(sub_objects) == 1:
            # Una sola referencia: usar BoundBox completo
            bb = sub_objects[0].BoundBox
            area_bb = self.Area.BoundBox
            n_cols = max(1, int((area_bb.XMax - area_bb.XMin) / self.gap_col))
            n_rows = max(1, int((area_bb.YMax - area_bb.YMin) / self.gap_row))
            x_range = np.linspace(area_bb.XMin + self.offsetX, area_bb.XMax, n_cols, dtype=np.float64)
            y_range = np.linspace(area_bb.YMax - self.offsetY - self.gap_row, area_bb.YMin, n_rows, dtype=np.float64)
        else:
            refh = max(sub_objects[:2], key=lambda x: x.BoundBox.XLength)
            refv = max(sub_objects[:2], key=lambda x: x.BoundBox.YLength)

            # Alinear grid con referencias
            area_xmin, area_xmax = self.Area.BoundBox.XMin, self.Area.BoundBox.XMax
            area_ymin, area_ymax = self.Area.BoundBox.YMin, self.Area.BoundBox.YMax

            n_cols = max(1, int((area_xmax - area_xmin) / self.gap_col))
            n_rows = max(1, int((area_ymax - area_ymin) / self.gap_row))
            x_range = np.linspace(
                refv.BoundBox.XMin + self.offsetX,
                min(refv.BoundBox.XMax + self.offsetX, area_xmax),
                n_cols, dtype=np.float64
            )
            y_range = np.linspace(
                refh.BoundBox.YMax - self.offsetY,
                max(refh.BoundBox.YMin - self.offsetY, area_ymin),
                n_rows, dtype=np.float64
            ) if n_rows > 1 else np.array([refh.BoundBox.YMin], dtype=np.float64)

        # Pre-filtrar: eliminar puntos claramente fuera del BoundBox del área
        x_range = x_range[(x_range >= self.Area.BoundBox.XMin) & (x_range <= self.Area.BoundBox.XMax)]
        if len(y_range) > 0:
            y_range = y_range[(y_range >= self.Area.BoundBox.YMin) & (y_range <= self.Area.BoundBox.YMax)]

        return x_range, y_range

    def calculateAlignedArray(self):
        """
        Coloca frames en grid alineado (filas y columnas).
        Llama al motor unificado _calculate_placement.
        """
        return self._calculate_placement(mode='aligned')

    def calculateNonAlignedArray(self):
        """
        Coloca frames adaptados al contorno del área (solo columnas).
        Llama al motor unificado _calculate_placement.
        """
        return self._calculate_placement(mode='non_aligned')

    def _calculate_placement(self, mode='non_aligned'):
        """
        Motor de posicionamiento unificado para aligned y non_aligned.

        aligned:     grid Y fijo + isInside (rápido en áreas rectangulares, usa caché)
        non_aligned: intersección área-línea (preciso en bordes irregulares)
        """
        pointsx, pointsy = self.getAligments()
        if len(pointsx) == 0:
            FreeCAD.Console.PrintWarning("No X alignments found.\n")
            return pd.DataFrame()

        # Pre-calcular footprints una sola vez
        footprints = []
        for frame in self.FrameSetups:
            footprint = self._get_frame_footprint(frame)
            footprints.append((frame, footprint))

        if not footprints:
            return pd.DataFrame()

        min_h = min(ftp[0].Width.Value for ftp in footprints)
        corridor_enabled = self.form.groupCorridor.isChecked()
        corridor_count = 0
        corridor_offset = 0
        ref_width = footprints[0][0].Width.Value
        corridor_val = FreeCAD.Units.Quantity(
            self.form.editColGap.text()).Value - (self.gap_col - ref_width)
        area_ymax = self.Area.BoundBox.YMax
        area_ymin = self.Area.BoundBox.YMin
        ref_frame = footprints[0][0]
        ref_len = ref_frame.Length.Value

        n_cols = len(pointsx)
        cols = [None] * n_cols

        # Procesar por lotes para permitir interrupción con barra de progreso
        from PySide.QtCore import QCoreApplication
        for idx, x in enumerate(pointsx):
            col = []
            cx = x + corridor_offset

            # Actualizar barra de progreso cada 20 columnas
            if idx % 20 == 0 and hasattr(self.form, 'progressBar'):
                self.form.progressBar.setValue(int(100 * idx / n_cols))
                QCoreApplication.processEvents()

            if mode == 'aligned' and len(pointsy) > 0:
                half_len = ref_len / 2
                for y in pointsy:
                    py = y - half_len
                    # Vector creado solo si pasa el BoundBox check (ya lo hace isInside internamente)
                    tp = FreeCAD.Vector(cx, py, 0.0)
                    placed = False
                    if self.isInside(ref_frame, tp):
                        col.append([ref_frame, tp])
                        placed = True
                    else:
                        # frames alternativos: probar con offsets
                        for fi in range(1, len(footprints)):
                            fr = footprints[fi][0]
                            ld = (ref_len - fr.Length.Value) / 2
                            for yoff in (ld, -ld):
                                if self.isInside(fr, FreeCAD.Vector(tp.x, tp.y + yoff, 0.0)):
                                    col.append([fr, FreeCAD.Vector(tp.x, tp.y + yoff, 0.0)])
                                    placed = True
                                    break
                            if placed:
                                break
                    if not placed:
                        col.append(0)
            else:
                # Non-aligned: intersección de línea vertical con el área
                line = Part.LineSegment(
                    FreeCAD.Vector(cx, area_ymax, 0.0),
                    FreeCAD.Vector(cx, area_ymin, 0.0)
                ).toShape()
                try:
                    inter = self.Area.section(line)
                    pts = sorted([v.Point for v in inter.Vertexes],
                                 key=lambda p: p.y, reverse=True)
                    for i in range(0, len(pts) - 1, 1 + (len(pts) > 2)):
                        top, bot = pts[i], pts[i + 1]
                        if top.y - bot.y > min_h:
                            self._place_frames_in_segment(col, footprints, cx, top, bot)
                except Exception as e:
                    FreeCAD.Console.PrintWarning(f"Segment error: {e}\n")

            # Corredores
            if corridor_enabled and col:
                corridor_count += 1
                if corridor_count >= self.form.editColCount.value():
                    corridor_offset += corridor_val
                    corridor_count = 0
            cols[idx] = col

        return self.adjustToTerrain(cols)

    def accept(self):
        from datetime import datetime
        starttime = datetime.now()

        params = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Document")
        auto_save_enabled = params.GetBool("AutoSaveEnabled")
        params.SetBool("AutoSaveEnabled", False)
        FreeCAD.ActiveDocument.RecomputesFrozen = True

        try:
            items = [
                FreeCAD.ActiveDocument.getObject(self.form.listFrameSetups.item(i).text())
                for i in range(self.form.listFrameSetups.count())
                if self.form.listFrameSetups.item(i).checkState() == QtCore.Qt.Checked
            ]

            self.FrameSetups = list({f.Length.Value: f for f in items}.values())
            self.FrameSetups.sort(key=lambda x: x.Length.Value, reverse=True)

            self.gap_col = FreeCAD.Units.Quantity(self.form.editGapCols.text()).Value
            self.gap_row = FreeCAD.Units.Quantity(self.form.editGapRows.text()).Value + self.FrameSetups[0].Length.Value
            self.offsetX = FreeCAD.Units.Quantity(self.form.editOffsetHorizontal.text()).Value
            self.offsetY = FreeCAD.Units.Quantity(self.form.editOffsetVertical.text()).Value

            FreeCAD.ActiveDocument.openTransaction("Create Placement")
            self.calculateWorkingArea()

            if self.form.cbAlignFrames.isChecked():
                dataframe = self.calculateAlignedArray()
            else:
                dataframe = self.calculateNonAlignedArray()

            if not dataframe.empty:
                self.createFrameFromPoints(dataframe)

            import Electrical.group as egroup
            import importlib
            importlib.reload(egroup)
            egroup.groupTrackersToTransformers(5000000, self.gap_row)

            FreeCAD.ActiveDocument.commitTransaction()

        finally:
            FreeCAD.ActiveDocument.RecomputesFrozen = False
            params.SetBool("AutoSaveEnabled", auto_save_enabled)

        elapsed = datetime.now() - starttime
        FreeCAD.Console.PrintMessage(f"Placement: {elapsed}\n")
        FreeCADGui.Control.closeDialog()
        FreeCAD.ActiveDocument.recompute()

class adjustToTerrainTaskPanel:
    def __init__(self, obj=None):
        self.obj = obj
        self.form = FreeCADGui.PySideUic.loadUi(PVPlantResources.__dir__ + "/PVPlantPlacementAdjust.ui")

    def accept(self):
        frames = []
        for obj in FreeCADGui.Selection.getSelection():
            if obj.Name.startswith("Tracker"):
                frames.append(obj)
            elif obj.Name.startswith("FrameArea"):
                frames.extend(obj.Frames)
        adjustToTerrain(frames, self.form.comboMethod.currentIndex() == 0)
        self.close()
        return True

    def reject(self):
        self.close()
        return False

    def close(self):
        FreeCADGui.Control.closeDialog()

import numpy as np
from scipy import stats

class _PVPlantConvertTaskPanel:
    '''The editmode TaskPanel for Conversions'''

    def __init__(self):
        self.To = None
        # self.form:
        self.form = FreeCADGui.PySideUic.loadUi(os.path.join(PVPlantResources.__dir__, "PVPlantPlacementConvert.ui"))
        self.form.setWindowIcon(QtGui.QIcon(os.path.join(PVPlantResources.DirIcons, "Trace.svg")))
        self.form.buttonTo.clicked.connect(self.addTo)

    def addTo(self):
        sel = FreeCADGui.Selection.getSelection()
        if len(sel) > 0:
            self.To = sel[0]
            self.form.editTo.setText(self.To.Label)

    def accept(self):
        sel = FreeCADGui.Selection.getSelection()
        if sel == self.To:
            return False
        if len(sel) > 0 and self.To is not None:
            FreeCAD.ActiveDocument.openTransaction("Convert to")
            ConvertObjectsTo(sel, self.To)
            return True
        return False


class CommandPVPlantPlacement:

    def GetResources(self):
        return {'Pixmap': str(os.path.join(PVPlantResources.DirIcons, "way.svg")),
                'Accel': "P,P",
                'MenuText': QT_TRANSLATE_NOOP("Placement", "Placement"),
                'ToolTip': QT_TRANSLATE_NOOP("Placement", "Crear un campo fotovoltaico")}

    def Activated(self):
        taskd = _PVPlantPlacementTaskPanel(None)
        FreeCADGui.Control.showDialog(taskd)

    def IsActive(self):
        if FreeCAD.ActiveDocument:
            return True
        else:
            return False


class CommandAdjustToTerrain:

    def GetResources(self):
        return {'Pixmap': str(os.path.join(PVPlantResources.DirIcons, "adjust.svg")),
                'Accel': "P, A",
                'MenuText': QT_TRANSLATE_NOOP("Placement", "Adjust"),
                'ToolTip': QT_TRANSLATE_NOOP("Placement", "Adjust object to terrain")}

    def Activated(self):
        sel = FreeCADGui.Selection.getSelection()
        if len(sel) > 0:
            # adjustToTerrain(sel)
            FreeCADGui.Control.showDialog(adjustToTerrainTaskPanel())
        else:
            print("No selected object")

    def IsActive(self):
        if FreeCAD.ActiveDocument:
            return True
        else:
            return False


class CommandConvert:
    def GetResources(self):
        return {'Pixmap': str(os.path.join(PVPlantResources.DirIcons, "convert.svg")),
                'Accel': "P, C",
                'MenuText': QT_TRANSLATE_NOOP("Placement", "Convert"),
                'ToolTip': QT_TRANSLATE_NOOP("Placement", "Convertir un objeto en otro")}

    def IsActive(self):
        return (not FreeCAD.ActiveDocument is None and
                not FreeCAD.ActiveDocument.getObject("Site") is None and
                not FreeCAD.ActiveDocument.getObject("Terrain") is None and
                not FreeCAD.ActiveDocument.getObject("TrackerSetup") is None)

    def Activated(self):
        taskd = _PVPlantConvertTaskPanel()
        FreeCADGui.Control.showDialog(taskd)


'''if FreeCAD.GuiUp:
    FreeCADGui.addCommand('PVPlantPlacement', _CommandPVPlantPlacement())
    FreeCADGui.addCommand('PVPlantAdjustToTerrain', _CommandAdjustToTerrain())
    FreeCADGui.addCommand('PVPlantConvertTo', _CommandConvert())'''