[Layer] Added KiPy support to all Layer members

Author: set-soft

kibot/__main__.py

@@ -480,6 +480,7 @@ def get_layers_info():
 def detect_kicad():
     import_kicad_api()
     get_kicad_version()
+    GS.set_version_pointers()
     get_layers_info()
 
     # Setup details dependent on the API version

kibot/gs.py

@@ -1242,33 +1242,90 @@ def module_position(m):
         return f'({GS.to_mm(pos.x)}, {GS.to_mm(pos.y)}) mm'
 
     @staticmethod
-    def layer_is_inner(id):
-        return pcbnew.IsInnerCopperLayer(id) if GS.ki9 else id > pcbnew.F_Cu and id < pcbnew.B_Cu
+    def set_version_pointers():
+        """ Used to setup function pointers according to the API and its version """
+        if GS.pn is not None:
+            if GS.ki9:
+                GS.layer_is_inner = GS.layer_is_inner_k9
+                GS.ordinal_to_copper_layer = GS.ordinal_to_copper_layer_k9
+                GS.copper_layer_to_ordinal = GS.copper_layer_to_ordinal_k9
+            else:
+                GS.layer_is_inner = GS.layer_is_inner_k5
+                GS.ordinal_to_copper_layer = GS.ordinal_to_copper_layer_k5
+                GS.copper_layer_to_ordinal = GS.copper_layer_to_ordinal_k5
+        elif GS.kp is not None:
+            GS.layer_is_inner = GS.layer_is_inner_kp
+            GS.ordinal_to_copper_layer = GS.ordinal_to_copper_layer_kp
+            GS.copper_layer_to_ordinal = GS.copper_layer_to_ordinal_kp
+
+    @staticmethod
+    def layer_is_inner_k5(id):
+        return id > GS.F_Cu and id < GS.B_Cu
+
+    @staticmethod
+    def layer_is_inner_k9(id):
+        return GS.pn.IsInnerCopperLayer(id)
+
+    @staticmethod
+    def layer_is_inner_kp(id):
+        return GS.kp.util.board_layer.is_copper_layer(id) and id != GS.F_Cu and id != GS.B_Cu
 
     @staticmethod
     def inner_layer_index(id):
         return int(id/2-1) if GS.ki9 else id-pcbnew.F_Cu+1
 
     @staticmethod
-    def copper_layer_to_ordinal(n):
-        if GS.ki9:
-            ordinal = pcbnew.CopperLayerToOrdinal(n)
-            # Adjust to the current PCB
-            if ordinal == pcbnew.CopperLayerToOrdinal(pcbnew.B_Cu):
-                ordinal = GS.board.GetCopperLayerCount()-1
-            return ordinal
-        # <= 8
-        return GS.board.GetCopperLayerCount()-1 if n == pcbnew.B_Cu else n
-
-    @staticmethod
-    def ordinal_to_copper_layer(n):
-        # Only for KiCad 9+
-        if n == GS.board.GetCopperLayerCount()-1:
-            return pcbnew.B_Cu
-        if n == 0:
-            return pcbnew.F_Cu
+    def copper_layer_to_ordinal_k5(n):
+        """ Converts a KiCad layer number to its position.
+            F.Cu will be 0 and B.Cu the last """
+        return GS.board.GetCopperLayerCount()-1 if n == GS.B_Cu else n
+
+    @staticmethod
+    def copper_layer_to_ordinal_k9(n):
+        """ Converts a KiCad layer number to its position.
+            F.Cu will be 0 and B.Cu the last """
+        ordinal = pcbnew.CopperLayerToOrdinal(n)
+        # Adjust to the current PCB
+        if ordinal == pcbnew.CopperLayerToOrdinal(pcbnew.B_Cu):
+            ordinal = GS.board.GetCopperLayerCount()-1
+        return ordinal
+
+    @staticmethod
+    def copper_layer_to_ordinal_kp(n):
+        """ Converts a KiCad layer number to its position.
+            F.Cu will be 0 and B.Cu the last """
+        return GS.board.get_copper_layer_count()-1 if n == GS.B_Cu else n
+
+    @staticmethod
+    def ordinal_to_copper_layer_k9(n):
+        """ From an ordinal layer position where F.Cu is 0 and B.Cu is the last
+            returns the KiCad layer number """
+        if n >= GS.board.GetCopperLayerCount()-1:
+            return GS.B_Cu
+        if n <= 0:
+            return GS.F_Cu
         return (n+1)*2
 
