GridCal 5.3.4__tar.gz → 5.3.6__tar.gz

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Branches/line_location_graphic_item.py

@@ -144,7 +144,7 @@ class LineLocationGraphicItem(QtWidgets.QGraphicsEllipseItem, NodeTemplate):
             x = pos.x() - self.rect().width() / 2
             y = pos.y() - self.rect().height() / 2
             self.setRect(x, y, self.rect().width(), self.rect().height())
-            self.set_callabacks(pos.x(), pos.y())
+            self.set_callbacks(pos.x(), pos.y())
 
             if self.hovered and self.enabled:
                 self.update_position()
@@ -232,13 +232,7 @@ class LineLocationGraphicItem(QtWidgets.QGraphicsEllipseItem, NodeTemplate):
         # Implement the functionality for Action 1 here
         self.editor.remove_line_location_graphic(self)
 
-    def MergeFunction(self):
-        """
 
-        :return:
-        """
-        self.editor.merge_lines()
-        pass
 
     def setNodeColor(self, inner_color: QColor, border_color: QColor = None) -> None:
         """

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Branches/map_line_container.py

@@ -47,7 +47,6 @@ class MapLineContainer(GenericDiagramWidget):
         self.nodes_list: List[LineLocationGraphicItem] = list()
         self.segments_list: List[MapLineSegment] = list()
         self.enabled = True
-        self.original = True  # TODO: Que es esto?
 
     def set_width_scale(self, branch_scale: float, arrow_scale: float):
         """
@@ -469,7 +468,7 @@ class MapLineContainer(GenericDiagramWidget):
         for line in self.segments_list:
             line.set_enable(val=False)
 
-    def set_arrows_with_power(self, Sf: complex, St: complex) -> None:
+    def set_arrows_with_power(self, Sf: complex | None, St: complex | None) -> None:
         """
 
         :param Sf:

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Branches/map_line_segment.py

@@ -63,7 +63,7 @@ class MapLineSegment(QGraphicsLineItem):
         self.first.add_position_change_callback(self.set_from_side_coordinates)
         self.second.add_position_change_callback(self.set_to_side_coordinates)
 
-        self.set_colour(self.color, self.style)
+        self._pen = self.set_colour(self.color, self.style)
         self.update_endings()
         self.needsUpdate = True
         self.setZValue(0)
@@ -93,9 +93,9 @@ class MapLineSegment(QGraphicsLineItem):
         :param width:
         :return:
         """
-        pen = self.pen()
-        pen.setWidthF(width)
-        self.setPen(pen)
+        if self._pen.widthF() != width:  # Only update if width changes
+            self._pen.setWidthF(width)
+            self.setPen(self._pen)
 
     def set_arrow_scale(self, width: float):
         """
@@ -124,6 +124,8 @@ class MapLineSegment(QGraphicsLineItem):
         self.arrow_p_to.set_colour(color, self.arrow_p_to.w, style)
         self.arrow_q_to.set_colour(color, self.arrow_q_to.w, style)
 
+        return pen
+
     def set_from_side_coordinates(self, x: float, y: float):
         """
 
@@ -383,7 +385,7 @@ class MapLineSegment(QGraphicsLineItem):
             self.editor.circuit.delete_branch(obj=self.api_object)
             self.editor.delete_diagram_element(device=self.api_object)
 
-    def set_arrows_with_power(self, Sf: complex, St: complex) -> None:
+    def set_arrows_with_power(self, Sf: complex | None, St: complex | None) -> None:
         """
         Set the arrow directions
         :param Sf: Complex power from

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Substation/node_template.py

@@ -5,7 +5,7 @@
 from __future__ import annotations
 from typing import Union, TYPE_CHECKING, List, Callable
 from PySide6.QtCore import QPointF
-from PySide6.QtGui import QBrush, QColor
+from PySide6.QtGui import QBrush
 
 from GridCal.Gui.Diagrams.generic_graphics import GenericDiagramWidget
 
@@ -24,10 +24,15 @@ class NodeTemplate(GenericDiagramWidget):
                  api_object: ALL_DEV_TYPES = None,
                  editor: Union[GridMapWidget, None] = None,
                  draw_labels: bool = True,
-                 needsUpdate: bool = True,
                  lat: float = 0.0,
                  lon: float = 0.0):
         """
+
+        :param api_object: any GridCal device object
+        :param editor: GridMapWidget
+        :param draw_labels:
+        :param lat:
+        :param lon:
         """
         GenericDiagramWidget.__init__(self,
                                       parent=None,
@@ -35,7 +40,6 @@ class NodeTemplate(GenericDiagramWidget):
                                       editor=editor,
                                       draw_labels=draw_labels)
 
-        self.needs_update: bool = needsUpdate
         self.lat = lat
         self.lon = lon
 
@@ -52,7 +56,7 @@ class NodeTemplate(GenericDiagramWidget):
         """
         self._callbacks.append(fcn)
 
