GridCal 5.1.18__tar.gz → 5.1.20__tar.gz

{GridCal-5.1.18 → GridCal-5.1.20}/GridCal/Gui/Diagrams/MapWidget/Branches/map_line_container.py

@@ -78,7 +78,7 @@ class MapLineContainer(GenericDiagramWidget):
         Remove all segments from the scene
         """
         for segment in self.segments_list:
-            self.editor.remove_from_scene(segment)
+            self.editor.remove_only_graphic_element(segment)
 
         self.segments_list = list()
 
@@ -257,48 +257,16 @@ class MapLineContainer(GenericDiagramWidget):
             # draw the segment in the scene
             self.editor.add_to_scene(graphic_object=segment_graphic_object)
 
-        # diagram_locations: PointsGroup = self.editor.diagram.data.get(DeviceType.LineLocation.value, None)
-        #
-        # for idx, elm in enumerate(self.api_object.locations.data):
-        #
-        #     if diagram_locations is None:
-        #         # no locations found, use the data from the api object
-        #         # lat = elm.lat
-        #         # lon = elm.long
-        #         pass
-        #     else:
-        #
-        #         # try to get location from the diagram
-        #         diagram_location = diagram_locations.locations.get(elm.idtag, None)
-        #
-        #         if diagram_location is None:
-        #             # no particular location found, use the data from the api object
-        #             # lat = elm.lat
-        #             # lon = elm.long
-        #             pass
-        #         else:
-        #             # Draw only what's on the diagram
-        #             # diagram data found, use it
-        #
-        #             if idx > 0:
-        #                 i1 = idx
-        #                 i2 = idx - 1
-        #                 # Assuming Connector takes (scene, node1, node2) as arguments
-        #                 segment_graphic_object = Segment(first=self.nodes_list[i1],
-        #                                                  second=self.nodes_list[i2])
-        #
-        #                 self.nodes_list[i1].needsUpdateFirst = True
-        #                 self.nodes_list[i2].needsUpdateSecond = True
-        #                 segment_graphic_object.needsUpdate = True
-        #
-        #                 # register the segment in the line
-        #                 self.add_segment(segment=segment_graphic_object)
-        #
-        #                 # draw the segment in the scene
-        #                 self.editor.add_to_scene(graphic_object=segment_graphic_object)
-
         self.update_connectors()
 
+        self.editor.Update_widths()
+
+    def substation_to(self):
+        return self.editor.graphics_manager.query(elm=self.api_object.get_substation_to())
+
+    def substation_from(self):
+        return self.editor.graphics_manager.query(elm=self.api_object.get_substation_from())
+
     def insert_new_node_at_position(self, index: int):
         """
         Creates a new node in the list at the given position
