src/thermal.c

   1 /* $Id$ */
   2
   3 /*
   4  *                            COPYRIGHT
   5  *
   6  *  PCB, interactive printed circuit board design
   7  *  Copyright (C) 1994,1995,1996,2004,2006 Thomas Nau
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  *  Contact addresses for paper mail and Email:
  24  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  25  *  Thomas.Nau@rz.uni-ulm.de
  26  *
  27  */
  28
  29 /* this file, thermal.c was written by and is
  30  * (C) Copyright 2006, harry eaton
  31  */
  32
  33 /* negative thermal finger polygons
  34  */
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include <stdlib.h>
  41 #include <stdarg.h>
  42 #ifdef HAVE_STRING_H
  43 #include <string.h>
  44 #endif
  45 #include <assert.h>
  46 #include <setjmp.h>
  47 #include <memory.h>
  48 #include <ctype.h>
  49 #include <signal.h>
  50 #include <sys/param.h>
  51 #include <sys/stat.h>
  52 #include <sys/types.h>
  53 #include <math.h>
  54 #ifdef HAVE_UNISTD_H
  55 #include <unistd.h>
  56 #endif
  57 #ifdef HAVE_PWD_H
  58 #include <pwd.h>
  59 #endif
  60
  61 #include "global.h"
  62
  63 #include "create.h"
  64 #include "data.h"
  65 #include "draw.h"
  66 #include "error.h"
  67 #include "misc.h"
  68 #include "move.h"
  69 #include "polygon.h"
  70 #include "rtree.h"
  71 #include "thermal.h"
  72 #include "undo.h"
  73
  74 #ifdef HAVE_LIBDMALLOC
  75 #include <dmalloc.h>
  76 #endif
  77
  78 RCSID ("$Id$");
  79
  80 static PCBTypePtr pcb;
  81
  82 struct cent
  83 {
  84   LocationType x, y;
  85   BDimension s, c;
  86   char style;
  87   POLYAREA *p;
  88 };
  89
  90 static POLYAREA *
  91 diag_line (LocationType X, LocationType Y, BDimension l, BDimension w,
  92            bool rt)
  93 {
  94   PLINE *c;
  95   Vector v;
  96   BDimension x1, x2, y1, y2;
  97
  98   if (rt)
  99     {
 100       x1 = (l - w) * M_SQRT1_2;
 101       x2 = (l + w) * M_SQRT1_2;
 102       y1 = x1;
 103       y2 = x2;
 104     }
 105   else
 106     {
 107       x2 = -(l - w) * M_SQRT1_2;
 108       x1 = -(l + w) * M_SQRT1_2;
 109       y1 = -x1;
 110       y2 = -x2;
 111     }
 112
 113   v[0] = X + x1;
 114   v[1] = Y + y2;
 115   if ((c = poly_NewContour (v)) == NULL)
 116     return NULL;
 117   v[0] = X - x2;
 118   v[1] = Y - y1;
 119   poly_InclVertex (c->head.prev, poly_CreateNode (v));
 120   v[0] = X - x1;
 121   v[1] = Y - y2;
 122   poly_InclVertex (c->head.prev, poly_CreateNode (v));
 123   v[0] = X + x2;
 124   v[1] = Y + y1;
 125   poly_InclVertex (c->head.prev, poly_CreateNode (v));
 126   return ContourToPoly (c);
 127 }
 128
 129 static POLYAREA *
 130 square_therm (PinTypePtr pin, Cardinal style)
 131 {
 132   POLYAREA *p, *p2;
 133   PLINE *c;
 134   Vector v;
 135   BDimension d, in, out;
 136
 137   switch (style)
 138     {
 139     case 1:
 140       d = pcb->ThermScale * pin->Clearance * M_SQRT1_2;
 141       out = (pin->Thickness + pin->Clearance) / 2;
 142       in = pin->Thickness / 2;
 143       /* top (actually bottom since +y is down) */
 144       v[0] = pin->X - in + d;
 145       v[1] = pin->Y + in;
 146       if ((c = poly_NewContour (v)) == NULL)
 147         return NULL;
 148       v[0] = pin->X + in - d;
 149       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 150       v[0] = pin->X + out - d;
 151       v[1] = pin->Y + out;
 152       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 153       v[0] = pin->X - out + d;
 154       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 155       p = ContourToPoly (c);
 156       /* right */
 157       v[0] = pin->X + in;
 158       v[1] = pin->Y + in - d;
 159       if ((c = poly_NewContour (v)) == NULL)
 160         return NULL;
 161       v[1] = pin->Y - in + d;
 162       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 163       v[0] = pin->X + out;
 164       v[1] = pin->Y - out + d;
 165       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 166       v[1] = pin->Y + out - d;
 167       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 168       p2 = ContourToPoly (c);
 169       p->f = p2;
 170       p2->b = p;
 171       /* left */
 172       v[0] = pin->X - in;
 173       v[1] = pin->Y - in + d;
 174       if ((c = poly_NewContour (v)) == NULL)
 175         return NULL;
 176       v[1] = pin->Y + in - d;
 177       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 178       v[0] = pin->X - out;
 179       v[1] = pin->Y + out - d;
 180       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 181       v[1] = pin->Y - out + d;
 182       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 183       p2 = ContourToPoly (c);
 184       p->f->f = p2;
 185       p2->b = p->f;
 186       /* bottom (actually top since +y is down) */
 187       v[0] = pin->X + in - d;
 188       v[1] = pin->Y - in;
 189       if ((c = poly_NewContour (v)) == NULL)
 190         return NULL;
 191       v[0] = pin->X - in + d;
 192       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 193       v[0] = pin->X - out + d;
 194       v[1] = pin->Y - out;
 195       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 196       v[0] = pin->X + out - d;
 197       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 198       p2 = ContourToPoly (c);
 199       p->f->f->f = p2;
 200       p2->f = p;
 201       p2->b = p->f->f;
 202       p->b = p2;
 203       return p;
 204     case 4:
 205       {
 206         LineType l;
 207         l.Flags = NoFlags ();
 208         d = pin->Thickness / 2 - pcb->ThermScale * pin->Clearance;
 209         out = pin->Thickness / 2 + pin->Clearance / 4;
 210         in = pin->Clearance / 2;
 211         /* top */
 212         l.Point1.X = pin->X - d;
 213         l.Point2.Y = l.Point1.Y = pin->Y + out;
 214         l.Point2.X = pin->X + d;
 215         p = LinePoly (&l, in);
 216         /* right */
 217         l.Point1.X = l.Point2.X = pin->X + out;
 218         l.Point1.Y = pin->Y - d;
 219         l.Point2.Y = pin->Y + d;
 220         p2 = LinePoly (&l, in);
 221         p->f = p2;
 222         p2->b = p;
 223         /* bottom */
 224         l.Point1.X = pin->X - d;
 225         l.Point2.Y = l.Point1.Y = pin->Y - out;
 226         l.Point2.X = pin->X + d;
 227         p2 = LinePoly (&l, in);
 228         p->f->f = p2;
 229         p2->b = p->f;
 230         /* left */
 231         l.Point1.X = l.Point2.X = pin->X - out;
 232         l.Point1.Y = pin->Y - d;
 233         l.Point2.Y = pin->Y + d;
 234         p2 = LinePoly (&l, in);
 235         p->f->f->f = p2;
 236         p2->b = p->f->f;
 237         p->b = p2;
 238         p2->f = p;
 239         return p;
 240       }
 241     default:                   /* style 2 and 5 */
 242       d = 0.5 * pcb->ThermScale * pin->Clearance;
 243       if (style == 5)
 244         d += d;
 245       out = (pin->Thickness + pin->Clearance) / 2;
 246       in = pin->Thickness / 2;
 247       /* topright */
 248       v[0] = pin->X + in;
 249       v[1] = pin->Y + in;
 250       if ((c = poly_NewContour (v)) == NULL)
 251         return NULL;
 252       v[1] = pin->Y + d;
 253       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 254       if (style == 2)
 255         {
 256           v[0] = pin->X + out;
 257           poly_InclVertex (c->head.prev, poly_CreateNode (v));
 258         }
 259       else
 260         frac_circle (c, v[0] + pin->Clearance / 4, v[1], v, 2);
 261       v[1] = pin->Y + in;
 262       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 263       /* pivot 1/4 circle to next point */
 264       frac_circle (c, pin->X + in, pin->Y + in, v, 4);
 265       v[0] = pin->X + d;
 266       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 267       if (style == 2)
 268         {
 269           poly_InclVertex (c->head.prev, poly_CreateNode (v));
 270           v[1] = pin->Y + in;
 271           poly_InclVertex (c->head.prev, poly_CreateNode (v));
 272         }
 273       else
 274         frac_circle (c, v[0], v[1] - pin->Clearance / 4, v, 2);
 275       p = ContourToPoly (c);
 276       /* bottom right */
 277       v[0] = pin->X + in;
 278       v[1] = pin->Y - d;
 279       if ((c = poly_NewContour (v)) == NULL)
 280         return NULL;
 281       v[1] = pin->Y - in;
 282       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 283       v[0] = pin->X + d;
 284       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 285       if (style == 2)
 286         {
 287           v[1] = pin->Y - out;
 288           poly_InclVertex (c->head.prev, poly_CreateNode (v));
 289         }
 290       else
 291         frac_circle (c, v[0], v[1] - pin->Clearance / 4, v, 2);
 292       v[0] = pin->X + in;
 293       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 294       /* pivot 1/4 circle to next point */
 295       frac_circle (c, pin->X + in, pin->Y - in, v, 4);
 296       v[1] = pin->Y - d;
 297       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 298       if (style == 5)
 299         frac_circle (c, v[0] - pin->Clearance / 4, v[1], v, 2);
 300       p2 = ContourToPoly (c);
 301       p->f = p2;
 302       p2->b = p;
 303       /* bottom left */
 304       v[0] = pin->X - d;
 305       v[1] = pin->Y - in;
 306       if ((c = poly_NewContour (v)) == NULL)
 307         return NULL;
 308       v[0] = pin->X - in;
 309       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 310       v[1] = pin->Y - d;
 311       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 312       if (style == 2)
 313         {
 314           v[0] = pin->X - out;
 315           poly_InclVertex (c->head.prev, poly_CreateNode (v));
 316         }
 317       else
 318         frac_circle (c, v[0] - pin->Clearance / 4, v[1], v, 2);
 319       v[1] = pin->Y - in;
 320       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 321       /* pivot 1/4 circle to next point */
 322       frac_circle (c, pin->X - in, pin->Y - in, v, 4);
 323       v[0] = pin->X - d;
 324       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 325       if (style == 5)
 326         frac_circle (c, v[0], v[1] + pin->Clearance / 4, v, 2);
 327       p2 = ContourToPoly (c);
 328       p->f->f = p2;
 329       p2->b = p->f;
 330       /* top left */
 331       v[0] = pin->X - d;
 332       v[1] = pin->Y + out;
 333       if ((c = poly_NewContour (v)) == NULL)
 334         return NULL;
 335       v[0] = pin->X - in;
 336       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 337       /* pivot 1/4 circle to next point (x-out, y+in) */
 338       frac_circle (c, pin->X - in, pin->Y + in, v, 4);
 339       v[1] = pin->Y + d;
 340       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 341       if (style == 2)
 342         {
 343           v[0] = pin->X - in;
 344           poly_InclVertex (c->head.prev, poly_CreateNode (v));
 345         }
 346       else
 347         frac_circle (c, v[0] + pin->Clearance / 4, v[1], v, 2);
 348       v[1] = pin->Y + in;
 349       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 350       v[0] = pin->X - d;
 351       poly_InclVertex (c->head.prev, poly_CreateNode (v));
 352       if (style == 5)
 353         frac_circle (c, v[0], v[1] + pin->Clearance / 4, v, 2);
 354       p2 = ContourToPoly (c);
 355       p->f->f->f = p2;
 356       p2->f = p;
 357       p2->b = p->f->f;
 358       p->b = p2;
 359       return p;
 360     }
 361 }
 362
 363 static POLYAREA *
 364 oct_therm (PinTypePtr pin, Cardinal style)
 365 {
 366   POLYAREA *p, *p2, *m;
 367   BDimension t = 0.5 * pcb->ThermScale * pin->Clearance;
 368   BDimension w = pin->Thickness + pin->Clearance;
 369
 370   p = OctagonPoly (pin->X, pin->Y, w);
 371   p2 = OctagonPoly (pin->X, pin->Y, pin->Thickness);
 372   /* make full clearance ring */
 373   poly_Boolean_free (p, p2, &m, PBO_SUB);
 374   switch (style)
 375     {
 376     default:
 377     case 1:
 378       p = diag_line (pin->X, pin->Y, w, t, true);
 379       poly_Boolean_free (m, p, &p2, PBO_SUB);
 380       p = diag_line (pin->X, pin->Y, w, t, false);
 381       poly_Boolean_free (p2, p, &m, PBO_SUB);
 382       return m;
 383     case 2:
 384       p = RectPoly (pin->X - t, pin->X + t, pin->Y - w, pin->Y + w);
 385       poly_Boolean_free (m, p, &p2, PBO_SUB);
 386       p = RectPoly (pin->X - w, pin->X + w, pin->Y - t, pin->Y + t);
 387       poly_Boolean_free (p2, p, &m, PBO_SUB);
 388       return m;
 389       /* fix me add thermal style 4 */
 390     case 5:
 391       {
 392         BDimension t = pin->Thickness / 2;
 393         POLYAREA *q;
 394         /* cheat by using the square therm's rounded parts */
 395         p = square_therm (pin, style);
 396         q = RectPoly (pin->X - t, pin->X + t, pin->Y - t, pin->Y + t);
 397         poly_Boolean_free (p, q, &p2, PBO_UNITE);
 398         poly_Boolean_free (m, p2, &p, PBO_ISECT);
 399         return p;
 400       }
 401     }
 402 }
 403
 404 /* ThermPoly returns a POLYAREA having all of the clearance that when
 405  * subtracted from the plane create the desired thermal fingers.
 406  * Usually this is 4 disjoint regions.
 407  *
 408  */
 409 POLYAREA *
 410 ThermPoly (PCBTypePtr p, PinTypePtr pin, Cardinal laynum)
 411 {
 412   ArcType a;
 413   POLYAREA *pa, *arc;
 414   Cardinal style = GET_THERM (laynum, pin);
 415
 416   if (style == 3)
 417     return NULL;                /* solid connection no clearance */
 418   pcb = p;
 419   if (TEST_FLAG (SQUAREFLAG, pin))
 420     return square_therm (pin, style);
 421   if (TEST_FLAG (OCTAGONFLAG, pin))
 422     return oct_therm (pin, style);
 423   /* must be circular */
 424   switch (style)
 425     {
 426     case 1:
 427     case 2:
 428       {
 429         POLYAREA *m;
 430         BDimension t = (pin->Thickness + pin->Clearance) / 2;
 431         BDimension w = 0.5 * pcb->ThermScale * pin->Clearance;
 432         pa = CirclePoly (pin->X, pin->Y, t);
 433         arc = CirclePoly (pin->X, pin->Y, pin->Thickness / 2);
 434         /* create a thin ring */
 435         poly_Boolean_free (pa, arc, &m, PBO_SUB);
 436         /* fix me needs error checking */
 437         if (style == 2)
 438           {
 439             pa = RectPoly (pin->X - t, pin->X + t, pin->Y - w, pin->Y + w);
 440             poly_Boolean_free (m, pa, &arc, PBO_SUB);
 441             pa = RectPoly (pin->X - w, pin->X + w, pin->Y - t, pin->Y + t);
 442           }
 443         else
 444           {
 445             pa = diag_line (pin->X, pin->Y, t, w, true);
 446             poly_Boolean_free (m, pa, &arc, PBO_SUB);
 447             pa = diag_line (pin->X, pin->Y, t, w, false);
 448           }
 449         poly_Boolean_free (arc, pa, &m, PBO_SUB);
 450         return m;
 451       }
 452
 453
 454     default:
 455       a.X = pin->X;
 456       a.Y = pin->Y;
 457       a.Height = a.Width = pin->Thickness / 2 + pin->Clearance / 4;
 458       a.Thickness = 1;
 459       a.Clearance = pin->Clearance / 2;
 460       a.Flags = NoFlags ();
 461       a.Delta =
 462         90 -
 463         (a.Clearance * (1. + 2. * pcb->ThermScale) * 180) / (M_PI * a.Width);
 464       a.StartAngle = 90 - a.Delta / 2 + (style == 4 ? 0 : 45);
 465       pa = ArcPoly (&a, a.Clearance);
 466       if (!pa)
 467         return NULL;
 468       a.StartAngle += 90;
 469       arc = ArcPoly (&a, a.Clearance);
 470       if (!arc)
 471         return NULL;
 472       pa->f = arc;
 473       arc->b = pa;
 474       a.StartAngle += 90;
 475       arc = ArcPoly (&a, a.Clearance);
 476       if (!arc)
 477         return NULL;
 478       pa->f->f = arc;
 479       arc->b = pa->f;
 480       a.StartAngle += 90;
 481       arc = ArcPoly (&a, a.Clearance);
 482       if (!arc)
 483         return NULL;
 484       pa->b = arc;
 485       pa->f->f->f = arc;
 486       arc->b = pa->f->f;
 487       arc->f = pa;
 488       pa->b = arc;
 489       return pa;
 490     }
 491 }