+    @staticmethod
+    def ordinal_to_copper_layer_k5(n):
+        """ From an ordinal layer position where F.Cu is 0 and B.Cu is the last
+            returns the KiCad layer number """
+        if n >= GS.board.GetCopperLayerCount()-1:
+            return GS.B_Cu
+        if n <= 0:
+            return GS.F_Cu
+        return n
+
+    @staticmethod
+    def ordinal_to_copper_layer_kp(n):
+        """ From an ordinal layer position where F.Cu is 0 and B.Cu is the last
+            returns the KiCad layer number """
+        if n >= GS.board.get_copper_layer_count()-1:
+            return GS.B_Cu
+        if n <= 0:
+            return GS.F_Cu
+        return GS.kp.util.board_layer.layer_from_canonical_name(f'In{n}.Cu')
+
     @staticmethod
     def get_via_width(via):
         if not GS.ki9:

kibot/layer.py

@@ -31,19 +31,14 @@ def create_print_priority(board):
     global LAYER_PRIORITY
     if len(LAYER_PRIORITY) > 0:
         return
-    LAYER_PRIORITY = {board.GetLayerID(name): c for c, name in enumerate(LAYER_ORDER)}
+    get_id = board.GetLayerID if GS.pn else GS.kp.util.board_layer.layer_from_canonical_name
+    LAYER_PRIORITY = {get_id(name): c for c, name in enumerate(LAYER_ORDER)}
 
 
 def get_priority(id):
     return LAYER_PRIORITY.get(id, 1e6)
 
 
-def inner_id_in_range(id, cnt):
-    if GS.ki9:
-        return GS.layer_is_inner(id) and int(id/2) < cnt
-    return id > 0 and id < cnt-1
-
-
 class Layer(Optionable):
     """ A layer description """
     # Protel extensions
@@ -122,9 +117,8 @@ def fix_protel_ext(self):
     @classmethod
     def solve(cls, values):
         board = GS.board
-        layer_cnt = 2
         if board:
-            layer_cnt = board.GetCopperLayerCount()
+            board.GetCopperLayerCount() if GS.pn is not None else board.get_copper_layer_count()
             create_print_priority(board)
         # Get the list of used layers from the board
         # Used for 'all' but also to validate the layer names
@@ -146,9 +140,6 @@ def solve(cls, values):
             for layer in values:
                 if isinstance(layer, Layer):
                     layer._get_layer_id_from_name()
-                    # Check if the layer is in use
-                    if layer._is_inner and not inner_id_in_range(layer._id, layer_cnt):
-                        raise PlotError("Inner layer `{}` is not valid for this board".format(layer))
                     layer.fix_protel_ext()
                     new_vals.append(layer)
                 elif isinstance(layer, int):
@@ -183,41 +174,76 @@ def solve(cls, values):
         raise AssertionError("Unimplemented layer type "+str(type(values)))
 
     @staticmethod
-    def _get_copper():
+    def _get_copper_pn():
         return {GS.board.GetLayerName(id): id for id in GS.board.GetEnabledLayers().CuStack()}
 
     @staticmethod
-    def _get_inners():
+    def _get_copper_kp():
+        return {GS.board.get_layer_name(id): id for id in GS.board.get_enabled_layers()
+                if GS.kp.util.board_layer.is_copper_layer(id)}
+
+    @staticmethod
+    def _get_inners_pn():
         return {GS.board.GetLayerName(id): id for id in GS.board.GetEnabledLayers().CuStack()
                 if id != GS.B_Cu and id != GS.F_Cu}
 
     @staticmethod
-    def _get_outers():
+    def _get_inners_kp():
+        return {GS.board.get_layer_name(id): id for id in GS.board.get_enabled_layers()
+                if id != GS.B_Cu and id != GS.F_Cu and GS.kp.util.board_layer.is_copper_layer(id)}
+
+    @staticmethod
+    def _get_outers_pn():
         return {GS.board.GetLayerName(id): id for id in GS.board.GetEnabledLayers().CuStack()
                 if id == GS.B_Cu or id == GS.F_Cu}
 
     @staticmethod