@@ -307,7 +275,7 @@ class MapLineContainer(GenericDiagramWidget):
         """
 
         # Check if the index is valid
-        if 1 <= index < len(self.api_object.locations.data):
+        if 1 <= index < len(self.api_object.locations.data) and len(self.api_object.locations.data) > 1:
 
             nd1 = self.nodes_list[index]
             nd2 = self.nodes_list[index - 1]
@@ -356,7 +324,7 @@ class MapLineContainer(GenericDiagramWidget):
             # Return the newly created node
             return graphic_obj
 
-        elif index == 0 and len(self.api_object.locations.data) == 0:
+        elif len(self.api_object.locations.data) == 0:
 
             substation_from_graphics = self.editor.graphics_manager.query(elm=self.api_object.get_substation_from())
             substation_to_graphics = self.editor.graphics_manager.query(elm=self.api_object.get_substation_to())
@@ -375,7 +343,7 @@ class MapLineContainer(GenericDiagramWidget):
                                           idtag="",
                                           code="")
 
-            self.api_object.locations.data.insert(index, new_api_object)
+            self.api_object.locations.data.insert(0, new_api_object)
 
             # Create a new graphical node item
 
@@ -383,19 +351,10 @@ class MapLineContainer(GenericDiagramWidget):
                                                   api_object=new_api_object,
                                                   lat=new_api_object.lat,
                                                   lon=new_api_object.long,
-                                                  index=index)
-
-            idx = 0
-
-            for nod in self.nodes_list:
-
-                if idx >= index:
-                    nod.index = nod.index + 1
-
-                idx = idx + 1
+                                                  index=0)
 
             # Add the node to the nodes list
-            self.nodes_list.insert(index, graphic_obj)
+            self.nodes_list.insert(0, graphic_obj)
 
             graphic_obj.updatePosition()
 
@@ -405,7 +364,7 @@ class MapLineContainer(GenericDiagramWidget):
             # Return the newly created node
             return graphic_obj
 
-        elif 0 == index or index == len(self.api_object.locations.data):
+        elif (0 == index or index >= len(self.api_object.locations.data) - 1):
 
             substation_from_graphics = self.editor.graphics_manager.query(elm=self.api_object.get_substation_from())
             substation_to_graphics = self.editor.graphics_manager.query(elm=self.api_object.get_substation_to())
@@ -417,7 +376,7 @@ class MapLineContainer(GenericDiagramWidget):
                 nd2 = self.nodes_list[0]
 
             if index >= len(self.nodes_list):
-                nd2 = self.nodes_list[len(self.nodes_list) - 1]
+                nd1 = self.nodes_list[len(self.nodes_list) - 1]
 
             new_lat = ((nd2.lat + nd1.lat) / 2)
             new_long = ((nd2.lon + nd1.lon) / 2)

{GridCal-5.1.18 → GridCal-5.1.20}/GridCal/Gui/Diagrams/MapWidget/Branches/map_line_segment.py

@@ -324,8 +324,18 @@ class MapLineSegment(QGraphicsLineItem):
 
         if len(self.container.nodes_list) == 0:
             self.container.insert_new_node_at_position(0)
+        elif len(self.container.nodes_list) == 1:
+            if self.second == self.container.substation_to() or self.first == self.container.substation_to():
+                self.container.insert_new_node_at_position(1)
+            else:
+                self.container.insert_new_node_at_position(0)
         else:
-            self.container.insert_new_node_at_position(self.second.index)
+            if self.second == self.container.substation_to() or self.first == self.container.substation_to():
+                self.container.insert_new_node_at_position(len(self.container.nodes_list))
+            elif self.second == self.container.substation_from() or self.first == self.container.substation_from():
+                self.container.insert_new_node_at_position(0)
+            else:
+                self.container.insert_new_node_at_position(self.first.index)
 
         # TODO implement
         # self.editor.split_line(line_graphics=self)

{GridCal-5.1.18 → GridCal-5.1.20}/GridCal/Gui/Diagrams/MapWidget/Substation/substation_graphic_item.py

@@ -50,7 +50,7 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
                  api_object: Substation,
                  lat: float,
                  lon: float,
-                 r: float = 0.4,
+                 r: float = 0.8,
                  draw_labels: bool = True):
         """
 
@@ -101,16 +101,21 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
         # self.setZValue(1)
         self.voltage_level_graphics: List[VoltageLevelGraphicItem] = list()
 
-    def move_to(self, lat: float, lon: float):
+    def move_to(self, lat: float, lon: float) -> Tuple[float, float]:
         """
 
         :param lat:
         :param lon:
-        :return:
+        :return: x, y
         """
         x, y = self.editor.to_x_y(lat=lat, lon=lon)
         self.setRect(x, y, self.rect().width(), self.rect().height())
 
+        for vl in self.voltage_level_graphics:
+            vl.center_on_substation()
+
+        return x, y
+
     def register_voltage_level(self, vl: VoltageLevelGraphicItem):
         """
 
@@ -147,13 +152,22 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
         """
         lat, long = self.editor.to_lat_lon(self.rect().x(), self.rect().y())
 
