stipple.hpp

Go to the documentation of this file.

/*
 *                            COPYRIGHT
 *
 *  Stipple, cross hatching add-in for gEDA PCB
 *  Copyright (C) 2015 Charles Repetti
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
*/

//
// \image html PercentFill.png

#ifndef STIPPLE_HPP_
#define STIPPLE_HPP_

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

extern "C" {
#include "config.h"
#include "global.h"
#include "data.h"
#include "macro.h"
#include "create.h"
#include "remove.h"
#include "hid.h"
#include "error.h"
#include "rtree.h"
#include "polygon.h"
#include "polyarea.h"
#include "assert.h"
#include "strflags.h"
#include "find.h"
#include "misc.h"
#include "draw.h"
#include "undo.h"
}

#include <gtk/gtk.h>

#include <iostream>
#include <fstream>
#include <string>
#include <iterator>
#include <algorithm>
#include <deque>

#include <boost/math/constants/constants.hpp>
#include <boost/polygon/polygon.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <boost/regex.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/geometry/geometries/geometries.hpp>

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>

#define foreach BOOST_FOREACH

#define BoxTypePtr      BoxType *

#define LayerTypePtr    LayerType *

#define PointTypePtr    PointType *

#define PolygonTypePtr  PolygonType *

namespace gtl = boost::polygon;

using namespace std;
using namespace gtl;
using namespace boost::polygon::operators;

typedef gtl::polygon_with_holes_data<int>                       b_polygon;

typedef gtl::polygon_traits<b_polygon>::point_type              b_point;

typedef gtl::polygon_with_holes_traits<b_polygon>::hole_type    b_hole;

typedef std::vector<b_polygon>                                  b_polygon_set;

const double PI = boost::math::constants::pi<double>();

const string component_perimeter = "comp-perim";

const string component_stipple = "comp-stipple";

const string solder_perimeter = "solder-perim";

const string solder_stipple = "solder-stipple";

const double NanometerToMil = 3.93700787E10-5;

const Coord MilToNanometer = 254;

extern bool Cancel;

extern Coord
    ComponentTrace,
    SolderTrace,
    ComponentPitch,
    SolderPitch;

enum MakeLayers_t
{ MakeTopLayer, MakeBottomLayer, MakeBothLayers, MakeSelected, MakeDelete };

extern MakeLayers_t MakeLayers;

extern vector<string> MakeLayerNames;

void ParameterDialog();

void MakeAllLayers();

void LayerFactory(int i);

void Log(const char *format, ...);

#define POLYGON_LP(layer) do {                                      \
  GList *__iter, *__next;                                           \
  Cardinal n = 0;                                                   \
  for (__iter = (layer)->Polygon, __next = g_list_next (__iter);    \
       __iter != NULL;                                              \
       __iter = __next, __next = g_list_next (__iter), n++) {       \
    PolygonType *polygon = (PolygonType *)__iter->data;

#define POLYGONPOINT_LP(polygon) do {           \
    int             n;                          \
    PointTypePtr    point;                      \
    for (n = (int)((polygon)->PointN) - 1; n != -1; n--)    \
    {                                           \
        point = &(polygon)->Points[n]

#define VIA_LP(top) do {                                            \
  GList *__iter, *__next;                                           \
  Cardinal n = 0;                                                   \
  for (__iter = (top)->Via, __next = g_list_next (__iter);          \
       __iter != NULL;                                              \
       __iter = __next, __next = g_list_next (__iter), n++) {       \
    PinType *via = (PinType *)__iter->data;

#define LINE_LP(layer) do {                                         \
  GList *__iter, *__next;                                           \
  Cardinal n = 0;                                                   \
  for (__iter = (layer)->Line, __next = g_list_next (__iter);       \
       __iter != NULL;                                              \
       __iter = __next, __next = g_list_next (__iter), n++) {       \
    LineType *line = (LineType *)__iter->data;

#define ELEMENT_LP(top) do {                                        \
  GList *__iter, *__next;                                           \
  Cardinal n = 0;                                                   \
  for (__iter = (top)->Element, __next = g_list_next (__iter);      \
       __iter != NULL;                                              \
       __iter = __next, __next = g_list_next (__iter), n++) {       \
    ElementType *element = (ElementType *)__iter->data;

#define PAD_LP(element) do {                                        \
  GList *__iter, *__next;                                           \
  Cardinal n = 0;                                                   \
  for (__iter = (element)->Pad, __next = g_list_next (__iter);      \
       __iter != NULL;                                              \
       __iter = __next, __next = g_list_next (__iter), n++) {       \
    PadType *pad = (PadType *)__iter->data;

#define PIN_LP(element) do {                                        \
  GList *__iter, *__next;                                           \
  Cardinal n = 0;                                                   \
  for (__iter = (element)->Pin, __next = g_list_next (__iter);      \
       __iter != NULL;                                              \
       __iter = __next, __next = g_list_next (__iter), n++) {       \
    PinType *pin = (PinType *)__iter->data;

#endif /* STIPPLE_HPP_ */

class StippledPolygon
{
    public:

        b_polygon Outline;

        b_polygon_set CutOuts;

        b_polygon_set Overlays;
};

class StippleDialog  {

private:

    long ReadDefault(string File, string Key, Coord Default);

    bool ReadDefaults();

public:

    static void ButtonPress( GtkButton *widget, gpointer data );

    static void KeyPress( GtkButton *widget, gpointer data );

    static gboolean UpdateProgress(GtkProgressBar *PB);

    static void Progress(float progress, string Message);

    static int PercentFill(double Trace, double Pitch);

    void ParameterDialog();

};

class Layer
{

protected:

    double Angle2D(
            int X0, int Y0,
            int X1, int Y1);

    LayerTypePtr FindLayerByName(string Name);

    b_polygon MakeCircularOverlay(
            Coord x, Coord y, Coord Radius, int SegmentCount = 24);

    b_polygon MakeRectangularOverlay(
            Coord x0, Coord y0, Coord x1, Coord y1, Coord Thickness);

    b_polygon MakeRoundedRectangle(
            int x0, int y0, int x1, int y1, int Radius, int Smoothness);

    b_polygon_set ReadTemplatePolygons(LayerTypePtr layer);

    b_polygon_set LoadPCB(string LayerName, Coord Trace);

    vector<StippledPolygon> CalculateStipples(
            LayerTypePtr layer, b_polygon_set Union,
            Coord Trace, Coord Pitch, int i);

    void InsertToPCB(
            LayerTypePtr layer, vector<StippledPolygon> StippledPolygons);

public:

    void MakeLayer(int i);
};