board: add blind and buried vias

changelog: New Features/Board Editor: add support for blind and buried vias

Author: carrotIndustries

Diff for: Makefile

@@ -50,6 +50,7 @@ SRC_COMMON = \
 	src/pool/padstack.cpp\
 	src/common/polygon.cpp\
 	src/util/polygon_arc_removal_proxy.cpp\
+	src/util/layer_range.cpp\
 	src/common/hole.cpp\
 	src/common/shape.cpp\
 	src/common/patch_type_names.cpp\

Diff for: scripts/app_versions.yml

@@ -18,6 +18,7 @@ versions:
     16: support relative paths for including boards
     17: save plane fragements to a separate file
     18: increase maximum number of inner layers to 8
+    19: add blind and buried vias
   schematic:
     1: add custom values on symbols
     2: add hierarchy

Diff for: src/board/board.cpp

@@ -12,6 +12,7 @@
 #include "util/bbox_accumulator.hpp"
 #include "util/polygon_arc_removal_proxy.hpp"
 #include <filesystem>
+#include <range/v3/view.hpp>
 
 namespace horizon {
 
@@ -42,7 +43,7 @@ const LutEnumStr<Board::OutputFormat> Board::output_format_lut = {
         {"odb", Board::OutputFormat::ODB},
 };
 
-static const unsigned int app_version = 18;
+static const unsigned int app_version = 19;
 
 unsigned int Board::get_app_version()
 {
@@ -465,19 +466,25 @@ void Board::update_junction_connections()
         it.connected_vias.clear();
         it.connected_net_ties.clear();
         it.has_via = false;
-        it.needs_via = false;
+        it.required_span = {};
     }
     for (auto &[uu, it] : tracks) {
         for (const auto &it_ft : {it.from, it.to}) {
             if (it_ft.is_junc()) {
                 auto &ju = *it_ft.junc;
                 ju.connected_tracks.push_back(uu);
+                ju.required_span.merge(it.layer);
                 ju.layer.merge(it.layer);
-                if (ju.layer.is_multilayer())
-                    ju.needs_via = true;
             }
         }
     }
+    for (auto &[uu, it] : net_ties) {
+        for (auto &it_ft : {&it.from, &it.to}) {
+            (*it_ft)->connected_net_ties.push_back(uu);
+            (*it_ft)->required_span.merge(it.layer);
+            (*it_ft)->layer.merge(it.layer);
+        }
+    }
 
     JunctionUtil::update(lines);
     JunctionUtil::update(arcs);
@@ -490,15 +497,9 @@ void Board::update_junction_connections()
     }
     for (auto &[uu, it] : vias) {
         it.junction->has_via = true;
-        it.junction->layer = LayerRange(BoardLayers::TOP_COPPER, BoardLayers::BOTTOM_COPPER);
+        it.junction->layer = it.span;
         it.junction->connected_vias.push_back(uu);
     }
-    for (auto &[uu, it] : net_ties) {
-        for (auto &it_ft : {&it.from, &it.to}) {
-            (*it_ft)->connected_net_ties.push_back(uu);
-            (*it_ft)->layer.merge(it.layer);
-        }
-    }
 }
 
 unsigned int Board::get_n_inner_layers() const
@@ -739,7 +740,7 @@ void Board::expand_some()
         ParameterSet ps_hole = it.second.parameter_set;
         ps_hole.emplace(ParameterID::HOLE_SOLDER_MASK_EXPANSION, params.hole_solder_mask_expansion);
         it.second.padstack.apply_parameter_set(ps_hole);
-        it.second.padstack.expand_inner(n_inner_layers);
+        it.second.padstack.expand_inner(n_inner_layers, BoardLayers::layer_range_through);
         if (it.second.padstack.type == Padstack::Type::HOLE && it.second.net == nullptr) {
             warnings.emplace_back(it.second.placement.shift, "PTH hole without net");
         }
@@ -753,9 +754,21 @@ void Board::expand_some()
         }
     }
 