-    def set_callabacks(self, x: float, y: float) -> None:
+    def set_callbacks(self, x: float, y: float) -> None:
         """
         Call all callback functions with x, y
         :param x: x position

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Substation/substation_graphic_item.py

@@ -62,8 +62,14 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
         self.api_object: Substation = api_object  # reassign for the types to be clear
 
         self.radius = r
-        x, y = self.editor.to_x_y(lat=lat, lon=lon)
-        self.setRect(x, y, self.radius, self.radius)
+        r2 = r / 2
+        x, y = self.editor.to_x_y(lat=lat, lon=lon)  # upper left corner
+        self.setRect(
+            x - r2,
+            y - r2,
+            self.radius,
+            self.radius
+        )
 
         # Enable hover events for the item
         self.setAcceptHoverEvents(True)
@@ -113,7 +119,7 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
             r3 = r / 2
             xc = new_x + r3
             yc = new_y + r3
-            self.set_callabacks(xc, yc)
+            self.set_callbacks(xc, yc)
 
             for vl_graphics in self.voltage_level_graphics:
                 vl_graphics.center_on_substation()
@@ -155,8 +161,14 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
         :param lon:
         :return: x, y
         """
-        x, y = self.editor.to_x_y(lat=lat, lon=lon)
-        self.setRect(x, y, self.rect().width(), self.rect().height())
+        x, y = self.editor.to_x_y(lat=lat, lon=lon)  # upper left corner
+
+        self.setRect(
+            x - self.rect().width() / 2,
+            y - self.rect().height() / 2,
+            self.rect().width(),
+            self.rect().height()
+        )
 
         for vl in self.voltage_level_graphics:
             vl.center_on_substation()
@@ -224,13 +236,20 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
             x = pos.x() - self.rect().width() / 2
             y = pos.y() - self.rect().height() / 2
             self.setRect(x, y, self.rect().width(), self.rect().height())
-            self.set_callabacks(pos.x(), pos.y())
+            self.set_callbacks(pos.x(), pos.y())
 
             for vl_graphics in self.voltage_level_graphics:
                 vl_graphics.center_on_substation()
 
             self.update_position_at_the_diagram()  # always update
 
+        # QGraphicsRectItem.mouseMoveEvent(self, event)
+        # pos = self.mapToParent(event.pos())
+        # x = pos.x() + self.rect().width() / 2
+        # y = pos.y() + self.rect().height() / 2
+        # self.set_callbacks(x, y)
+        # self.update_position_at_the_diagram()  # always update
+
     def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
         """
         Event handler for mouse press events.
@@ -369,7 +388,7 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
 
         if ok:
             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)
+            self.set_callbacks(x, y)
 
     def new_substation_diagram(self):
         """

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Substation/voltage_level_graphic_item.py

@@ -203,6 +203,8 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
                        icon_path="",
                        function_ptr=self.add_bus)
 
+        menu.exec_(event.screenPos())
+
     def set_color(self, inner_color: QColor = None, border_color: QColor = None) -> None:
         """
 
@@ -238,7 +240,7 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
         :param width: New pen width.
         """
         pen = self.pen()
-        pen.setWidth(width)
+        pen.setWidth(width)  # keep this and do not change to setWidthF
         self.setPen(pen)
 
     def add_bus(self):

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Tiles/TileProviders/blue_marble.py

@@ -45,9 +45,9 @@ class BlueMarbleTiles(Tiles):
         """
 
         Tiles.__init__(self,
-                       TilesetName=name,
-                       TilesetShortName='BM Tiles',
-                       TilesetVersion='1.0',
+                       tile_set_name=name,
+                       tile_set_short_name='BM Tiles',
+                       tile_set_version='1.0',
                        levels=list(range(10)),
                        tile_width=256,
                        tile_height=256,
@@ -66,7 +66,7 @@ class BlueMarbleTiles(Tiles):
 
         Note that we assume the point *is* on the map!
 
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
         """
 
         lat_rad = math.radians(latitude)
@@ -76,18 +76,18 @@ class BlueMarbleTiles(Tiles):
 
         return xtile, ytile
 
-    def Tile2Geo(self, xtile: float, ytile: float) -> Tuple[float, float]:
+    def Tile2Geo(self, x_tile: float, y_tile: float) -> Tuple[float, float]:
         """Convert tile fractional coordinates to geo for level in use.
 
         tile  a tupl;e (xtile,ytile) of tile fractional coordinates
 
         Note that we assume the point *is* on the map!
 
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
         """
         n = 2.0 ** self.level
-        xgeo = xtile / n * 360.0 - 180.0
-        yrad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
+        xgeo = x_tile / n * 360.0 - 180.0
+        yrad = math.atan(math.sinh(math.pi * (1 - 2 * y_tile / n)))
         ygeo = math.degrees(yrad)
 
         return xgeo, ygeo

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Tiles/TileProviders/cartodb.py