-    def _get_technical():
-        if GS.ki9:
-            return {GS.board.GetLayerName(id): id for id in GS.board.GetEnabledLayers().AllTechMask().Seq()}
+    def _get_outers_kp():
+        return {GS.board.get_layer_name(id): id for id in GS.board.get_enabled_layers() if id == GS.B_Cu or id == GS.F_Cu}
+
+    @staticmethod
+    def _get_technical_pn_k6():
         return {GS.board.GetLayerName(id): id for id in GS.board.GetEnabledLayers().Technicals()}
 
     @staticmethod
-    def _get_user():
+    def _get_technical_pn_k9():
+        return {GS.board.GetLayerName(id): id for id in GS.board.GetEnabledLayers().AllTechMask().Seq()}
+
+    @staticmethod
+    def _get_technical_kp():
+        # All but copper and user
+        return {GS.board.get_layer_name(id): id for id in GS.board.get_enabled_layers()
+                if not GS.kp.util.board_layer.is_copper_layer(id) and
+                not GS.kp.util.board_layer.canonical_name(id).startswith('User.')}
+
+    @staticmethod
+    def _get_user_pn_k6():
+        enabled = GS.board.GetEnabledLayers()
+        return {GS.board.GetLayerName(id): id for id in enabled.Users()}
+
+    @staticmethod
+    def _get_user_pn_k9():
         b = GS.board
         enabled = b.GetEnabledLayers()
-        if GS.ki9:
-            layers = {b.GetLayerName(id): id for id in enabled.UserMask().Seq()}
-            # Applying UserDefinedLayersMask() doesn't work as expected it returns all possible user layers
-            # This is why we need the "if id ..." and this why we need to get the list in 2 steps
-            layers.update({b.GetLayerName(id): id for id in enabled.UserDefinedLayersMask().Seq() if id in enabled.Seq()})
-            return layers
-        return {GS.board.GetLayerName(id): id for id in enabled.Users()}
+        layers = {b.GetLayerName(id): id for id in enabled.UserMask().Seq()}
+        # Applying UserDefinedLayersMask() doesn't work as expected it returns all possible user layers
+        # This is why we need the "if id ..." and this why we need to get the list in 2 steps
+        layers.update({b.GetLayerName(id): id for id in enabled.UserDefinedLayersMask().Seq() if id in enabled.Seq()})
+        return layers
+
+    @staticmethod
+    def _get_user_kp():
+        return {GS.board.get_layer_name(id): id for id in GS.board.get_enabled_layers()
+                if GS.kp.util.board_layer.canonical_name(id).startswith('User.')}
 
     @staticmethod
-    def _set_pcb_layers():
+    def _set_pcb_layers_pn():
         Layer._pcb_layers = {GS.board.GetLayerName(id): id for id in GS.board.GetEnabledLayers().Seq()}
 
+    @staticmethod
+    def _set_pcb_layers_kp():
+        Layer._pcb_layers = {GS.board.get_layer_name(id): id for id in GS.board.get_enabled_layers()}
+
     def get_default_suffix(self):
         if GS.global_layer_defaults:
             layer = next(filter(lambda x: x.layer == self.layer, GS.global_layer_defaults), None)
@@ -241,7 +267,7 @@ def create_layer(cls, name):
         else:
             layer._id = name
             layer._is_inner = GS.layer_is_inner(name)
-            name = GS.board.GetLayerName(name)
+            name = GS.board.GetLayerName(name) if GS.pn is not None else GS.board.get_layer_name(name)
             layer.layer = name
         layer.suffix = layer.get_default_suffix()
         layer.description = layer.get_default_description()
@@ -257,13 +283,19 @@ def _get_layers(cls, d_layers):
         return layers
 
     @staticmethod
-    def _set_plot_layers():
+    def _set_plot_layers_pn():
         board = GS.board
         enabled = board.GetEnabledLayers().Seq()
         for id in board.GetPlotOptions().GetLayerSelection().Seq():
             if id in enabled:
                 Layer._plot_layers[board.GetLayerName(id)] = id
 
+    @staticmethod
+    def _set_plot_layers_kp():
+        # TODO: kipy NOT IMPLEMENTED!!!
+        # Here we just get all of them, not good
+        Layer._plot_layers = {GS.board.get_layer_name(id): id for id in GS.board.get_enabled_layers()}
+
     def _get_layer_id_from_name(self):
         """ Get the pcbnew layer from the string provided in the config """
         # Priority