-        print(f'Updating SE position id:{self.api_object.idtag}, lat:{lat}, lon:{long}')
+        # print(f'Updating SE position id:{self.api_object.idtag}, lat:{lat}, lon:{long}')
 
         self.editor.update_diagram_element(device=self.api_object,
                                            latitude=lat,
                                            longitude=long,
                                            graphic_object=self)
 
+    def get_center_pos(self) -> QPointF:
+        """
+
+        :return:
+        """
+        x = self.rect().x() + self.rect().width() / 2
+        y = self.rect().y() + self.rect().height() / 2
+        return QPointF(x, y)
+
     def mouseMoveEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
         """
         Event handler for mouse move events.
@@ -170,23 +184,17 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
             for vl_graphics in self.voltage_level_graphics:
                 vl_graphics.center_on_substation()
 
-            self.editor.update_connectors()
-
-    def get_center_pos(self) -> QPointF:
-        """
-
-        :return:
-        """
-        x = self.rect().x() + self.rect().width() / 2
-        y = self.rect().y() + self.rect().height() / 2
-        return QPointF(x, y)
+            self.updateDiagram()  # always update
 
     def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
         """
         Event handler for mouse press events.
         """
+        super().mousePressEvent(event)
+        event.setAccepted(True)
         self.editor.map.view.disableMove = True
 
+        print("SE mouse press")
         if self.api_object is not None:
             self.editor.set_editor_model(api_object=self.api_object,
                                          dictionary_of_lists={
@@ -202,8 +210,10 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
         """
         Event handler for mouse release events.
         """
+        # super().mouseReleaseEvent(event)
         self.editor.disableMove = True
         self.updateDiagram()  # always update
+        print("SE mouse release")
 
     def hoverEnterEvent(self, event: QtWidgets.QGraphicsSceneHoverEvent) -> None:
         """
@@ -245,9 +255,14 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
 
         add_menu_entry(menu=menu,
                        text="ADD node",
-                       icon_path="",
+                       icon_path=":/Icons/icons/divide.svg",
                        function_ptr=self.add_function)
 
+        add_menu_entry(menu=menu,
+                       text="Show diagram",
+                       icon_path="",
+                       function_ptr=self.new_substation_diagram)
+
         menu.exec_(event.screenPos())
 
     def add_function(self):
@@ -265,8 +280,10 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
             lines_info = []
 
             for idtag, graphic_object in dev_dict.items():
-                substation_from_graphics = self.editor.graphics_manager.query(elm=graphic_object.api_object.get_substation_from())
-                substation_to_graphics = self.editor.graphics_manager.query(elm=graphic_object.api_object.get_substation_to())
+                substation_from_graphics = self.editor.graphics_manager.query(
+                    elm=graphic_object.api_object.get_substation_from())
+                substation_to_graphics = self.editor.graphics_manager.query(
+                    elm=graphic_object.api_object.get_substation_to())
                 lines_info.append((idtag, graphic_object, substation_from_graphics, substation_to_graphics))
 
             # Now, iterate over the collected information
@@ -298,8 +315,15 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
                              "Move substation graphics")
 
         if ok:
-            self.move_to(lat=self.api_object.latitude, lon=self.api_object.longitude)
-            self.editor.update_connectors()
+            x, y = self.move_to(lat=self.api_object.latitude, lon=self.api_object.longitude)  # this moves the vl too
+            self.set_callabacks(x, y)
+
+    def new_substation_diagram(self):
+        """
+        Function to create a new substation
+        :return:
+        """
+        self.editor.new_substation_diagram(substation=self.api_object)
 
     def add_voltage_level(self) -> None:
         """

{GridCal-5.1.18 → GridCal-5.1.20}/GridCal/Gui/Diagrams/MapWidget/Substation/voltage_level_graphic_item.py

@@ -61,19 +61,19 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
                                       api_object=api_object,
                                       editor=editor,
                                       draw_labels=draw_labels)
-        QGraphicsEllipseItem.__init__(self, parent_center.x(), parent_center.y(), r, r, parent)
+        QGraphicsEllipseItem.__init__(self, parent_center.x(), parent_center.y(), r * api_object.Vnom, r * api_object.Vnom, parent)
 
         parent.register_voltage_level(vl=self)
 
         self.editor: GridMapWidget = editor  # to reinforce the type
         self.api_object: VoltageLevel = api_object  # to reinforce the type
 
-        self.radius = r
+        self.radius = r * api_object.Vnom
         print(f"VL created at x:{parent_center.x()}, y:{parent_center.y()}")
 
         self.setAcceptHoverEvents(True)  # Enable hover events for the item
         # self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable)  # Allow moving the node
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)  # Allow selecting the node
+        self.setFlag(self.GraphicsItemFlag.ItemIsSelectable | self.GraphicsItemFlag.ItemIsMovable)  # Allow selecting the node
 
         # Create a pen with reduced line width
         self.change_pen_width(0.5)
@@ -90,7 +90,7 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
         self.needsUpdate = False
         self.setZValue(0)
 
-    def center_on_substation(self):
+    def center_on_substation(self) -> None:
         """
         Centers the graphic item on the substation
         """
@@ -99,6 +99,16 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
         yc = parent_center.y() - self.rect().height() / 2
         self.setRect(xc, yc, self.rect().width(), self.rect().height())
 
+    def move_to_xy(self, x: float, y: float):
+        """
+
+        :param x:
+        :param y:
+        :return:
+        """
+        self.setRect(x, y, self.rect().width(), self.rect().height())
+        return x, y
+
     def updateDiagram(self) -> None:
         """
 
@@ -120,10 +130,9 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
         """
         Event handler for mouse move events.
         """
-        super().mouseMoveEvent(event)
+        # super().mouseMoveEvent(event)
         if self.hovered:
-            # self.updatePosition()
-            self.editor.update_connectors()
+            self.parent.mouseMoveEvent(event)
 
     def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
         """

{GridCal-5.1.18 → GridCal-5.1.20}/GridCal/Gui/Diagrams/MapWidget/TileProviders/blue_marble.py

@@ -4,15 +4,15 @@ A tile source that serves BlueMarble tiles from the internet.
 
 import math
 from typing import Tuple
-import GridCal.Gui.Diagrams.MapWidget.Tiles.tiles as tiles_net
+from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles import Tiles
 
 
-class BlueMarbleTiles(tiles_net.Tiles):
+class BlueMarbleTiles(Tiles):
     """
     An object to source internet tiles for pySlip.
     """
 
-    def __init__(self, tiles_dir='blue_marble_tiles', http_proxy=None):
+    def __init__(self, tiles_dir='blue_marble_tiles', http_proxy=None, name: str = 'Blue Marble'):
         """
         Override the base class for these tiles.
 
@@ -22,18 +22,19 @@ class BlueMarbleTiles(tiles_net.Tiles):
         :param http_proxy:
         """
 
-        super().__init__(TilesetName='BlueMarble Tiles',
-                         TilesetShortName='BM Tiles',
-                         TilesetVersion='1.0',
-                         levels=list(range(10)),
-                         tile_width=256,
-                         tile_height=256,
-                         tiles_dir=tiles_dir,
-                         max_lru=10000,
-                         servers=['https://s3.amazonaws.com', ],
-                         url_path='/com.modestmaps.bluemarble/{Z}-r{Y}-c{X}.jpg',
-                         max_server_requests=2,
-                         http_proxy=http_proxy)
+        Tiles.__init__(self,
+                       TilesetName=name,
+                       TilesetShortName='BM Tiles',
+                       TilesetVersion='1.0',
+                       levels=list(range(10)),
+                       tile_width=256,
+                       tile_height=256,
+                       tiles_dir=tiles_dir,
+                       max_lru=10000,
+                       servers=['https://s3.amazonaws.com', ],
+                       url_path='/com.modestmaps.bluemarble/{Z}-r{Y}-c{X}.jpg',
+                       max_server_requests=2,
+                       http_proxy=http_proxy)
 
     def Geo2Tile(self, longitude: float, latitude: float) -> Tuple[float, float]:
         """Convert geo to tile fractional coordinates for level in use.

