Horizon
board.hpp
1 #pragma once
2 #include "block/block.hpp"
3 #include "board_hole.hpp"
4 #include "board_package.hpp"
5 #include "board_rules.hpp"
6 #include "clipper/clipper.hpp"
7 #include "common/dimension.hpp"
8 #include "common/hole.hpp"
9 #include "common/junction.hpp"
10 #include "common/layer_provider.hpp"
11 #include "common/polygon.hpp"
12 #include "common/keepout.hpp"
13 #include "common/pdf_export_settings.hpp"
14 #include "fab_output_settings.hpp"
15 #include "nlohmann/json_fwd.hpp"
16 #include "plane.hpp"
17 #include "pool/pool.hpp"
18 #include "track.hpp"
19 #include "util/uuid.hpp"
20 #include "util/warning.hpp"
21 #include "via.hpp"
22 #include "via_padstack_provider.hpp"
23 #include "connection_line.hpp"
24 #include "step_export_settings.hpp"
25 #include "pnp_export_settings.hpp"
26 #include "airwire.hpp"
27 #include "included_board.hpp"
28 #include "board_panel.hpp"
29 #include "common/picture.hpp"
30 #include <fstream>
31 #include <map>
32 #include <vector>
33 
34 namespace horizon {
35 using json = nlohmann::json;
36 
37 class BoardColors {
38 public:
39  BoardColors();
40  Color solder_mask;
41  Color substrate;
42 };
43 
44 class Board : public ObjectProvider, public LayerProvider {
45 private:
46  // unsigned int update_nets();
47  void propagate_nets();
48  std::map<int, Layer> layers;
49 
50  void delete_dependants();
51  void vacuum_junctions();
52 
53 public:
54  Board(const UUID &uu, const json &, Block &block, Pool &pool, ViaPadstackProvider &vpp);
55  static Board new_from_file(const std::string &filename, Block &block, Pool &pool, ViaPadstackProvider &vpp);
56  Board(const UUID &uu, Block &block);
57 
58  void expand(bool careful = false);
59  void expand_packages();
60 
61  Board(const Board &brd);
62  Board(shallow_copy_t sh, const Board &brd);
63  void operator=(const Board &brd) = delete;
64  void update_refs();
65  void update_airwires(bool fast = false, const std::set<UUID> &nets = {});
66  void disconnect_package(BoardPackage *pkg);
67 
68  void smash_package(BoardPackage *pkg);
69  void copy_package_silkscreen_texts(BoardPackage *dest, const BoardPackage *src);
70  void unsmash_package(BoardPackage *pkg);
71  void smash_package_silkscreen_graphics(BoardPackage *pkg);
72  void smash_package_outline(BoardPackage &pkg);
73  void smash_panel_outline(BoardPanel &panel);
74 
75  Junction *get_junction(const UUID &uu) override;
76  Polygon *get_polygon(const UUID &uu) override;
77  const std::map<int, Layer> &get_layers() const override;
78  void set_n_inner_layers(unsigned int n);
79  unsigned int get_n_inner_layers() const;
80  void update_plane(Plane *plane, const class CanvasPatch *ca = nullptr,
81  const class CanvasPads *ca_pads = nullptr); // when ca is given, patches will be read from it
82  void update_planes();
83  std::vector<KeepoutContour> get_keepout_contours() const;
84  std::pair<Coordi, Coordi> get_bbox() const;
85  void update_pdf_export_settings(PDFExportSettings &settings);
86  std::map<const BoardPackage *, PnPRow> get_PnP(const PnPExportSettings &settings) const;
87 
88 
89  UUID uuid;
90  Block *block;
91  std::string name;
92  std::map<UUID, Polygon> polygons;
93  std::map<UUID, BoardHole> holes;
94  std::map<UUID, BoardPackage> packages;
95  std::map<UUID, Junction> junctions;
96  std::map<UUID, Track> tracks;
97  std::map<UUID, Via> vias;
98  std::map<UUID, Text> texts;
99  std::map<UUID, Line> lines;
100  std::map<UUID, Arc> arcs;
101  std::map<UUID, Plane> planes;
102  std::map<UUID, Keepout> keepouts;
103  std::map<UUID, Dimension> dimensions;
104  std::map<UUID, ConnectionLine> connection_lines;
105  std::map<UUID, IncludedBoard> included_boards;
106  std::map<UUID, BoardPanel> board_panels;
107  std::map<UUID, Picture> pictures;
108 
109  std::vector<Warning> warnings;
110 
111  BoardRules rules;
112  FabOutputSettings fab_output_settings;
113 
114  std::map<UUID, std::list<Airwire>> airwires;
115 
116  class StackupLayer {
117  public:
118  StackupLayer(int l, const json &j);
119  StackupLayer(int l);
120  json serialize() const;
121  int layer;
122  uint64_t thickness = 0.035_mm;
123  uint64_t substrate_thickness = .1_mm;
124  };
125  std::map<int, StackupLayer> stackup;
126 
127  BoardColors colors;
128  PDFExportSettings pdf_export_settings;
129  STEPExportSettings step_export_settings;
130  PnPExportSettings pnp_export_settings;
131 
132  ClipperLib::Paths obstacles;
133  ClipperLib::Path track_path;
134 
135  enum ExpandFlags {
136  EXPAND_ALL = 0xff,
137  EXPAND_PROPAGATE_NETS = (1 << 0),
138  EXPAND_AIRWIRES = (1 << 1),
139  EXPAND_PACKAGES = (1 << 2)
140  };
141 
142  ExpandFlags expand_flags = EXPAND_ALL;
143  std::set<UUID> packages_expand;
144  std::set<UUID> airwires_expand;
145 
146  json serialize() const;
147  void save_pictures(const std::string &dir) const;
148  void load_pictures(const std::string &dir);
149 
150 private:
151  unsigned int n_inner_layers = 0;
152  ClipperLib::Paths get_thermals(class Plane *plane, const class CanvasPads *ca) const;
153  void flip_package_layer(int &layer) const;
154  Board(const Board &brd, CopyMode copy_mode);
155 };
156 } // namespace horizon
horizon::CanvasPads
Definition: canvas_pads.hpp:7
horizon::Polygon
Polygon used in Padstack, Package and Board for specifying filled Regions.
Definition: polygon.hpp:27
horizon::BoardPanel
Definition: board_panel.hpp:5
nlohmann::json
basic_json<> json
default JSON class
Definition: json_fwd.hpp:61
horizon::BoardColors
Definition: board.hpp:37
libzip::uint64_t
zip_uint64_t uint64_t
zip_uint64_t_t typedef.
Definition: zip.hpp:108
horizon::BoardRules
Definition: board_rules.hpp:21
horizon::CanvasPatch
Definition: canvas_patch.hpp:6
horizon::Board
Definition: board.hpp:44
horizon::shallow_copy_t
Definition: common.hpp:267
horizon::ViaPadstackProvider
Definition: via_padstack_provider.hpp:13
horizon::Color
Definition: common.hpp:217
horizon::Block
A block is one level of hierarchy in the netlist.
Definition: block.hpp:26
horizon::LayerProvider
Definition: layer_provider.hpp:7
horizon::BoardPackage
Definition: board_package.hpp:17
horizon::Board::StackupLayer
Definition: board.hpp:116
horizon::STEPExportSettings
Definition: step_export_settings.hpp:10
horizon::FabOutputSettings
Definition: fab_output_settings.hpp:10
horizon::Junction
A Junction is a point in 2D-Space.
Definition: junction.hpp:25
nlohmann::basic_json
a class to store JSON values
Definition: json.hpp:165
horizon::UUID
This class encapsulates a UUID and allows it to be uses as a value type.
Definition: uuid.hpp:16
horizon::Pool
Stores objects (Unit, Entity, Symbol, Part, etc.) from the pool.
Definition: pool.hpp:21
horizon::PnPExportSettings
Definition: pnp_export_settings.hpp:11
horizon::ObjectProvider
Interface for classes that store objects identified by UUID (e.g. Line or Junction)
Definition: object_provider.hpp:10
horizon::Plane
Definition: plane.hpp:39
horizon::PDFExportSettings
Definition: pdf_export_settings.hpp:9