-    for (const auto &it : junctions) {
-        if (it.second.needs_via && !it.second.has_via) {
-            warnings.emplace_back(it.second.position, "Junction needs via");
+    for (const auto &[uu, it] : junctions) {
+        if (it.required_span.is_multilayer() && !it.has_via) {
+            warnings.emplace_back(it.position, "Junction needs via");
+        }
+    }
+    for (const auto &[uu, it] : vias) {
+        // check that via's span is sufficient for required span
+
+        // merge required span and actual span
+        auto sp = it.junction->required_span;
+        sp.merge(it.span);
+
+        // if the resulting span is not the via's span it must have gotten extended by the required span
+        if (sp != it.span) {
+            warnings.emplace_back(it.junction->position, "Junction's via has insufficient span");
         }
     }
 
@@ -1486,4 +1499,13 @@ Board::Outline Board::get_outline_and_errors() const
     return get_outline(true);
 }
 
+std::set<LayerRange> Board::get_drill_spans() const
+{
+    // only vias can add non-through spans
+    auto spans = vias | ranges::views::values | ranges::views::transform([](const auto &x) { return x.span; })
+                 | ranges::to<std::set>();
+    spans.insert(BoardLayers::layer_range_through);
+    return spans;
+}
+
 } // namespace horizon

Diff for: src/board/board.hpp

