kicad/pcbnew/graphpcb.cpp

961 lines
24 KiB
C++
Raw Normal View History

/**
* @file graphpcb.cpp
* @brief PCB editor autorouting and "graphics" routines.
*/
#include <fctsys.h>
#include <common.h>
#include <macros.h>
#include <trigo.h>
#include <pcbcommon.h>
#include <class_board.h>
#include <class_track.h>
#include <pcbnew.h>
#include <cell.h>
#include <ar_protos.h>
int ToMatrixCoordinate( int aPhysicalCoordinate );
void TracePcbLine( int x0, int y0, int x1, int y1, int layer, int color );
void TraceArc( int ux0,
int uy0,
int ux1,
int uy1,
int ArcAngle,
int lg,
int layer,
int color,
int op_logic );
static void DrawSegmentQcq( int ux0,
int uy0,
int ux1,
int uy1,
int lg,
int layer,
int color,
int op_logic );
2012-02-19 04:02:19 +00:00
static void TraceFilledCircle( BOARD* aPcb,
int cx,
int cy,
2011-03-09 14:30:39 +00:00
int radius,
int aLayerMask,
int color,
int op_logic );
static void TraceCircle( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
int color, int op_logic );
// Macro call to update cell.
#define OP_CELL( layer, dy, dx ) \
{ \
if( layer < 0 ) \
{ \
WriteCell( dy, dx, BOTTOM, color ); \
if( Nb_Sides ) \
WriteCell( dy, dx, TOP, color ); \
} \
else \
{ \
if( layer == Route_Layer_BOTTOM ) \
WriteCell( dy, dx, BOTTOM, color ); \
if( Nb_Sides ) \
if( layer == Route_Layer_TOP ) \
WriteCell( dy, dx, TOP, color ); \
} \
}
/**
* Function ToMatrixCoordinate
* compute the coordinate in the routing matrix from the real (board) value
* @param aPhysicalCoordinate = value to convert
* @return the coordinate relative to the matrix
*/
int ToMatrixCoordinate( int aPhysicalCoordinate )
{
return aPhysicalCoordinate / Board.m_GridRouting;
}
2012-02-19 04:02:19 +00:00
void PlacePad( BOARD* aPcb, D_PAD* aPad, int color, int marge, int op_logic )
{
2007-08-23 04:28:46 +00:00
int dx, dy;
2012-02-19 04:02:19 +00:00
wxPoint shape_pos = aPad->ReturnShapePos();
2007-08-23 04:28:46 +00:00
2012-02-19 04:02:19 +00:00
dx = aPad->GetSize().x / 2;
dx += marge;
2007-08-23 04:28:46 +00:00
2012-02-19 04:02:19 +00:00
if( aPad->GetShape() == PAD_CIRCLE )
2007-08-23 04:28:46 +00:00
{
2012-02-19 04:02:19 +00:00
TraceFilledCircle( aPcb, shape_pos.x, shape_pos.y, dx,
aPad->GetLayerMask(), color, op_logic );
2007-08-23 04:28:46 +00:00
return;
}
2012-02-19 04:02:19 +00:00
dy = aPad->GetSize().y / 2;
dy += marge;
2007-08-23 04:28:46 +00:00
2012-02-19 04:02:19 +00:00
if( aPad->GetShape() == PAD_TRAPEZOID )
2007-08-23 04:28:46 +00:00
{
2012-02-19 04:02:19 +00:00
dx += abs( aPad->GetDelta().y ) / 2;
dy += abs( aPad->GetDelta().x ) / 2;
2007-08-23 04:28:46 +00:00
}
// The pad is a rectangle horizontally or vertically.
2012-02-19 04:02:19 +00:00
if( int( aPad->GetOrientation() ) % 900 == 0 )
{
// Orientation turned 90 deg.
2012-02-19 04:02:19 +00:00
if( aPad->GetOrientation() == 900 || aPad->GetOrientation() == 2700 )
{
2007-08-23 04:28:46 +00:00
EXCHG( dx, dy );
}
2012-02-19 04:02:19 +00:00
TraceFilledRectangle( aPcb, shape_pos.x - dx, shape_pos.y - dy,
2007-08-23 04:28:46 +00:00
shape_pos.x + dx, shape_pos.y + dy,
2012-02-19 04:02:19 +00:00
aPad->GetLayerMask(), color, op_logic );
2007-08-23 04:28:46 +00:00
}
else
{
2012-02-19 04:02:19 +00:00
TraceFilledRectangle( aPcb, shape_pos.x - dx, shape_pos.y - dy,
2007-08-23 04:28:46 +00:00
shape_pos.x + dx, shape_pos.y + dy,
2012-02-19 04:02:19 +00:00
(int) aPad->GetOrientation(),
aPad->GetLayerMask(), color, op_logic );
2007-08-23 04:28:46 +00:00
}
}
/* Initialize a color value, the cells included in the board area of the
* circle center cx, cy.
* Parameters:
* radius: a value add to the radius or half the score pad
* aLayerMask: layer occupied
* color: mask write in cells
* op_logic: type of writing in the cell (WRITE, OR)
2007-08-23 04:28:46 +00:00
*/
2012-02-19 04:02:19 +00:00
void TraceFilledCircle( BOARD* aPcb,
int cx,
int cy,
2011-03-09 14:30:39 +00:00
int radius,
int aLayerMask,
int color,
int op_logic )
{
2007-08-23 04:28:46 +00:00
int row, col;
int ux0, uy0, ux1, uy1;
int row_max, col_max, row_min, col_min;
int trace = 0;
float fdistmin, fdistx, fdisty;
2011-03-09 14:30:39 +00:00
void (* WriteCell)( int, int, int, MATRIX_CELL );
2007-08-23 04:28:46 +00:00
int tstwrite = 0;
int distmin;
// Determine occupied layer.
2007-08-23 04:28:46 +00:00
/* Single routing layer on bitmap and BOTTOM
* Route_Layer_B = Route_Layer_A */
2007-08-23 04:28:46 +00:00
if( aLayerMask & GetLayerMask( Route_Layer_BOTTOM ) )
trace = 1; // Trace on BOTTOM
2007-08-23 04:28:46 +00:00
if( aLayerMask & GetLayerMask( Route_Layer_TOP ) )
2007-08-23 04:28:46 +00:00
if( Nb_Sides )
trace |= 2; // Trace on TOP
2007-08-23 04:28:46 +00:00
if( trace == 0 )
return;
switch( op_logic )
2007-08-23 04:28:46 +00:00
{
default:
case WRITE_CELL:
WriteCell = SetCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_OR_CELL:
WriteCell = OrCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_XOR_CELL:
WriteCell = XorCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_AND_CELL:
WriteCell = AndCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_ADD_CELL:
WriteCell = AddCell;
break;
2007-08-23 04:28:46 +00:00
}
2012-02-19 04:02:19 +00:00
cx -= aPcb->GetBoundingBox().GetX();
cy -= aPcb->GetBoundingBox().GetY();
2007-08-23 04:28:46 +00:00
2011-03-09 14:30:39 +00:00
distmin = radius;
2007-08-23 04:28:46 +00:00
// Calculate the bounding rectangle of the circle.
2011-03-09 14:30:39 +00:00
ux0 = cx - radius;
uy0 = cy - radius;
ux1 = cx + radius;
uy1 = cy + radius;
2007-08-23 04:28:46 +00:00
// Calculate limit coordinates of cells belonging to the rectangle.
row_max = uy1 / Board.m_GridRouting;
col_max = ux1 / Board.m_GridRouting;
row_min = uy0 / Board.m_GridRouting; // if (uy0 > row_min*Board.m_GridRouting) row_min++;
col_min = ux0 / Board.m_GridRouting; // if (ux0 > col_min*Board.m_GridRouting) col_min++;
2007-08-23 04:28:46 +00:00
if( row_min < 0 )
row_min = 0;
2007-08-23 04:28:46 +00:00
if( row_max >= (Nrows - 1) )
row_max = Nrows - 1;
2007-08-23 04:28:46 +00:00
if( col_min < 0 )
col_min = 0;
2007-08-23 04:28:46 +00:00
if( col_max >= (Ncols - 1) )
col_max = Ncols - 1;
// Calculate coordinate limits of cell belonging to the rectangle.
2007-08-23 04:28:46 +00:00
if( row_min > row_max )
row_max = row_min;
2007-08-23 04:28:46 +00:00
if( col_min > col_max )
col_max = col_min;
fdistmin = (float) distmin * distmin;
for( row = row_min; row <= row_max; row++ )
{
fdisty = (float) ( cy - ( row * Board.m_GridRouting ) );
2007-08-23 04:28:46 +00:00
fdisty *= fdisty;
2007-08-23 04:28:46 +00:00
for( col = col_min; col <= col_max; col++ )
{
fdistx = (float) ( cx - ( col * Board.m_GridRouting ) );
2007-08-23 04:28:46 +00:00
fdistx *= fdistx;
if( fdistmin <= ( fdistx + fdisty ) )
2007-08-23 04:28:46 +00:00
continue;
if( trace & 1 )
WriteCell( row, col, BOTTOM, color );
2007-08-23 04:28:46 +00:00
if( trace & 2 )
WriteCell( row, col, TOP, color );
2007-08-23 04:28:46 +00:00
tstwrite = 1;
}
}
if( tstwrite )
return;
/* If no cell has been written, it affects the 4 neighboring diagonal
* (Adverse event: pad off grid in the center of the 4 neighboring
* diagonal) */
distmin = Board.m_GridRouting / 2 + 1;
fdistmin = ( (float) distmin * distmin ) * 2; // Distance to center point diagonally
2007-08-23 04:28:46 +00:00
for( row = row_min; row <= row_max; row++ )
{
fdisty = (float) ( cy - ( row * Board.m_GridRouting ) );
2007-08-23 04:28:46 +00:00
fdisty *= fdisty;
2007-08-23 04:28:46 +00:00
for( col = col_min; col <= col_max; col++ )
{
fdistx = (float) ( cx - ( col * Board.m_GridRouting ) );
2007-08-23 04:28:46 +00:00
fdistx *= fdistx;
if( fdistmin <= ( fdistx + fdisty ) )
2007-08-23 04:28:46 +00:00
continue;
if( trace & 1 )
WriteCell( row, col, BOTTOM, color );
2007-08-23 04:28:46 +00:00
if( trace & 2 )
WriteCell( row, col, TOP, color );
}
}
}
2012-02-19 04:02:19 +00:00
void TraceSegmentPcb( BOARD* aPcb, TRACK* pt_segm, int color, int marge, int op_logic )
{
int half_width;
2007-08-23 04:28:46 +00:00
int ux0, uy0, ux1, uy1;
half_width = ( pt_segm->m_Width / 2 ) + marge;
// Calculate the bounding rectangle of the segment (if H, V or Via)
2012-02-19 04:02:19 +00:00
ux0 = pt_segm->m_Start.x - aPcb->GetBoundingBox().GetX();
uy0 = pt_segm->m_Start.y - aPcb->GetBoundingBox().GetY();
ux1 = pt_segm->m_End.x - aPcb->GetBoundingBox().GetX();
uy1 = pt_segm->m_End.y - aPcb->GetBoundingBox().GetY();
2007-08-23 04:28:46 +00:00
// Test if VIA (filled circle was drawn)
if( pt_segm->Type() == PCB_VIA_T )
2007-08-23 04:28:46 +00:00
{
int mask_layer = 0;
if( pt_segm->IsOnLayer( Route_Layer_BOTTOM ) )
mask_layer = 1 << Route_Layer_BOTTOM;
if( pt_segm->IsOnLayer( Route_Layer_TOP ) )
{
if( mask_layer == 0 )
mask_layer = 1 << Route_Layer_TOP;
else
mask_layer = -1;
}
if( color == VIA_IMPOSSIBLE )
mask_layer = -1;
if( mask_layer )
2012-02-19 04:02:19 +00:00
TraceFilledCircle( aPcb, pt_segm->m_Start.x, pt_segm->m_Start.y,
half_width, mask_layer, color, op_logic );
2007-08-23 04:28:46 +00:00
return;
}
int layer = pt_segm->GetLayer();
if( color == VIA_IMPOSSIBLE )
layer = -1;
// The segment is here a straight line or a circle or an arc.:
2007-08-23 04:28:46 +00:00
if( pt_segm->m_Shape == S_CIRCLE )
{
TraceCircle( ux0, uy0, ux1, uy1, half_width, layer, color, op_logic );
2007-08-23 04:28:46 +00:00
return;
}
if( pt_segm->m_Shape == S_ARC )
{
TraceArc( ux0, uy0, ux1, uy1, pt_segm->m_Param, half_width, layer, color, op_logic );
2007-08-23 04:28:46 +00:00
return;
}
// The segment is here a line segment.
if( ( ux0 != ux1 ) && ( uy0 != uy1 ) ) // Segment tilts.
2007-08-23 04:28:46 +00:00
{
DrawSegmentQcq( ux0, uy0, ux1, uy1, half_width, layer, color, op_logic );
2007-08-23 04:28:46 +00:00
return;
}
// The segment is horizontal or vertical.
// F4EXB 051018-01
DrawSegmentQcq( ux0, uy0, ux1, uy1, half_width, layer, color, op_logic );
}
/* Draws a line, if layer = -1 on all layers
2007-08-23 04:28:46 +00:00
*/
void TracePcbLine( int x0, int y0, int x1, int y1, int layer, int color, int op_logic )
{
2007-08-23 04:28:46 +00:00
int dx, dy, lim;
int cumul, inc, il, delta;
2011-03-09 14:30:39 +00:00
void (* WriteCell)( int, int, int, MATRIX_CELL );
2007-08-23 04:28:46 +00:00
switch( op_logic )
2007-08-23 04:28:46 +00:00
{
default:
case WRITE_CELL:
WriteCell = SetCell; break;
case WRITE_OR_CELL:
WriteCell = OrCell; break;
case WRITE_XOR_CELL:
WriteCell = XorCell; break;
case WRITE_AND_CELL:
WriteCell = AndCell; break;
case WRITE_ADD_CELL:
WriteCell = AddCell; break;
}
if( x0 == x1 ) // Vertical.
2007-08-23 04:28:46 +00:00
{
if( y1 < y0 )
EXCHG( y0, y1 );
dy = y0 / Board.m_GridRouting;
lim = y1 / Board.m_GridRouting;
dx = x0 / Board.m_GridRouting;
// Clipping limits of board.
if( ( dx < 0 ) || ( dx >= Ncols ) )
2007-08-23 04:28:46 +00:00
return;
2007-08-23 04:28:46 +00:00
if( dy < 0 )
dy = 0;
2007-08-23 04:28:46 +00:00
if( lim >= Nrows )
lim = Nrows - 1;
2007-08-23 04:28:46 +00:00
for( ; dy <= lim; dy++ )
{
OP_CELL( layer, dy, dx );
}
return;
}
if( y0 == y1 ) // Horizontal
2007-08-23 04:28:46 +00:00
{
if( x1 < x0 )
EXCHG( x0, x1 );
dx = x0 / Board.m_GridRouting;
lim = x1 / Board.m_GridRouting;
dy = y0 / Board.m_GridRouting;
// Clipping limits of board.
if( ( dy < 0 ) || ( dy >= Nrows ) )
2007-08-23 04:28:46 +00:00
return;
2007-08-23 04:28:46 +00:00
if( dx < 0 )
dx = 0;
2007-08-23 04:28:46 +00:00
if( lim >= Ncols )
lim = Ncols - 1;
2007-08-23 04:28:46 +00:00
for( ; dx <= lim; dx++ )
{
OP_CELL( layer, dy, dx );
}
return;
}
// Here is some perspective: using the algorithm LUCAS.
if( abs( x1 - x0 ) >= abs( y1 - y0 ) ) // segment slightly inclined/
2007-08-23 04:28:46 +00:00
{
if( x1 < x0 )
{
EXCHG( x1, x0 ); EXCHG( y1, y0 );
}
dx = x0 / Board.m_GridRouting;
lim = x1 / Board.m_GridRouting;
dy = y0 / Board.m_GridRouting;
inc = 1;
if( y1 < y0 )
2007-08-23 04:28:46 +00:00
inc = -1;
il = lim - dx; cumul = il / 2;
delta = abs( y1 - y0 ) / Board.m_GridRouting;
2007-08-23 04:28:46 +00:00
for( ; dx <= lim; )
{
if( ( dx >= 0 ) && ( dy >= 0 ) && ( dx < Ncols ) && ( dy < Nrows ) )
2007-08-23 04:28:46 +00:00
{
OP_CELL( layer, dy, dx );
}
dx++;
cumul += delta;
2007-08-23 04:28:46 +00:00
if( cumul > il )
{
cumul -= il;
dy += inc;
2007-08-23 04:28:46 +00:00
}
}
}
else
{
if( y1 < y0 )
{
EXCHG( x1, x0 );
EXCHG( y1, y0 );
2007-08-23 04:28:46 +00:00
}
dy = y0 / Board.m_GridRouting;
lim = y1 / Board.m_GridRouting;
dx = x0 / Board.m_GridRouting;
inc = 1;
if( x1 < x0 )
2007-08-23 04:28:46 +00:00
inc = -1;
il = lim - dy; cumul = il / 2;
delta = abs( x1 - x0 ) / Board.m_GridRouting;
2007-08-23 04:28:46 +00:00
for( ; dy <= lim; )
{
if( ( dx >= 0 ) && ( dy >= 0 ) && ( dx < Ncols ) && ( dy < Nrows ) )
2007-08-23 04:28:46 +00:00
{
OP_CELL( layer, dy, dx );
}
dy++;
cumul += delta;
2007-08-23 04:28:46 +00:00
if( cumul > il )
{
cumul -= il;
dx += inc;
2007-08-23 04:28:46 +00:00
}
}
}
}
2007-08-23 04:28:46 +00:00
2012-02-19 04:02:19 +00:00
void TraceFilledRectangle( BOARD* aPcb, int ux0, int uy0, int ux1, int uy1,
int aLayerMask, int color, int op_logic )
{
2007-08-23 04:28:46 +00:00
int row, col;
int row_min, row_max, col_min, col_max;
int trace = 0;
2011-03-09 14:30:39 +00:00
void (* WriteCell)( int, int, int, MATRIX_CELL );
2007-08-23 04:28:46 +00:00
if( ( aLayerMask & GetLayerMask( Route_Layer_BOTTOM ) ) )
trace = 1; // Trace on BOTTOM
2007-08-23 04:28:46 +00:00
if( ( aLayerMask & GetLayerMask( Route_Layer_TOP ) ) && Nb_Sides )
trace |= 2; // Trace on TOP
2007-08-23 04:28:46 +00:00
if( trace == 0 )
return;
switch( op_logic )
2007-08-23 04:28:46 +00:00
{
default:
case WRITE_CELL:
WriteCell = SetCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_OR_CELL:
WriteCell = OrCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_XOR_CELL:
WriteCell = XorCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_AND_CELL:
WriteCell = AndCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_ADD_CELL:
WriteCell = AddCell;
break;
2007-08-23 04:28:46 +00:00
}
2012-02-19 04:02:19 +00:00
ux0 -= aPcb->GetBoundingBox().GetX();
uy0 -= aPcb->GetBoundingBox().GetY();
ux1 -= aPcb->GetBoundingBox().GetX();
uy1 -= aPcb->GetBoundingBox().GetY();
2007-08-23 04:28:46 +00:00
// Calculating limits coord cells belonging to the rectangle.
row_max = uy1 / Board.m_GridRouting;
col_max = ux1 / Board.m_GridRouting;
row_min = uy0 / Board.m_GridRouting;
if( uy0 > row_min * Board.m_GridRouting )
2007-08-23 04:28:46 +00:00
row_min++;
col_min = ux0 / Board.m_GridRouting;
if( ux0 > col_min * Board.m_GridRouting )
2007-08-23 04:28:46 +00:00
col_min++;
if( row_min < 0 )
row_min = 0;
if( row_max >= ( Nrows - 1 ) )
2007-08-23 04:28:46 +00:00
row_max = Nrows - 1;
2007-08-23 04:28:46 +00:00
if( col_min < 0 )
col_min = 0;
if( col_max >= ( Ncols - 1 ) )
2007-08-23 04:28:46 +00:00
col_max = Ncols - 1;
for( row = row_min; row <= row_max; row++ )
{
for( col = col_min; col <= col_max; col++ )
{
if( trace & 1 )
WriteCell( row, col, BOTTOM, color );
2007-08-23 04:28:46 +00:00
if( trace & 2 )
WriteCell( row, col, TOP, color );
}
}
}
2012-02-19 04:02:19 +00:00
void TraceFilledRectangle( BOARD* aPcb, int ux0, int uy0, int ux1, int uy1,
int angle, int aLayerMask, int color, int op_logic )
{
2007-08-23 04:28:46 +00:00
int row, col;
int cx, cy; // Center of rectangle
int radius; // Radius of the circle
2007-08-23 04:28:46 +00:00
int row_min, row_max, col_min, col_max;
int rotrow, rotcol;
int trace = 0;
2011-03-09 14:30:39 +00:00
void (* WriteCell)( int, int, int, MATRIX_CELL );
2007-08-23 04:28:46 +00:00
if( aLayerMask & GetLayerMask( Route_Layer_BOTTOM ) )
trace = 1; // Trace on BOTTOM
2007-08-23 04:28:46 +00:00
if( aLayerMask & GetLayerMask( Route_Layer_TOP ) )
{
2007-08-23 04:28:46 +00:00
if( Nb_Sides )
trace |= 2; // Trace on TOP
}
2007-08-23 04:28:46 +00:00
if( trace == 0 )
return;
switch( op_logic )
2007-08-23 04:28:46 +00:00
{
default:
case WRITE_CELL:
WriteCell = SetCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_OR_CELL:
WriteCell = OrCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_XOR_CELL:
WriteCell = XorCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_AND_CELL:
WriteCell = AndCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_ADD_CELL:
WriteCell = AddCell;
break;
2007-08-23 04:28:46 +00:00
}
2012-02-19 04:02:19 +00:00
ux0 -= aPcb->GetBoundingBox().GetX();
uy0 -= aPcb->GetBoundingBox().GetY();
ux1 -= aPcb->GetBoundingBox().GetX();
uy1 -= aPcb->GetBoundingBox().GetY();
cx = (ux0 + ux1) / 2;
cy = (uy0 + uy1) / 2;
2011-03-09 14:30:39 +00:00
radius = (int) sqrt( (double) ( cx - ux0 ) * ( cx - ux0 )
+ (double) ( cy - uy0 ) * ( cy - uy0 ) );
// Calculating coordinate limits belonging to the rectangle.
row_max = ( cy + radius ) / Board.m_GridRouting;
col_max = ( cx + radius ) / Board.m_GridRouting;
row_min = ( cy - radius ) / Board.m_GridRouting;
if( uy0 > row_min * Board.m_GridRouting )
2007-08-23 04:28:46 +00:00
row_min++;
col_min = ( cx - radius ) / Board.m_GridRouting;
if( ux0 > col_min * Board.m_GridRouting )
2007-08-23 04:28:46 +00:00
col_min++;
if( row_min < 0 )
row_min = 0;
if( row_max >= ( Nrows - 1 ) )
2007-08-23 04:28:46 +00:00
row_max = Nrows - 1;
2007-08-23 04:28:46 +00:00
if( col_min < 0 )
col_min = 0;
if( col_max >= ( Ncols - 1 ) )
2007-08-23 04:28:46 +00:00
col_max = Ncols - 1;
for( row = row_min; row <= row_max; row++ )
{
for( col = col_min; col <= col_max; col++ )
{
rotrow = row * Board.m_GridRouting;
rotcol = col * Board.m_GridRouting;
2007-08-23 04:28:46 +00:00
RotatePoint( &rotcol, &rotrow, cx, cy, -angle );
2007-08-23 04:28:46 +00:00
if( rotrow <= uy0 )
continue;
2007-08-23 04:28:46 +00:00
if( rotrow >= uy1 )
continue;
2007-08-23 04:28:46 +00:00
if( rotcol <= ux0 )
continue;
2007-08-23 04:28:46 +00:00
if( rotcol >= ux1 )
continue;
2007-08-23 04:28:46 +00:00
if( trace & 1 )
WriteCell( row, col, BOTTOM, color );
2007-08-23 04:28:46 +00:00
if( trace & 2 )
WriteCell( row, col, TOP, color );
}
}
}
/* Fills all cells inside a segment
* half-width lg, org ux, ux end y0, y1
* is set to color.
* coordinates are in PCB units (0.1 mil) are relative to the Board
*/
2007-08-23 04:28:46 +00:00
void DrawSegmentQcq( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
int color, int op_logic )
{
2007-08-23 04:28:46 +00:00
int row, col;
int inc;
int row_max, col_max, row_min, col_min;
int demi_pas;
2011-03-09 14:30:39 +00:00
void (* WriteCell)( int, int, int, MATRIX_CELL );
2007-08-23 04:28:46 +00:00
int angle;
int cx, cy, dx, dy;
switch( op_logic )
2007-08-23 04:28:46 +00:00
{
default:
case WRITE_CELL:
WriteCell = SetCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_OR_CELL:
WriteCell = OrCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_XOR_CELL:
WriteCell = XorCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_AND_CELL:
WriteCell = AndCell;
break;
2007-08-23 04:28:46 +00:00
case WRITE_ADD_CELL:
WriteCell = AddCell;
break;
2007-08-23 04:28:46 +00:00
}
// Make coordinate ux1 tj > ux0 to simplify calculations
2007-08-23 04:28:46 +00:00
if( ux1 < ux0 )
{
EXCHG( ux1, ux0 );
EXCHG( uy1, uy0 );
2007-08-23 04:28:46 +00:00
}
// Calculating the incrementing the Y axis
inc = 1;
if( uy1 < uy0 )
2007-08-23 04:28:46 +00:00
inc = -1;
demi_pas = Board.m_GridRouting / 2;
2007-08-23 04:28:46 +00:00
col_min = ( ux0 - lg ) / Board.m_GridRouting;
2007-08-23 04:28:46 +00:00
if( col_min < 0 )
col_min = 0;
col_max = ( ux1 + lg + demi_pas ) / Board.m_GridRouting;
if( col_max > ( Ncols - 1 ) )
2007-08-23 04:28:46 +00:00
col_max = Ncols - 1;
if( inc > 0 )
{
row_min = ( uy0 - lg ) / Board.m_GridRouting;
row_max = ( uy1 + lg + demi_pas ) / Board.m_GridRouting;
2007-08-23 04:28:46 +00:00
}
else
{
row_min = ( uy1 - lg ) / Board.m_GridRouting;
row_max = ( uy0 + lg + demi_pas ) / Board.m_GridRouting;
2007-08-23 04:28:46 +00:00
}
if( row_min < 0 )
row_min = 0;
if( row_min > ( Nrows - 1 ) )
2007-08-23 04:28:46 +00:00
row_min = Nrows - 1;
2007-08-23 04:28:46 +00:00
if( row_max < 0 )
row_max = 0;
if( row_max > ( Nrows - 1 ) )
2007-08-23 04:28:46 +00:00
row_max = Nrows - 1;
dx = ux1 - ux0;
dy = uy1 - uy0;
2007-08-23 04:28:46 +00:00
if( dx )
{
angle = (int) ( atan2( (double) dy, (double) dx ) * 1800 / M_PI );
}
2007-08-23 04:28:46 +00:00
else
{
angle = 900;
if( dy < 0 )
2007-08-23 04:28:46 +00:00
angle = -900;
}
RotatePoint( &dx, &dy, angle ); // dx = length, dy = 0
2007-08-23 04:28:46 +00:00
for( col = col_min; col <= col_max; col++ )
{
int cxr;
cxr = ( col * Board.m_GridRouting ) - ux0;
for( row = row_min; row <= row_max; row++ )
2007-08-23 04:28:46 +00:00
{
cy = (row * Board.m_GridRouting) - uy0;
2007-08-23 04:28:46 +00:00
cx = cxr;
RotatePoint( &cx, &cy, angle );
2007-08-23 04:28:46 +00:00
if( abs( cy ) > lg )
continue; // The point is too far on the Y axis.
2007-08-23 04:28:46 +00:00
/* This point a test is close to the segment: the position
* along the X axis must be tested.
*/
if( ( cx >= 0 ) && ( cx <= dx ) )
2007-08-23 04:28:46 +00:00
{
OP_CELL( layer, row, col );
continue;
}
// Examination of extremities are rounded.
if( ( cx < 0 ) && ( cx >= -lg ) )
2007-08-23 04:28:46 +00:00
{
if( ( ( cx * cx ) + ( cy * cy ) ) <= ( lg * lg ) )
2007-08-23 04:28:46 +00:00
OP_CELL( layer, row, col );
2007-08-23 04:28:46 +00:00
continue;
}
if( ( cx > dx ) && ( cx <= ( dx + lg ) ) )
2007-08-23 04:28:46 +00:00
{
if( ( ( ( cx - dx ) * ( cx - dx ) ) + ( cy * cy ) ) <= ( lg * lg ) )
2007-08-23 04:28:46 +00:00
OP_CELL( layer, row, col );
2007-08-23 04:28:46 +00:00
continue;
}
}
}
}
2007-08-23 04:28:46 +00:00
/* Fills all cells BOARD contained in the circle
* half-width lg center ux, ux through y0, y1 is set to color.
* coord in PCB units (0.1 million) relating to the origin
* pt_pcb-> m_PcbBox.m_Xmin, Y's board.
2007-08-23 04:28:46 +00:00
*/
void TraceCircle( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
int color, int op_logic )
{
2011-03-09 14:30:39 +00:00
int radius, nb_segm;
int x0, y0, // Starting point of the current segment trace.
x1, y1; // End point.
2007-08-23 04:28:46 +00:00
int ii;
int angle;
2011-03-09 14:30:39 +00:00
radius = (int) hypot( (double) (ux1 - ux0), (double) (uy1 - uy0) );
2007-08-23 04:28:46 +00:00
2011-03-09 14:30:39 +00:00
x0 = x1 = radius;
y0 = y1 = 0;
2007-08-23 04:28:46 +00:00
if( lg < 1 )
lg = 1;
2011-03-09 14:30:39 +00:00
nb_segm = ( 2 * radius ) / lg;
2007-08-23 04:28:46 +00:00
if( nb_segm < 5 )
nb_segm = 5;
2007-08-23 04:28:46 +00:00
if( nb_segm > 100 )
nb_segm = 100;
2007-08-23 04:28:46 +00:00
for( ii = 1; ii < nb_segm; ii++ )
{
angle = (3600 * ii) / nb_segm;
x1 = (int) ( radius * cos( DEG2RAD( (double)angle / 10.0 ) ) );
y1 = (int) ( radius * sin( DEG2RAD( (double)angle / 10.0 ) ) );
DrawSegmentQcq( x0 + ux0, y0 + uy0, x1 + ux0, y1 + uy0, lg, layer, color, op_logic );
x0 = x1;
y0 = y1;
2007-08-23 04:28:46 +00:00
}
DrawSegmentQcq( x1 + ux0, y1 + uy0, ux0 + radius, uy0, lg, layer, color, op_logic );
}
2007-08-23 04:28:46 +00:00
/* Fills all BOARD cells contained in the arc of "L" angle half-width lg
* ux center, starting in ux y0, y1 is set to color. Coordinates are in
* PCB units (0.1 mil) relating to the origin pt_pcb-> Pcb_oX, Y's board.
2007-08-23 04:28:46 +00:00
*/
void TraceArc( int ux0, int uy0, int ux1, int uy1, int ArcAngle, int lg,
int layer, int color, int op_logic )
{
2011-03-09 14:30:39 +00:00
int radius, nb_segm;
int x0, y0, // Starting point of the current segment trace
x1, y1; // End point
2007-08-23 04:28:46 +00:00
int ii;
int angle, StAngle;
2011-03-09 14:30:39 +00:00
radius = (int) hypot( (double) (ux1 - ux0), (double) (uy1 - uy0) );
2007-08-23 04:28:46 +00:00
x0 = ux1 - ux0;
y0 = uy1 - uy0;
2007-08-23 04:28:46 +00:00
StAngle = ArcTangente( uy1 - uy0, ux1 - ux0 );
2007-08-23 04:28:46 +00:00
if( lg < 1 )
lg = 1;
2011-03-09 14:30:39 +00:00
nb_segm = ( 2 * radius ) / lg;
2007-08-23 04:28:46 +00:00
nb_segm = ( nb_segm * abs( ArcAngle ) ) / 3600;
2007-08-23 04:28:46 +00:00
if( nb_segm < 5 )
nb_segm = 5;
2007-08-23 04:28:46 +00:00
if( nb_segm > 100 )
nb_segm = 100;
for( ii = 1; ii <= nb_segm; ii++ )
{
angle = ( ArcAngle * ii ) / nb_segm;
2007-08-23 04:28:46 +00:00
angle += StAngle;
while( angle >= 3600 )
angle -= 3600;
while( angle < 0 )
angle += 3600;
x1 = (int) ( radius * cos( DEG2RAD( (double)angle / 10.0 ) ) );
y1 = (int) ( radius * sin( DEG2RAD( (double)angle / 10.0 ) ) );
DrawSegmentQcq( x0 + ux0, y0 + uy0, x1 + ux0, y1 + uy0, lg, layer, color, op_logic );
x0 = x1;
y0 = y1;
2007-08-23 04:28:46 +00:00
}
}