export-geda-pcb.c

Go to the documentation of this file.

/*
 * gEDA - GNU Electronic Design Automation
 * This file is a part of Gerbv.
 *
 *   Copyright (C) 2014 Sergey Alyoshin
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA 02111 USA
 */
 
#include "gerbv.h"
#include "common.h"
 
#include <glib/gstdio.h>
 
static void
write_line(FILE *fd, gerbv_net_t *net, double thick,
              double dx_p, double dy_m, const char *sflags)
{
       dx_p = COORD2MILS(dx_p);
       dy_m = COORD2MILS(dy_m);
 
       fprintf(fd, "\tLine[%.2fmil %.2fmil %.2fmil %.2fmil "
                     "%.2fmil %.2fmil \"%s\"]\n",
                     dx_p + COORD2MILS(net->stop_x),
                     dy_m - COORD2MILS(net->stop_y),
                     dx_p + COORD2MILS(net->start_x),
                     dy_m - COORD2MILS(net->start_y),
                     COORD2MILS(thick), 100.0, sflags);
}
 
static void
write_element_with_pad(FILE *fd, gerbv_net_t *net, double thick,
              double dx_p, double dy_m, const char *sflags)
{
       double xc, yc;
       static unsigned int element_num = 1;
 
       dx_p = COORD2MILS(dx_p);
       dy_m = COORD2MILS(dy_m);
 
       xc = COORD2MILS(net->stop_x + net->start_x)/2;
       yc = COORD2MILS(net->stop_y + net->start_y)/2;
 
       fprintf(fd, "Element[\"\" \"\" \"pad%d\" \"\" "
                     "%.2fmil %.2fmil 0mil 0mil 0 100 \"\"]\n(\n",
                     element_num++, dx_p + xc, dy_m - yc);
       fprintf(fd, "\tPad[%.2fmil %.2fmil %.2fmil %.2fmil "
                     "%.2fmil 0mil %.2fmil "
                     "\"%s\" \"%s\" \"%s\"]\n)\n",
                     xc - COORD2MILS(net->stop_x),
                     yc - COORD2MILS(net->stop_y),
                     xc - COORD2MILS(net->start_x),
                     yc - COORD2MILS(net->start_y),
                     COORD2MILS(thick),   /* Thickness */
                     COORD2MILS(thick),   /* Mask */
                     "1",                 /* Name */
                     "1",                 /* Number */
                     sflags);             /* String flags */
}
 
static void
write_polygon(FILE *fd, gerbv_net_t *net,
              double dx_p, double dy_m, const char *sflags)
{
       dx_p = COORD2MILS(dx_p);
       dy_m = COORD2MILS(dy_m);
 
       fprintf(fd, "\tPolygon(\"%s\")\n\t(", sflags);
       net = net->next;
 
       unsigned int i = 0;
       while (net != NULL
              && net->interpolation != GERBV_INTERPOLATION_PAREA_END) {
              if (net->aperture_state == GERBV_APERTURE_STATE_ON) {
                     fprintf(fd, "%s[%.2fmil %.2fmil] ",
                            !(i%5)? "\n\t\t": "",
                            dx_p + COORD2MILS(net->stop_x),
                            dy_m - COORD2MILS(net->stop_y));
                            i++;
              }
              net = net->next;
       }
 
       fprintf(fd, "\n\t)\n");
}
 