@@ -184,6 +184,8 @@ class Board : public ObjectProvider, public LayerProvider {
     Outline get_outline() const;
     Outline get_outline_and_errors() const;
 
+    std::set<LayerRange> get_drill_spans() const;
+
     std::string board_directory; // for resolving relative paths in included boards
 
 private:

Diff for: src/board/board_junction.hpp

@@ -8,7 +8,7 @@ class BoardJunction : public Junction {
     using Junction::Junction;
 
     uuid_ptr<class Net> net = nullptr;
-    bool needs_via = false;
+    LayerRange required_span;
     bool has_via = false;
     std::vector<UUID> connected_vias;
     std::vector<UUID> connected_tracks;

Diff for: src/board/board_layers.cpp

@@ -90,4 +90,6 @@ const std::vector<int> &BoardLayers::get_layers()
 
 const unsigned int BoardLayers::max_inner_layers = 8;
 
+const LayerRange BoardLayers::layer_range_through{BoardLayers::TOP_COPPER, BoardLayers::BOTTOM_COPPER};
+
 } // namespace horizon

Diff for: src/board/board_layers.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <string>
 #include <vector>
+#include "util/layer_range.hpp"
 
 namespace horizon {
 class BoardLayers {
@@ -34,11 +35,18 @@ class BoardLayers {
         BOTTOM_NOTES = -200
     };
 
+    static const LayerRange layer_range_through;
+
     static bool is_copper(int l)
     {
         return l <= TOP_COPPER && l >= BOTTOM_COPPER;
     }
 
+    static bool is_copper(const LayerRange &l)
+    {
+        return is_copper(l.start()) || is_copper(l.end());
+    }
+
     static bool is_silkscreen(int l)
     {
         return l == TOP_SILKSCREEN || l == BOTTOM_SILKSCREEN;

Diff for: src/board/board_package.cpp

@@ -5,6 +5,7 @@
 #include "pool/ipool.hpp"
 #include "board.hpp"
 #include "util/util.hpp"
+#include "board_layers.hpp"
 
 namespace horizon {
 
@@ -138,7 +139,7 @@ bool BoardPackage::update_package(const Board &brd)
 
     placement.mirror = flip;
     for (auto &it2 : package.pads) {
-        it2.second.padstack.expand_inner(brd.get_n_inner_layers());
+        it2.second.padstack.expand_inner(brd.get_n_inner_layers(), BoardLayers::layer_range_through);
     }
 
     if (flip) {

Diff for: src/board/board_rules_check.cpp

@@ -13,7 +13,6 @@
 #include "util/util.hpp"
 #include "board_rules_check_util.hpp"
 #include <iostream>
-#include "board_rules_check_util.hpp"
 
 namespace horizon {
 
@@ -363,13 +362,7 @@ RulesCheckResult BoardRules::check_clearance_copper_keepout(const Board &brd, Ru
     status_cb("Getting patches");
     auto rules = get_rules_sorted<RuleClearanceCopperKeepout>();
     auto &c = cache.get_cache<RulesCheckCacheBoardImage>();
-    std::set<int> layers;
     const auto &patches = c.get_canvas().get_patches();
-    for (const auto &it : patches) { // collect copper layers
-        if (brd.get_layers().count(it.first.layer) && brd.get_layers().at(it.first.layer).copper) {
-            layers.emplace(it.first.layer);
-        }
-    }
     auto keepout_contours = brd.get_keepout_contours();
     auto n_patches = patches.size();
     auto n_keepouts = keepout_contours.size();
@@ -390,7 +383,7 @@ RulesCheckResult BoardRules::check_clearance_copper_keepout(const Board &brd, Ru
                 status_cb(ss.str());
             }
             if (BoardLayers::is_copper(it.first.layer)
-                && (it.first.layer == keepout->polygon->layer || keepout->all_cu_layers)
+                && (it.first.layer.overlaps(keepout->polygon->layer) || keepout->all_cu_layers)
                 && keepout->patch_types_cu.count(it.first.type)) {
 
                 const Net *net = it.first.net ? &brd.block->nets.at(it.first.net) : nullptr;
@@ -434,9 +427,9 @@ RulesCheckResult BoardRules::check_clearance_copper_keepout(const Board &brd, Ru
                         }
                         e.location = acc.get();
                         e.comment = patch_type_names.at(it.first.type) + "(" + (net ? net->name : "") + ") on layer"
-                                    + brd.get_layers().at(it.first.layer).name + " near keepout";
+                                    + brd.get_layer_name(it.first.layer) + " near keepout";
                         e.error_polygons = {ite};
-                        e.layers.insert(it.first.layer);
+                        e.add_layer_range(brd, it.first.layer);
                     }
                 }
             }
@@ -454,77 +447,77 @@ RulesCheckResult BoardRules::check_clearance_same_net(const Board &brd, RulesChe
     status_cb("Getting patches");
     auto rules = get_rules_sorted<RuleClearanceSameNet>();
     auto &c = cache.get_cache<RulesCheckCacheBoardImage>();
-    std::set<int> layers;
     const auto &patches = c.get_canvas().get_patches();
-    for (const auto &it : patches) { // collect copper layers
-        if (brd.get_layers().count(it.first.layer) && brd.get_layers().at(it.first.layer).copper) {
-            layers.emplace(it.first.layer);
-        }
-    }
+
     if (r.check_cancelled(cancel))
         return r;
     status_cb("Building patch pairs");
 
     static const std::set<PatchType> patch_types = {PatchType::PAD, PatchType::PAD_TH, PatchType::VIA,
                                                     PatchType::HOLE_NPTH};
-
-    for (const auto layer : layers) { // check each layer individually
-        // assemble a list of patch pairs we'll need to check
-        std::set<std::pair<CanvasPatch::PatchKey, CanvasPatch::PatchKey>> patch_pairs;
-        for (const auto &it : patches) {
-            for (const auto &it_other : patches) {
-                if (layer == it.first.layer && it.first.layer == it_other.first.layer
-                    && patch_types.count(it.first.type) && patch_types.count(it_other.first.type)
-                    && it.first.type != it_other.first.type && it.first.net == it_other.first.net) {
-                    std::pair<CanvasPatch::PatchKey, CanvasPatch::PatchKey> k = {it.first, it_other.first};
-                    auto k2 = k;
-                    std::swap(k2.first, k2.second);
-                    if (patch_pairs.count(k) == 0 && patch_pairs.count(k2) == 0) {
-                        patch_pairs.emplace(k);
-                    }
+    std::set<std::pair<CanvasPatch::PatchKey, CanvasPatch::PatchKey>> patch_pairs;
+
+
+    // assemble a list of patch pairs we'll need to check
+    for (const auto &it : patches) {
+        for (const auto &it_other : patches) {
+            if (it.first.layer.overlaps(it_other.first.layer) && patch_types.count(it.first.type)
+                && patch_types.count(it_other.first.type) && it.first.type != it_other.first.type
+                && it.first.net == it_other.first.net) {
+                std::pair<CanvasPatch::PatchKey, CanvasPatch::PatchKey> k = {it.first, it_other.first};
+                auto k2 = k;
+                std::swap(k2.first, k2.second);
+                if (patch_pairs.count(k) == 0 && patch_pairs.count(k2) == 0) {
+                    patch_pairs.emplace(k);
                 }
             }
-            if (r.check_cancelled(cancel))
-                return r;
         }
+        if (r.check_cancelled(cancel))
+            return r;
+    }
 
-        for (const auto &[p1, p2] : patch_pairs) {
-            if (r.check_cancelled(cancel))
-                return r;
-            const Net *net = p1.net ? &brd.block->nets.at(p1.net) : nullptr;
-            const auto &rule = get_clearance_same_net(net, layer);
-            auto clearance = rule.get_clearance(p1.type, p2.type);
-            if (clearance >= 0) {
-                // expand p1 patch by clearance
-                ClipperLib::ClipperOffset ofs;
-                ofs.ArcTolerance = 10e3;
-                ofs.AddPaths(patches.at(p1), ClipperLib::jtRound, ClipperLib::etClosedPolygon);
-                ClipperLib::Paths paths_ofs;
-                ofs.Execute(paths_ofs, clearance);
-
-                // intersect expanded and this patch
-                ClipperLib::Clipper clipper;
-                clipper.AddPaths(paths_ofs, ClipperLib::ptClip, true);
-                clipper.AddPaths(patches.at(p2), ClipperLib::ptSubject, true);
-                ClipperLib::Paths errors;
-                clipper.Execute(ClipperLib::ctIntersection, errors, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
+    for (const auto &[p1, p2] : patch_pairs) {
+        if (r.check_cancelled(cancel))
+            return r;
 
-                // no intersection: no clearance violation
-                if (errors.size() > 0) {
-                    for (const auto &ite : errors) {
-                        r.errors.emplace_back(RulesCheckErrorLevel::FAIL);
-                        auto &e = r.errors.back();
-                        e.has_location = true;
-                        Accumulator<Coordi> acc;
-                        for (const auto &ite2 : ite) {
-                            acc.accumulate({ite2.X, ite2.Y});
-                        }
-                        e.location = acc.get();
-                        e.comment = patch_type_names.at(p1.type) + " near " + patch_type_names.at(p2.type) + " "
-                                    + get_net_name(net) + " on layer " + brd.get_layers().at(layer).name;
-                        e.error_polygons = {ite};
-                        e.layers.insert(layer);
+        const Net *net = p1.net ? &brd.block->nets.at(p1.net) : nullptr;
+
+        const auto layer_isect = p1.layer.intersection(p2.layer).value();
+
+        auto clearance =
+                find_clearance(*this, &BoardRules::get_clearance_same_net, brd.get_layers_for_range(layer_isect),
+                               std::forward_as_tuple(net), std::forward_as_tuple(p1.type, p2.type));
+
+        if (clearance >= 0) {
+            // expand p1 patch by clearance
+            ClipperLib::ClipperOffset ofs;
+            ofs.ArcTolerance = 10e3;
+            ofs.AddPaths(patches.at(p1), ClipperLib::jtRound, ClipperLib::etClosedPolygon);
+            ClipperLib::Paths paths_ofs;
+            ofs.Execute(paths_ofs, clearance);
+
+            // intersect expanded and this patch
+            ClipperLib::Clipper clipper;
+            clipper.AddPaths(paths_ofs, ClipperLib::ptClip, true);
+            clipper.AddPaths(patches.at(p2), ClipperLib::ptSubject, true);
+            ClipperLib::Paths errors;
+            clipper.Execute(ClipperLib::ctIntersection, errors, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
+
+            // no intersection: no clearance violation
+            if (errors.size() > 0) {
+                for (const auto &ite : errors) {
+                    r.errors.emplace_back(RulesCheckErrorLevel::FAIL);
+                    auto &e = r.errors.back();
+                    e.has_location = true;
+                    Accumulator<Coordi> acc;
+                    for (const auto &ite2 : ite) {
+                        acc.accumulate({ite2.X, ite2.Y});
                     }
+                    e.location = acc.get();
+                    e.comment = patch_type_names.at(p1.type) + " near " + patch_type_names.at(p2.type) + " "
+                                + get_net_name(net) + " on layer " + brd.get_layer_name(layer_isect);
+                    e.error_polygons = {ite};
+                    e.add_layer_range(brd, layer_isect);
                 }
             }
         }