{GridCal-5.1.18 → GridCal-5.1.20}/GridCal/Gui/Diagrams/MapWidget/TileProviders/cartodb.py

@@ -10,7 +10,10 @@ from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles import Tiles
 class CartoDbTiles(Tiles):
     """An object to source server tiles for pySlipQt."""
 
-    def __init__(self, tiles_dir='open_street_map_tiles', http_proxy=None, tile_servers=None):
+    def __init__(self, tiles_dir='open_street_map_tiles',
+                 http_proxy=None,
+                 tile_servers=None,
+                 name: str = 'Carto positron'):
         """
         Override the base class for these tiles.
 
@@ -21,7 +24,7 @@ class CartoDbTiles(Tiles):
         :param tile_servers:
         """
 
-        super().__init__(TilesetName='CartoDb Dark Matter',
+        super().__init__(TilesetName=name,
                          TilesetShortName='CartoDb Dark Matter',
                          TilesetVersion='1.0',
                          levels=list(range(17)),

{GridCal-5.1.18 → GridCal-5.1.20}/GridCal/Gui/Diagrams/MapWidget/grid_map_widget.py

@@ -51,7 +51,7 @@ from GridCal.Gui.Diagrams.MapWidget.Substation.substation_graphic_item import Su
 from GridCal.Gui.Diagrams.MapWidget.Substation.voltage_level_graphic_item import VoltageLevelGraphicItem
 from GridCal.Gui.Diagrams.MapWidget.map_widget import MapWidget
 import GridCal.Gui.Visualization.visualization as viz
-import GridCal.Gui.Visualization.palettes as palettes
+import GridCalEngine.Devices.Diagrams.palettes as palettes
 from GridCal.Gui.Diagrams.graphics_manager import ALL_MAP_GRAPHICS
 from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles import Tiles
 from GridCal.Gui.Diagrams.base_diagram_widget import BaseDiagramWidget
@@ -207,7 +207,8 @@ class GridMapWidget(BaseDiagramWidget):
                  name: str,
                  circuit: MultiCircuit,
                  diagram: Union[None, MapDiagram] = None,
-                 call_delete_db_element_func: Callable[["GridMapWidget", ALL_DEV_TYPES], None] = None):
+                 call_delete_db_element_func: Callable[["GridMapWidget", ALL_DEV_TYPES], None] = None,
+                 call_new_substation_diagram_func: Callable[[Substation], None] = None, ):
         """
 
         :param tile_src:
@@ -241,11 +242,14 @@ class GridMapWidget(BaseDiagramWidget):
                              position_callback=self.position_callback)
 
         # Any representation on the map must be done after this Goto Function
-        self.map.GotoLevelAndPosition(level=start_level, longitude=longitude, latitude=latitude)
+        self.map.GotoLevelAndPosition(level=6, longitude=0, latitude=40)
 
-        self.map.startLev = start_level
-        self.map.startLat = latitude
-        self.map.startLon = longitude
+        self.map.startLev = 6
+        self.map.startLat = 0
+        self.map.startLon = 40
+
+        # function pointer to call for a new substation diagram
+        self.call_new_substation_diagram_func = call_new_substation_diagram_func
 
         self.startHe = self.map.view.height()
         self.startWi = self.map.view.width()
@@ -301,6 +305,13 @@ class GridMapWidget(BaseDiagramWidget):
 
         self.map.diagram_scene.addItem(graphic_object)
 
+    def remove_only_graphic_element(self, graphic_object: ALL_MAP_GRAPHICS = None) -> None:
+        """
+        Removes only the graphic elements, not the api_object
+        :param graphic_object: Graphic object associated
+        """
+        self.map.diagram_scene.removeItem(graphic_object)
+
     def remove_from_scene(self, graphic_object: ALL_MAP_GRAPHICS = None) -> None:
         """
         Add item to the diagram and the diagram scene
