gEDA Project Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
//Translations of this page are also available in the following languages:// [[pcb-projects.ru|Русский]]

==== PCB Layout Editor ====

== Plow feature ==

A "plow" feature where the line tool shoves existing traces aside
preserving the design rules when possible.

''Difficulty = 4-5''

== Fast snap rounding Algorithm ==

Implement a fast snap rounding algorithm and resolve the case where
inserted point cause self-intersection.

PCB uses an integer coordinate system for all of its objects. The polygon
clipping code computes all points of intersection between two
non-self-intersecting contours (among many other things it does), but these
points of intersection must also have integer coordinates.

A snap-rounding algorithm replaces two segments that intersect at other than
their end points with four segments where each has an end point on an
integer coordinate near the original (non-integer) intersection. Because
this rounding operation on the point of intersection can change the slopes
of the four segments compare to that of the original two, it raises the
possibility that new intersections between the replacement segments and
other segments of the contours occur that did not exist with the original
segments. The snap rounding algorithm needs to produce a collection of
segments where all intersections occur at segment end points having integer
coordinates. The existing code in pcb does this already, but it uses a
theoretically slow algorithm, compared to others that are known, such as:

 "Improved output-sensitive snap rounding," John Hershberger, Proceedings of
the 22nd annual symposium on Computational geometry, 2006, pp 357-366.
 http://doi.acm.org/10.1145/1137856.1137909

Algorithms described by de Berg, or Goodrich or Halperin, or Hobby would
probably also be better than what we currently have implemented.

In addition, there are rare-but-real degenerate situations where the snap
rounding results in one (or both) contours having a self-intersection that
did not exist before. This self-intersection is fatal to our polygon
clipping code. We do not know if the snap rounding algorithms in the
literature deal with this issue or not, but if they do not, we need to
develop a variant algorithm that does, whether done by judicious choice of
the rounding points that are created, or a post-processing step that
eliminates the self-intersection with minimal geometric distortion to the
original contours.

''Difficulty = 4-5''

== Snapping enhancements == 

There are a number of possible enhancements related to crosshair snapping that could improve usability. For example, being able to reorder the snapping priority (what objects are snapped to before others), disabling certain objects from being snapped to, changing the radius at which a snap occurs, and others.

Ideas for how the snapping system should work are being collected here: [[Snapping in pcb]]

== Auto-routed drawing tool ==

Basically with this tool, you would click on a starting point, then drag the
crosshair to some other (typically intermediate point), possibly on another
layer and an auto-routing tool would show a prospective path to that point
(meeting design rules and style requirements). If you didn't like the
offered path, you could hit a key to see a more expensive candidate, or a
different key to (back up) to a less expensive candidate. The prospective
route would dynamically change to reach the crosshair end-point as the
crosshair is moved. It would disappear if no path could be found. Clicking
would place the prospective path as copper and anchor a new starting point
for the tool (much like the line tool does now).

''Difficulty = 5''

== IPC Footprint Calculator ==

Build a footprint calculator that can take the IPC rules and produce a pcb footprint. Preferably write this in a way where the core program is independent of a GUI so that you can script it for generating entire large families of footprints or hook it up to a GUI of choice (lesstif, gtk, maybe even cgi). Would require the purchase of IPC-7351 (approximately U.S.A. $100) and verifying that one is allowed to produce such a calculator.

''Difficulty = 2''

== Recently loaded file list ==

Presently pcb does not present a list of recently loaded files in the file menu. It would be nice if pcb kept track of the last few files a user loaded. This is a common feature found in other programs.

''Difficulty = 1''

==== User Experience (UX) Improvements ====


== Update the User Manual ==

In 1997, Richard Stallman wrote: “The biggest deficiency in free operating systems is not in the software — it is the lack of good free manuals that we can include in these systems.”

  * Include a chapter on the Topological router in User Manual.
  * Include DJ's Getting Started in the User Manual.
  * Extend Getting Started for both autorouter and topological router.
  * Add more step-by-step examples for existing exporters:
    * Usage of Nelma.
    * Usage of GSvit.
    * Usage of Blind and buried vias.
    * Unify and combine the READMEs.

== i18n / l10n ==

  * Get more translations/translators --> better and more language translations.
  * Update the Dutch translation ?
  * Update the French translations ?
  * Update the Cyrrilic translations ?
  * Use Launchpad for common translations.
  * Check on what should be translatable strings.
  * Check on plural forms in exotic languages (Japanese, etc).
  * Respect "Right-To-Left" reading users (Arabic, GUI layouts ?).

== Netlists ==

  * Layout vs netlist/schematic check or just trust the "import schematic" netlist (ERC).
  * Rebuilding a netlist from scratch, based on connectivity (copper layers).

== Routing ==

  * Respect the "outline", "route" and non-copper layers with the autorouter.
  * Respect the "outline", "route" and non-copper layers with the toporouter.
  * Add via placement to the toporouter.
  * Respect keepouts.
  * Importing routing style and other data from the netlist (if available).

== Other platforms, GUI's and dependencies ==

  * Migrate to GNOME/GTK3 … when ?
  * Migrate to GNOME/GTK4 … when ?
  * HTML5 (+java) GUI (web based pcb layout designer).
  * Android GUI for tablets and smart-phones.
  * QT GUI ?
  * wxWidgets for native Microsoft windows look-and-feel UX ?
  * Single Document Interface mode GTK UI with a separate function tear-off (lessGTK ?)
  * Multiple Document Interface mode for the GTK UI ?
  * Multiple Document Interface mode for the lesstif UI ?
  * Cygwin port for windows ?
  * W32 port with minipack ?
  * WIN32 port with a NSIS installer ?
  * Flatpak (http://flatpak.org) pcb packages for multiple linux distributions ?

== Other unsorted crazy ideas ==

  * Layer definition awareness (copper, non-copper, soldermask).
  * Editable soldermask (gang solder mask clearance … for QFP, SO, PLCC, etc. package types).
  * Grouping of elements, traces and vias.
  * Show / define solder paste.
  * Show / define IPC-356-D test points.
  * Back annotation (output).
  * Pin swapping.
  * Pinout awareness (in, out, inout, pas, pwr like in gschem).
  * Padstack definitions.
  * Layer stackup definitions.
  * Create multiple pcb executables during build time (bpcb for batch, gpcb for GTK, lpcb for lesstif).

==== Developer Experience (DX) Improvements ====

  * Travis-CI Continuous Integration for pcb on Travis (https://travis-ci.org).
  * Under the hood structural improvements.
  * Start a pcb-5.x.y development blueprint and branch "devel" ?
  * Object Oriented approach in source tree / files.
  * libpcb for helper functions or abstraction stuff ?
  * Pin/pad/traces know to which net they belong (cross reference index). 
  * Developer documentation !
    * Further Doxygenation of source files.
    * Descriptions of "state machines" within actions and other code flow.
gEDA Project Wiki

User Tools

Site Tools

Page Tools