gboolean
gerbv_export_geda_pcb_file_from_image(const gchar *file_name,
              gerbv_image_t *input_img,
              gerbv_user_transformation_t *trans)
{
       gerbv_aperture_t *apert;
       gerbv_image_t *img;
       gerbv_net_t *net;
       double dx_p, dy_m;
       double thick, len;
       FILE *fd;
 
       if ((fd = g_fopen(file_name, "w")) == NULL) {
              GERB_MESSAGE(_("Can't open file for writing: %s"), file_name);
              return FALSE;
       }
 
       /* Output decimals as dots for all locales */
       setlocale(LC_NUMERIC, "C");
 
       /* Duplicate the image, cleaning it in the process */
       img = gerbv_image_duplicate_image(input_img, trans);
 
       /* Header */
       fputs("# Generated with gerbv\n\n", fd);
       fputs("FileVersion[20091103]\n", fd);
 
       dx_p = (img->info->max_x - img->info->min_x) - img->info->min_x;
       dy_m = 2*(img->info->max_y - img->info->min_y) + img->info->min_y;
 
       /* Make board size is 3 times more than Gerber size */
       fprintf(fd, "PCB[\"%s\" %.2fmil %.2fmil]\n",
                     img->info->name,
                     3*COORD2MILS(img->info->max_x - img->info->min_x),
                     3*COORD2MILS(img->info->max_y - img->info->min_y));
 
       fputs("Grid[1000.000000 0.0000 0.0000 0]\n", fd);
 
       /* Write all apertures as elements with single pad, before layer
        * definition */
       for (net = img->netlist; net != NULL; net = net->next) {
              apert = img->aperture[net->aperture];
              if (!apert)
                     continue;
 
              /* Skip polygon, it will be written in layer section */
              if (net->interpolation == GERBV_INTERPOLATION_PAREA_START) {
                     /* Skip to the end for polygon */
                     do {
                            net = net->next;
                     } while (net != NULL && net->interpolation !=
                                   GERBV_INTERPOLATION_PAREA_END);
                     continue;
              }
 
              switch (net->aperture_state) {
              case GERBV_APERTURE_STATE_FLASH:
                     switch (apert->type) {
                     case GERBV_APTYPE_CIRCLE:
                            /* Set start to stop coords for Circle flash */
                            net->start_x = net->stop_x;
                            net->start_y = net->stop_y;
                            write_element_with_pad(fd, net,
                                          apert->parameter[0],
                                          dx_p, dy_m, "");
                            break;
                     case GERBV_APTYPE_OVAL:
                     case GERBV_APTYPE_RECTANGLE:
 
                            if (apert->parameter[0] > apert->parameter[1]) {
                                   /* Horizontal */
                                   len = apert->parameter[0];
                                   thick = apert->parameter[1];
 
                                   net->start_x = net->stop_x - len/2 +
                                                        thick/2;
                                   net->stop_x += len/2 - thick/2;
                                   net->start_y = net->stop_y;
                            } else {
                                   /* Vertical */
                                   len = apert->parameter[1];
                                   thick = apert->parameter[0];
 
                                   net->start_x = net->stop_x;
                                   net->start_y = net->stop_y - len/2 +
                                                        thick/2;
                                   net->stop_y += len/2 - thick/2;
                            }
 
                            write_element_with_pad(fd, net, thick,
                                   dx_p, dy_m,
                                   (apert->type == GERBV_APTYPE_RECTANGLE)?
                                          "square": "");
                            break;
                     default:
/* TODO */
                            GERB_COMPILE_WARNING(
                                   "%s:%d: aperture type %d is "
                                   "not yet supported",
                                   __func__, __LINE__,
                                   apert->type);
                            break;
                     }
                     break;
              case GERBV_APERTURE_STATE_ON:
                     /* Will be done in layer section */
                     break;
              default:
/* TODO */
                     GERB_COMPILE_WARNING(
                                   "%s:%d: aperture type %d is "
                                   "not yet supported",
                                   __func__, __LINE__,
                                   apert->type);
                     break;
              }
       }
 
       /* Write all lines in layer definition */
       fputs("Layer(1 \"top\")\n(\n", fd);
 
       for (net = img->netlist; net != NULL; net = net->next) {
              apert = img->aperture[net->aperture];
              if (!apert)
                     continue;
 
              if (net->interpolation == GERBV_INTERPOLATION_PAREA_START) {
                     write_polygon(fd, net, dx_p, dy_m, "clearpoly");
 
                     /* Skip to the end for polygon */
                     do {
                            net = net->next;
                     } while (net != NULL && net->interpolation !=
                                   GERBV_INTERPOLATION_PAREA_END);
                     continue;
              }
 
              switch (net->aperture_state) {
              case GERBV_APERTURE_STATE_FLASH:
                     /* Already done in elements section */
                     break;
 
              case GERBV_APERTURE_STATE_ON:
                     /* Trace (or cut slot in drill file) */
                     switch (apert->type) {
                     case GERBV_APTYPE_CIRCLE:
                            write_line(fd, net, apert->parameter[0],
                                          dx_p, dy_m, "clearline");
                            break;
                     default:
                            GERB_COMPILE_WARNING(
                                          "%s:%d: aperture type %d is "
                                          "not yet supported",
                                          __func__, __LINE__,
                                          apert->type);
                            break;
                     }
                     break;
              default:
                     GERB_COMPILE_WARNING(
                                   "%s:%d: aperture state %d type %d is "
                                   "not yet supported",
                                   __func__, __LINE__,
                                   net->aperture_state, apert->type);
                     break;
              }
       }
 
       fputs(")\n", fd);    /* End of Layer 1 */
 
       /* Necessary layer */
       fputs("Layer(7 \"outline\")\n(\n)\n", fd);
 
       gerbv_destroy_image (img);
       fclose(fd);
 
       setlocale(LC_NUMERIC, "");  /* Return to the default locale */
 
       return TRUE;
}