@@ -590,18 +601,19 @@ class GridMapWidget(BaseDiagramWidget):
 
         :return:
         """
-        for dev_tpe in [DeviceType.LineDevice,
-                        DeviceType.DCLineDevice,
-                        DeviceType.HVDCLineDevice,
-                        DeviceType.FluidPathDevice]:
-
-            dev_dict = self.graphics_manager.get_device_type_dict(device_type=dev_tpe)
-
-            for idtag, graphic_object in dev_dict.items():
-                graphic_object.update_connectors()
-
-            for idtag, graphic_object in dev_dict.items():
-                graphic_object.end_update()
+        # for dev_tpe in [DeviceType.LineDevice,
+        #                 DeviceType.DCLineDevice,
+        #                 DeviceType.HVDCLineDevice,
+        #                 DeviceType.FluidPathDevice]:
+        #
+        #     dev_dict = self.graphics_manager.get_device_type_dict(device_type=dev_tpe)
+        #
+        #     for idtag, graphic_object in dev_dict.items():
+        #         graphic_object.update_connectors()
+        #
+        #     for idtag, graphic_object in dev_dict.items():
+        #         graphic_object.end_update()
+        pass
 
     def add_api_substation(self,
                            api_object: Substation,
@@ -806,21 +818,25 @@ class GridMapWidget(BaseDiagramWidget):
         :return:
         """
 
-        pass
+        # SANTIAGO: NO TOCAR ESTO ES EL COMPORTAMIENTO DESEADO
 
-        # max_zoom = self.map.max_level
-        # min_zoom = self.map.min_level
-        # zoom = self.map.zoom_factor
-        # scale = 0.1 + (zoom - min_zoom) / (max_zoom - min_zoom)
-        #
-        # # rescale lines
-        # for dev_tpe in [DeviceType.LineDevice,
-        #                 DeviceType.DCLineDevice,
-        #                 DeviceType.HVDCLineDevice,
-        #                 DeviceType.FluidPathDevice]:
-        #     graphics_dict = self.graphics_manager.get_device_type_dict(device_type=dev_tpe)
-        #     for key, lne in graphics_dict.items():
-        #         lne.setWidthScale(scale)
+        self.Update_widths()
+
+    def Update_widths(self):
+
+        max_zoom = self.map.max_level
+        min_zoom = self.map.min_level
+        zoom = self.map.zoom_factor
+        scale = self.diagram.min_branch_width + (zoom - min_zoom) / (max_zoom - min_zoom)
+
+        # rescale lines
+        for dev_tpe in [DeviceType.LineDevice,
+                        DeviceType.DCLineDevice,
+                        DeviceType.HVDCLineDevice,
+                        DeviceType.FluidPathDevice]:
+            graphics_dict = self.graphics_manager.get_device_type_dict(device_type=dev_tpe)
+            for key, lne in graphics_dict.items():
+                lne.setWidthScale(scale)
 
     def change_size_and_pen_width_all(self, new_radius, pen_width):
         """
@@ -1096,6 +1112,17 @@ class GridMapWidget(BaseDiagramWidget):
         else:
             raise Exception('Extension ' + str(extension) + ' not supported :(')
 
+    def new_substation_diagram(self, substation: Substation):
+        """
+
+        :param substation:
+        :return:
+        """
+        if self.call_new_substation_diagram_func is not None:
+            self.call_new_substation_diagram_func(substation)
+        else:
+            print("call_new_substation_diagram_func is None :( ")
+
 
 def generate_map_diagram(substations: List[Substation],
                          voltage_levels: List[VoltageLevel],