@@ -281,17 +313,20 @@ def _get_layer_id_from_name(self):
                 # 3) Inner.N names
                 m = match(r"^Inner\.([0-9]+)$", self.layer)
                 if not m:
-                    raise KiPlotConfigurationError("Malformed inner layer name: `{}`, use Inner.N".format(self.layer))
+                    raise KiPlotConfigurationError(f"Malformed inner layer name: `{self.layer}`, use Inner.N")
                 id = int(m.group(1))
-                self._id = (id+1)*2 if GS.ki9 else id
+                self._id = GS.ordinal_to_copper_layer(id)
+                if self._id == GS.B_Cu or self._id == GS.F_Cu:
+                    raise PlotError(f"Inner layer `{self.layer}` is not valid for this board")
                 self._is_inner = True
             else:
                 raise KiPlotConfigurationError("Unknown layer name: `{}`".format(self.layer))
         return self._id
 
-    def is_copper(self):
-        if GS.pn is not None:
-            return self._id >= GS.F_Cu and self._id <= GS.B_Cu
+    def is_copper_pn(self):
+        return self._id >= GS.F_Cu and self._id <= GS.B_Cu
+
+    def is_copper_kp(self):
         return GS.kp.util.board_layer.is_copper_layer(self._id)
 
     def is_top(self):
@@ -306,7 +341,42 @@ def __str__(self):
         return "{} ('{}' {})".format(self.layer, self.description, self.suffix)
 
     @staticmethod
-    def id2def_name(id):
-        if GS.ki5:
-            return GS.ID_2_DEFAULT_NAME[id]
-        return GS.pn.LayerName(id) if GS.pn is not None else GS.kp.canonical_name(id)
+    def id2def_name_k5(id):
+        return GS.ID_2_DEFAULT_NAME[id]
+
+    @staticmethod
+    def id2def_name_k6(id):
+        return GS.pn.LayerName(id)
+
+    @staticmethod
+    def id2def_name_kp(id):
+        return GS.kp.canonical_name(id)
+
+
+if GS.pn is not None:
+    Layer._set_pcb_layers = Layer._set_pcb_layers_pn
+    Layer._get_copper = Layer._get_copper_pn
+    Layer._get_inners = Layer._get_inners_pn
+    Layer._get_outers = Layer._get_outers_pn
+    Layer._set_plot_layers = Layer._set_plot_layers_pn
+    Layer.is_copper = Layer.is_copper_pn
+    if GS.ki9:
+        Layer._get_technical = Layer._get_technical_pn_k9
+        Layer._get_user = Layer._get_user_pn_k9
+    else:
+        Layer._get_technical = Layer._get_technical_pn_k6
+        Layer._get_user = Layer._get_user_pn_k6
+    if GS.ki5:
+        Layer.id2def_name = Layer.id2def_name_k5
+    else:
+        Layer.id2def_name = Layer.id2def_name_k6
+else:
+    Layer._set_pcb_layers = Layer._set_pcb_layers_kp
+    Layer._get_copper = Layer._get_copper_kp
+    Layer._get_inners = Layer._get_inners_kp
+    Layer._get_outers = Layer._get_outers_kp
+    Layer._get_technical = Layer._get_technical_kp
+    Layer._get_user = Layer._get_user_kp
+    Layer._set_plot_layers = Layer._set_plot_layers_kp
+    Layer.is_copper = Layer.is_copper_kp
+    Layer.id2def_name = Layer.id2def_name_kp

tests/test_plot/test_gerber.py

@@ -118,6 +118,14 @@ def test_gerber_inner_wrong(test_dir):
     ctx.clean_up()
 
 
+def test_gerber_inner_wrong_2(test_dir):
+    prj = 'good-project'
+    ctx = context.TestContext(test_dir, prj, 'gerber_inner_wrong_2')
+    ctx.run(PLOT_ERROR)
+    assert ctx.search_err('is not valid for this board')
+    ctx.clean_up()
+
+
 def compose_fname(dir, prefix, layer, suffix, ext='gbr'):
     return os.path.join(dir, prefix+'-'+layer+suffix+'.'+ext)