@@ -23,7 +23,6 @@
 """
 A tile source that serves OpenStreetMap tiles from server(s).
 """
-
 import math
 from typing import Tuple
 from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles import Tiles
@@ -46,16 +45,15 @@ class CartoDbTiles(Tiles):
         :param tile_servers:
         """
 
-        super().__init__(TilesetName=name,
-                         TilesetShortName='CartoDb Dark Matter',
-                         TilesetVersion='1.0',
+        super().__init__(tile_set_name=name,
+                         tile_set_short_name='CartoDb Dark Matter',
+                         tile_set_version='1.0',
                          levels=list(range(22)),
                          tile_width=256,
                          tile_height=256,
                          tiles_dir=tiles_dir,
                          servers=[
-                             "http://basemaps.cartocdn.com/dark_all/"
-                             # http://basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png
+                             "https://basemaps.cartocdn.com/dark_all/"
                          ] if tile_servers is None else tile_servers,
                          url_path='/{Z}/{X}/{Y}.png',
                          max_server_requests=2,
@@ -73,28 +71,46 @@ class CartoDbTiles(Tiles):
     def Geo2Tile(self, longitude: float, latitude: float) -> Tuple[float, float]:
         """
         Convert geo to tile fractional coordinates for level in use.
-        geo  tuple of geo coordinates (xgeo, ygeo)
+        geo  tuple of geo coordinates (longitude, latitude)
         Note that we assume the point *is* on the map!
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+
+        Lon./lat. to tile numbers:
+        n = 2 ^ zoom
+        x_tile = n * ((lon_deg + 180) / 360)
+        y_tile = n * (1 - (log(tan(lat_rad) + sec(lat_rad)) / π)) / 2
+
+        :return: This code returns the coordinate of the upper left point of the tile. (x_tile, y_tile)
         """
         lat_rad = math.radians(latitude)
-        n = 2.0 ** self.level
-        xtile = (longitude + 180.0) / 360.0 * n
-        ytile = ((1.0 - math.log(math.tan(lat_rad) + (1.0 / math.cos(lat_rad))) / math.pi) / 2.0) * n
+        n = math.pow(2.0, self.level)
+        x_tile = (longitude + 180.0) / 360.0 * n
+        y_tile = ((1.0 - math.log(math.tan(lat_rad) + (1.0 / math.cos(lat_rad))) / math.pi) / 2.0) * n
 
-        return xtile, ytile
+        return x_tile, y_tile
 
-    def Tile2Geo(self, xtile: float, ytile: float) -> Tuple[float, float]:
+    def Tile2Geo(self, x_tile: float, y_tile: float) -> Tuple[float, float]:
         """
         Convert tile fractional coordinates to geo for level in use.
-        tile  a tuple (xtile,ytile) of tile fractional coordinates
+        tile  a tuple (x_tile, y_tile) of tile fractional coordinates
         Note that we assume the point *is* on the map!
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+
+        n = 2 ^ zoom
+        lon_deg = x_tile / n * 360.0 - 180.0
+        lat_rad = arctan(sinh(π * (1 - 2 * y_tile / n)))
+        lat_deg = lat_rad * 180.0 / π
+
+        This returns the NW-corner of the square.
+        Use the function with x_tile+1 and/or y_tile+1 to get the other corners.
+        With x_tile+0.5 & y_tile+0.5 it will return the center of the tile.
+
+        :return: This code returns the coordinate of the upper left point of the tile. (longitude, latitude)
         """
 
         n = 2.0 ** self.level
-        longitude = xtile / n * 360.0 - 180.0
-        yrad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
-        latitude = math.degrees(yrad)
+        longitude = x_tile / n * 360.0 - 180.0
+        y_rad = math.atan(math.sinh(math.pi * (1 - 2 * y_tile / n)))
+        latitude = math.degrees(y_rad)
 
         return longitude, latitude

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Tiles/base_tiles.py

@@ -72,8 +72,8 @@ class BaseTiles(object):
         self.ppd_y = 0
 
         # TODO: implement map wrap-around
-        #        self.wrap_x = False
-        #        self.wrap_y = False
+        self.wrap_x = False
+        self.wrap_y = False
 
         # setup the tile cache
         self.cache = TilesCache(tiles_dir=tiles_dir, max_lru=max_lru)
@@ -207,13 +207,13 @@ class BaseTiles(object):
         Tile coordinates are measured from map top-left.
         """
 
