Also a rationalization of text polygon generators, with the "standard"
version inherited from BOARD_ITEM now giving the bounding box. This
requires callers who want the (much) more expensive stroke-based one
to call it explicitly (and brings PCB_TEXT in line with the was FP_TEXT
already was.
Fixes https://gitlab.com/kicad/code/kicad/issues/6525
The copper zones are checking for any point being outside the board
as they will have already been broken in to islands either entirely
outside or entirely inside the board. Not so for non-copper zones.
However, non-copper zones are *already* trimmed to the board edges,
so we just need to avoid using the above faulty assumption.
Fixes https://gitlab.com/kicad/code/kicad/issues/5811
These objects can now be used in advanced DRC rules and
not just for keeping things out. Also remove the restriction
that at least one of the "basic" keepout rules must be set,
so that these areas can be used for more advanced rules.
1) better load-balancing for deferred zones
2) sort zones by priority before filling
3) retire BOARD::GetZoneList() which had a horrible performance profile
4) implement a zone bounding box cache
5) better checks for IsCancelled() so long fills can be exited
Fixes https://gitlab.com/kicad/code/kicad/issues/5738
The first attempt to address this which added back in the zones
with a 0 netcode didn't pick up those with a netcode which weren't
isolated (ie: because there were unplaced footprints outside the
board edges).
The new system gives up on trying to adjust the insulated island
list and just makes a second pass.
Fixes https://gitlab.com/kicad/code/kicad/issues/5658
Also fixes a bunch of naming issues, primarily with lowercase for
protected variables, but also some for consistency with other parts
of the code.
Also changes the zone fill radio buttons in Board Setup to be more
generic referring to legacy vs. current, and to have tooltips.
Fixes https://gitlab.com/kicad/code/kicad/issues/5583
1) For a while now we've been using a calculated seg count from a given
maxError, and a correction factor to push the radius out so that all
the error is outside the arc/circle. However, the second calculation
(which pre-dates the first) is pretty much just the inverse of the first
(and yields nothing more than maxError back). This is particularly
sub-optimal given the cost of trig functions.
2) There are a lot of old optimizations to reduce segcounts in certain
situations, someting that our error-based calculation compensates for
anyway. (Smaller radii need fewer segments to meet the maxError
condition.) But perhaps more importantly we now surface maxError in the
UI and we don't really want to call it "Max deviation except when it's
not".
3) We were also clamping the segCount twice: once in the calculation
routine and once in most of it's callers. Furthermore, the caller
clamping was inconsistent (both in being done and in the clamping
value). We now clamp only in the calculation routine.
4) There's no reason to use the correction factors in the 3Dviewer;
it's just a visualization and whether the polygonization error is
inside or outside the shape isn't really material.
5) The arc-correction-disabling stuff (used for solder mask layer) was
somewhat fragile in that it depended on the caller to turn it back on
afterwards. It's now only exposed as a RAII object which automatically
cleans up when it goes out of scope.
6) There were also bugs in a couple of the polygonization routines where
we'd accumulate round-off error in adding up the segments and end up with
an overly long last segment (which of course would voilate the error
max). This was the cause of the linked bug and also some issues with vias
that we had fudged in the past with extra clearance.
Fixes https://gitlab.com/kicad/code/kicad/issues/5567
This is required in case there are DRC Rules that are matching against
the properties. It also allows any local clearance overrides to take
effect.
Fixes https://gitlab.com/kicad/code/kicad/issues/5468
This introduces layer handling to a lot of the geometry routines.
Many of them don't do much with it now, but it does help multi-layer
zones and will help when padstacks are implemented.
This option removes copper layers from pads and vias where they are not
connected to other board elements. This allows the inner layers to be
more closely routed if the via landing pad is not needed.
Fixes https://gitlab.com/kicad/code/kicad/issues/1835
The shape cache gets reset by the zone fill algorithm. This needs to be
cleaned before multiple threads are created and cannot be modified when
threading.
Fixes https://gitlab.com/kicad/code/kicad/issues/4723
There were a lot of plotters, exporters, etc. that were rolling their
own implementations.
This also introduces a lazily-built set of SHAPE objects for doing
collision detection and some forms of rendering (and later DRC).
to calculate thermal clearance (antipad size) for pads having the same netcode
as the zone, the net clearance has no meaning
(net clearance between object of the same net is 0)
and the zone_clearance can be set to 0 (i.e. use the netclass clearance).
Therefore use the antipad clearance (thermal clearance) or the zone_clearance if bigger.
- Fix non optimal shape of solid polygons after inflate transform.
- Add a small extra clearance ((2 microns) when creating clearance areas
(especially, convert arc to polygons create small differences)
- Add a small threshold (1 micron) in drc test distances to avoid false positives
- fix a minor issue in TransformOvalToPolygon that created sometimes a not perfect shape
Fixes#3812https://gitlab.com/kicad/code/kicad/issues/3812
* Split up the thirdparty code into the thirdparty folder (#3637)
* Create a new kimath static library containing all the math functions
This is part of cleaning the build system for #1906.
This is the first step to allowing non-segments in the line chain.
External routines cannot be allowed to change the line chain without
going through the internal routines. To accomplish this, we remove the
Vertex() and Point() access routines and only leave the const versions.
Transformations are given for both points as well as the chain itself.
pad size is sometimes smaller than the zone minimal width.
So, to avoid strange and incorrect results, do not create the stubs in
thermal relief when the pad size is smaller than the zone minimal width.
This margin is mandatory to avoid incorrect polygons in Gerber files:
due to the fact Gerber units can be 10 nm (and Gerbview internal unit is also 10nm), valid polygons
can be converted to non valid (self intersecting for instance) by coordinates truncation.
This is a known problem in Gerber files (not specific to Gerber format)
Fixes: lp:1847737
https://bugs.launchpad.net/kicad/+bug/1847737
Setting stub width to a ridiculous large value (for instance 100 times the pad size) creates strange and broken shapes,
and obviously stubs cannot be built.
Ensure also the thermal shape is inside the zone boundary (because the algo adds areas this was previously possible)
Fixes: lp:1837559
https://bugs.launchpad.net/kicad/+bug/1837559
This unifies the zone refill across architecture into the tool-based
architecture. Also provides ZONE_FILLER-based progress managment for
tools.
(cherry picked from commit be9cd98cb1)
It's too complicated trying to keep everything smaller or larger by
half the pen width, and some things like spoke-end-detection need the
actual outline anyway.
The thermal spokes are anchored at the pad anchor. They may or may
not make sense, depending on the pad shape. It's up to the author
to move the anchor around as necessary or to not use thermals.
This places the arc approximation setting in the kicad_pcb file and uses
it for all parts of the board rendering where arcs are converted to
segments. This allows the user to customize their speed vs. accuracy
tradeoff. The default setting of maximum error of 0.005mm is acceptable
for small boards on moderate systems.
This removes the remaining hard-coded segments counts and replaces them
with the relative error calculation where the segments per arc is
determined by the maximum error we allow (smaller arcs = fewer segments)
1 - For debug purposes, the code to fill non copper zones was disabled and the copper zone code was uses instead.
It creates issues with pad clearance areas, because a non copper zone has no clearance areas.
2 - The non copper zone dialog had no option to set the outline smoothing option.
Unfortunately, this parameter was inherited from the last edited copper zone.
And therefore the non copper zone can have a non wanted outline smoothing option.
This option is now added to the dialog.
Fixes: lp:1826952
https://bugs.launchpad.net/kicad/+bug/1826952
Give the user the option of cancelling a file open if there are
segment zones; otherwise they're converted to polygon fills.
Fixes: lp:1823087
* https://bugs.launchpad.net/kicad/+bug/1823087
For legacy boards, the setting is picked up from the board outline
thickness. If the board outline has mixed thicknesses, then the
max is used and a warning is displayed.
Fixes: lp:1797787
* https://bugs.launchpad.net/kicad/+bug/1797787
the filled areas can use a hatch pattern (crossing lines) using square holes.
The zone filler removes too small holes (truncated holes) from hatch pattern.
It avoid to create small holes when a hole pattern is truncated by the filled area base shape.
Commit 6006703798 fixed a crash but broke the filled zones changes detection.
Filled zones were always seen as not up to date due to the fact the filled areas were cleared too early.
The up to date detection is also optimized: the old filled polygons are no longer stored.
Instead of, the MD5_HASH is calculated and stored before clearing the filled polygons.
Previously, in many cases the selected zone was refilled on exit selection, even if the zone was not modified.
This is annoying, because the zone fill can be really time consuming, and cannot be called without a good reason.
Now the refilling is made only if a zone parameter is actually modified.
Removing existing fills will prevent re-drawing invalid polygons before
they are ready. This seems to happen on Macs more easily due to redraw
timing.
Fixes: lp:1819553
* https://bugs.launchpad.net/kicad/+bug/1819553
This was due to the stub removal tests if a stub end is outside a solid area to remove it.
There is a corner case: is the stub end is exactly on a solid area outline extra segment
created by Fracture() used in calculations.
The stub removal tests are now made before fracturing.
Fixes: lp:1819317
https://bugs.launchpad.net/kicad/+bug/1819317
No net zones, by definition, do not connect to any other element.
Therefore, the entire net is an island and should not be removed by the
knockout section
Fixes: lp:1811239
* https://bugs.launchpad.net/kicad/+bug/1811239
Non-connected zones are, by definition, not connected, therefore, we
should not knock out thermal reliefs under any case
Fixes: lp:1810989
* https://bugs.launchpad.net/kicad/+bug/1810989
Where we can get away with lower segment counts (localizing an anchor),
we keep the low-def 16 segment count. Intermediate values and values
that are visible to the user are set to high definition. Most are
simply hints to the inflation correction but where they show, the user
show see smooth lines.
Most rounding operations have been shifted to an absolute error
calculation and the ability to adjust zone segment counts has been
removed in 5.1. The remaining elements that use fixed segment counts
are either 18 (DRC) or 32 (plotting). This aligns the punchout segment
count with the higher (32) definition value
Rather than depend on proper unlocking for each exit, we move the
connectivity lock mutex into an RAII-type configuration that
automatically unlocks on exit.
This allows people to continue to use the edge-width as a proxy
for board edge clearance until we implement board edge clearance
as a real feature.
Fixes: lp:1797787
* https://bugs.launchpad.net/kicad/+bug/1797787
The evaluation of count_if resulted in a 0 or 1, leading to segment zone
fills always running on single processor and the progress bar showing
incorrect status. Likely infrequently hit as only affected segment
fills.
This is a boyscouting commit to standardize the threading of zone fills.
We do not need to join threads after their completion, instead we simply
allow them to clean up their memory without blocking the user. This
also sets the maximum number of threads that may be created to the
number of zones being filled. More than this will only leave un-used
threads being created and immediately killed.
We also include the connectivity search as a phase in the fill progress
reporter. This was the case before but did not utilize the correct
maxsize, leading to stalled progress bar.
Using Title + Message wasn't working for all the dialogs which
did substitutions in the message (which was a lot of them).
Fixes: lp:1789348
* https://bugs.launchpad.net/kicad/+bug/1789348
There are three related changes here to harden our handling of threads
in the footprint async loader.
1) Footprint async loader explicitly aborts any remaining loader threads
on exit.
2) We protect the thread join by a mutex
3) We do not pause during no-wait routines
m_Zone is a fully deprecated list of SEG_ZONE items (similar to TRACK), used to fill copper zones in *very old* boards.
it is even unlikely there are still boards that use them.
So it should be removed one day.
On OpenMP single core systems only the first thread launched. It means
that only the UI updating thread was running, without the one
responsible for actual computation. It is fixed by enforcing at least
two threads.
The calculation was made too early, before removing insulated islands.
Note: filling zones with segments is an old option, not very useful:
using only polygons has never created issues in gerber files.
Jeff Young
Jon Evans
Roberto Fernandez Bautista
Ian McInerney
jean-pierre charras
Seth Hillbrand
Mark Roszko
Ross Schlaikjer
Seth Hillbrand
Maciej Suminski
Tomasz Włostowski