-        #        # if we are wrapping X or Y, get wrapped tile coords
-        #        if self.wrap_x:
-        #            x = (x + self.num_tiles_x*self.tile_size_x) % self.num_tiles_x
-        #        if self.wrap_y:
-        #            y = (y + self.num_tiles_y*self.tile_size_y) % self.num_tiles_y
+        # if we are wrapping X or Y, get wrapped tile coords
+        if self.wrap_x:
+            x = (x + self.num_tiles_x * self.tile_size_x) % self.num_tiles_x
+        if self.wrap_y:
+            y = (y + self.num_tiles_y * self.tile_size_y) % self.num_tiles_y
 
-        # retrieve the tile
+            # retrieve the tile
         try:
             # get tile from cache
             return self.cache[(self.level, x, y)]
@@ -254,7 +254,6 @@ class BaseTiles(object):
         """
         Return True if tile at (level, x, y) is on-disk.
         """
-
         raise Exception('You must override BaseTiles.tile_on_disk(level, x, y))')
 
     def setCallback(self, callback: Callable[[int, float, float, QPixmap, bool], None]):
@@ -262,9 +261,7 @@ class BaseTiles(object):
         Set the "tile available" callback function.
         Only used with internet tiles.  See "tiles_net.py".
         """
-
-        pass
-        # raise Exception('You must override BaseTiles.setCallback(callback))')
+        raise Exception('You must override BaseTiles.setCallback(callback))')
 
     def Geo2Tile(self, longitude: float, latitude: float) -> Tuple[int, int]:
         """
@@ -277,12 +274,12 @@ class BaseTiles(object):
 
         raise Exception('You must override BaseTiles.Geo2Tile(xgeo, ygeo)')
 
-    def Tile2Geo(self, xtile: float, ytile: float) -> Tuple[float, float]:
+    def Tile2Geo(self, x_tile: float, y_tile: float) -> Tuple[float, float]:
         """
         Convert tile fractional coordinates to geo for level in use.
 
-        xtile  tile fractional X coordinate
-        ytile  tile fractional Y coordinate
+        :param x_tile:  tile fractional X coordinate
+        :param y_tile:  tile fractional Y coordinate
 
         Note that we assume the point *is* on the map!
         """

{gridcal-5.3.4 → gridcal-5.3.6}/GridCal/Gui/Diagrams/MapWidget/Tiles/tile_worker.py

@@ -42,74 +42,6 @@ def log(val: str):
     print(val)
 
 
-
-
-# class OsmHandler(osm.SimpleHandler):
-#     def __init__(self):
-#         super().__init__()
-#         self.nodes = []
-#         self.ways = []
-#
-#     def node(self, n):
-#         self.nodes.append((n.location.lat, n.location.lon))
-#
-#     def way(self, w):
-#         self.ways.append([node.ref for node in w.nodes])
-#
-#
-# def render_pbf_to_pixmap(pbf_file: str, width=800, height=800) -> QPixmap:
-#     """
-#
-#     :param pbf_file:
-#     :param width:
-#     :param height:
-#     :return:
-#     """
-#     # Parse the .pbf file
-#     handler = OsmHandler()
-#     handler.apply_file(pbf_file)
-#
-#     # Setup Mercator projection
-#     mercator_proj = Proj("epsg:3857")
-#
-#     # Create a QPixmap and painter
-#     pixmap = QPixmap(width, height)
-#     pixmap.fill(Qt.GlobalColor.white)
-#     painter = QPainter(pixmap)
-#     painter.setPen(QPen(Qt.GlobalColor.black, 1))
-#
-#     # Scale coordinates to fit the pixmap
-#     bounds = {
-#         'min_x': float('inf'), 'max_x': float('-inf'),
-#         'min_y': float('inf'), 'max_y': float('-inf')
-#     }
-#     transformed_nodes = []
-#
-#     for lat, lon in handler.nodes:
-#         x, y = mercator_proj(lon, lat)
-#         transformed_nodes.append((x, y))
-#         bounds['min_x'] = min(bounds['min_x'], x)
-#         bounds['max_x'] = max(bounds['max_x'], x)
-#         bounds['min_y'] = min(bounds['min_y'], y)
-#         bounds['max_y'] = max(bounds['max_y'], y)
-#
-#     x_range = bounds['max_x'] - bounds['min_x']
-#     y_range = bounds['max_y'] - bounds['min_y']
-#     scale_x = width / x_range if x_range else 1
-#     scale_y = height / y_range if y_range else 1
-#     scale = min(scale_x, scale_y)
-#
-#     # Render nodes as points
-#     for x, y in transformed_nodes:
-#         scaled_x = int((x - bounds['min_x']) * scale)
-#         scaled_y = int((y - bounds['min_y']) * scale)
-#         painter.drawPoint(scaled_x, height - scaled_y)  # Flip y-axis for Qt's coordinate system
-#
-#     # Close the painter
-#     painter.end()
-#     return pixmap
-
-
 class TileWorker(QThread):
     """Thread class that gets request from queue, loads tile, calls callback."""