533 lines
15 KiB
C++
533 lines
15 KiB
C++
/******************************************/
|
|
/* Kicad: Common plot HPGL Routines */
|
|
/******************************************/
|
|
|
|
#include "fctsys.h"
|
|
#include "gr_basic.h"
|
|
#include "trigo.h"
|
|
#include "wxstruct.h"
|
|
#include "base_struct.h"
|
|
#include "plot_common.h"
|
|
#include "macros.h"
|
|
#include "kicad_string.h"
|
|
|
|
/* From decimils to plu */
|
|
const double SCALE_HPGL = 0.102041;
|
|
|
|
/***********************************************************************************/
|
|
void HPGL_Plotter::set_viewport( wxPoint offset,
|
|
double aScale, int orient )
|
|
/***********************************************************************************/
|
|
|
|
/* Set the plot offset for the current plotting
|
|
*/
|
|
{
|
|
wxASSERT(!output_file);
|
|
plot_offset = offset;
|
|
plot_scale = aScale;
|
|
device_scale = SCALE_HPGL;
|
|
set_default_line_width(100); /* epaisseur du trait standard en 1/1000 pouce */
|
|
plot_orient_options = orient;
|
|
}
|
|
|
|
/*****************************************************************/
|
|
void HPGL_Plotter::start_plot( FILE *fout )
|
|
/*****************************************************************/
|
|
{
|
|
wxASSERT(!output_file);
|
|
output_file = fout;
|
|
fprintf( output_file, "IN;VS%d;PU;PA;SP%d;\n", pen_speed, pen_number );
|
|
}
|
|
|
|
/**********************************/
|
|
void HPGL_Plotter::end_plot()
|
|
/**********************************/
|
|
{
|
|
wxASSERT(output_file);
|
|
fputs( "PU;PA;SP0;\n", output_file );
|
|
fclose( output_file );
|
|
output_file = 0;
|
|
}
|
|
|
|
/************************************************************/
|
|
void HPGL_Plotter::rect( wxPoint p1, wxPoint p2, FILL_T fill, int width )
|
|
/************************************************************/
|
|
{
|
|
wxASSERT(output_file);
|
|
user_to_device_coordinates( p2 );
|
|
move_to(p1);
|
|
fprintf( output_file, "EA %d,%d;\n", p2.x, p2.y );
|
|
pen_finish();
|
|
}
|
|
|
|
/************************************************************/
|
|
void HPGL_Plotter::circle( wxPoint centre, int diameter, FILL_T fill, int width )
|
|
/************************************************************/
|
|
{
|
|
wxASSERT(output_file);
|
|
double rayon = user_to_device_size(diameter / 2);
|
|
|
|
if( rayon > 0 )
|
|
{
|
|
move_to(centre);
|
|
fprintf( output_file, "CI %g;\n", rayon);
|
|
pen_finish();
|
|
}
|
|
}
|
|
|
|
/*****************************************************/
|
|
void HPGL_Plotter::poly( int nb, int* coord, FILL_T fill, int width )
|
|
/*****************************************************/
|
|
|
|
/* Trace un polygone (ferme si rempli) en format HPGL
|
|
* coord = tableau des coord des sommets
|
|
* nb = nombre de coord ( 1 coord = 2 elements: X et Y du tableau )
|
|
* fill : si != 0 polygone rempli
|
|
*/
|
|
{
|
|
wxASSERT(output_file);
|
|
if( nb <= 1 )
|
|
return;
|
|
|
|
move_to( wxPoint( coord[0], coord[1] ) );
|
|
for(int ii = 1; ii < nb; ii++ )
|
|
line_to( wxPoint( coord[ii * 2], coord[(ii * 2) + 1] ) );
|
|
|
|
/* Fermeture eventuelle du polygone */
|
|
if( fill )
|
|
{
|
|
int ii = (nb - 1) * 2;
|
|
if( (coord[ii] != coord[0] ) || (coord[ii + 1] != coord[1]) )
|
|
line_to( wxPoint( coord[0], coord[1] ) );
|
|
}
|
|
pen_finish();
|
|
}
|
|
|
|
/***************************/
|
|
void HPGL_Plotter::pen_control( int plume )
|
|
/***************************/
|
|
|
|
/* leve (plume = 'U') ou baisse (plume = 'D') la plume
|
|
*/
|
|
{
|
|
wxASSERT(output_file);
|
|
switch (plume) {
|
|
case 'U':
|
|
if( pen_state != 'U' )
|
|
{
|
|
fputs( "PU;", output_file );
|
|
pen_state = 'U';
|
|
}
|
|
break;
|
|
case 'D':
|
|
if( pen_state != 'D' )
|
|
{
|
|
fputs( "PD;", output_file );
|
|
pen_state = 'D';
|
|
}
|
|
break;
|
|
case 'Z':
|
|
fputs( "PU;", output_file );
|
|
pen_state = 'U';
|
|
pen_lastpos.x = -1;
|
|
pen_lastpos.y = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**********************************************/
|
|
void HPGL_Plotter::pen_to( wxPoint pos, char plume )
|
|
/**********************************************/
|
|
|
|
/*
|
|
* deplace la plume levee (plume = 'U') ou baissee (plume = 'D')
|
|
* en position x,y
|
|
* Unites en Unites DESSIN
|
|
* Si plume = 'Z' lever de plume sans deplacement
|
|
*/
|
|
{
|
|
wxASSERT(output_file);
|
|
if( plume == 'Z' )
|
|
{
|
|
pen_control( 'Z' );
|
|
return;
|
|
}
|
|
pen_control( plume );
|
|
user_to_device_coordinates( pos );
|
|
|
|
if (pen_lastpos != pos)
|
|
fprintf( output_file, "PA %d,%d;\n", pos.x, pos.y );
|
|
pen_lastpos = pos;
|
|
}
|
|
|
|
void HPGL_Plotter::set_dash( bool dashed )
|
|
{
|
|
wxASSERT(output_file);
|
|
if (dashed)
|
|
fputs("LI 2;\n", stderr);
|
|
else
|
|
fputs("LI;\n", stderr);
|
|
}
|
|
|
|
void HPGL_Plotter::thick_segment( wxPoint start, wxPoint end, int width,
|
|
GRTraceMode tracemode)
|
|
/** Function Plot a filled segment (track)
|
|
* @param start = starting point
|
|
* @param end = ending point
|
|
* @param aWidth = segment width (thickness)
|
|
* @param aPlotMode = FILLED, SKETCH ..
|
|
*/
|
|
{
|
|
wxASSERT(output_file);
|
|
wxPoint center;
|
|
wxSize size;
|
|
|
|
if( (pen_diameter >= width) || (tracemode == FILAIRE) ) /* just a line is Ok */
|
|
{
|
|
move_to( start );
|
|
finish_to( end );
|
|
}
|
|
else
|
|
segment_as_oval(start, end, width, tracemode);
|
|
}
|
|
|
|
/********************************************************************/
|
|
void HPGL_Plotter::arc( wxPoint centre, int StAngle, int EndAngle, int rayon,
|
|
FILL_T fill, int width )
|
|
/********************************************************************/
|
|
|
|
/* trace d'un arc de cercle:
|
|
* centre = coord du centre
|
|
* StAngle, EndAngle = angle de debut et fin
|
|
* rayon = rayon de l'arc
|
|
* commande
|
|
* PU;PA x,y;PD;AA start_arc_X, start_arc_Y, angle, NbSegm; PU;
|
|
* ou PU;PA x,y;PD;AA start_arc_X, start_arc_Y, angle; PU;
|
|
*/
|
|
{
|
|
wxASSERT(output_file);
|
|
wxPoint cmap; /* point de depart */
|
|
wxPoint cpos; /* centre */
|
|
float angle; /* angle de l'arc*/
|
|
|
|
if( rayon <= 0 )
|
|
return;
|
|
|
|
cpos = centre;
|
|
user_to_device_coordinates( cpos );
|
|
|
|
if( plot_orient_options == PLOT_MIROIR )
|
|
angle = (StAngle - EndAngle) / 10.0;
|
|
else
|
|
angle = (EndAngle - StAngle) / 10.0;
|
|
/* Calcul des coord du point de depart : */
|
|
cmap.x = (int) ( centre.x + ( rayon * cos( StAngle * M_PI / 1800 ) ) );
|
|
cmap.y = (int) ( centre.y - ( rayon * sin( StAngle * M_PI / 1800 ) ) );
|
|
user_to_device_coordinates( cmap );
|
|
|
|
fprintf( output_file, "PU;PA %d,%d;PD;AA %d,%d, ", cmap.x, cmap.y, cpos.x, cpos.y );
|
|
fprintf( output_file, "%f", angle );
|
|
fprintf( output_file, ";PU;\n" );
|
|
pen_finish();
|
|
}
|
|
|
|
/***********************************************************************************/
|
|
void HPGL_Plotter::flash_pad_oval( wxPoint pos, wxSize size, int orient,
|
|
GRTraceMode trace_mode )
|
|
/************************************************************************************/
|
|
/* Trace 1 pastille PAD_OVAL en position pos_X,Y , de dim size.x, size.y */
|
|
{
|
|
wxASSERT(output_file);
|
|
int rayon, deltaxy, cx, cy;
|
|
|
|
/* la pastille est ramenee a une pastille ovale avec size.y > size.x
|
|
* ( ovale vertical en orientation 0 ) */
|
|
if( size.x > size.y )
|
|
{
|
|
EXCHG( size.x, size.y ); orient += 900;
|
|
if( orient >= 3600 )
|
|
orient -= 3600;
|
|
}
|
|
deltaxy = size.y - size.x; /* = distance entre centres de l'ovale */
|
|
rayon = size.x / 2;
|
|
if( trace_mode == FILLED )
|
|
{
|
|
flash_pad_rect( pos, wxSize( size.x, deltaxy+pen_diameter ),
|
|
orient, trace_mode );
|
|
cx = 0; cy = deltaxy / 2;
|
|
RotatePoint( &cx, &cy, orient );
|
|
flash_pad_circle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode );
|
|
cx = 0; cy = -deltaxy / 2;
|
|
RotatePoint( &cx, &cy, orient );
|
|
flash_pad_circle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode );
|
|
}
|
|
else /* Trace en mode SKETCH */
|
|
{
|
|
sketch_oval(pos, size, orient, pen_diameter);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
void HPGL_Plotter::flash_pad_circle(wxPoint pos, int diametre,
|
|
GRTraceMode trace_mode)
|
|
/*******************************************************************************/
|
|
/* Trace 1 pastille RONDE (via,pad rond) en position pos */
|
|
{
|
|
wxASSERT(output_file);
|
|
int rayon, delta;
|
|
|
|
user_to_device_coordinates( pos );
|
|
|
|
delta = pen_diameter - pen_overlap;
|
|
rayon = diametre / 2;
|
|
if( trace_mode != FILAIRE )
|
|
{
|
|
rayon = (diametre - pen_diameter ) / 2;
|
|
}
|
|
|
|
if( rayon < 0 )
|
|
{
|
|
rayon = 0;
|
|
}
|
|
wxSize rsize( rayon, rayon );
|
|
|
|
user_to_device_size( rsize );
|
|
|
|
fprintf( output_file, "PA %d,%d;CI %d;\n", pos.x, pos.y, rsize.x );
|
|
if( trace_mode == FILLED ) /* Trace en mode Remplissage */
|
|
{
|
|
if( delta > 0 )
|
|
{
|
|
while( (rayon -= delta ) >= 0 )
|
|
{
|
|
rsize.x = rsize.y = rayon;
|
|
user_to_device_size( rsize );
|
|
fprintf( output_file, "PA %d,%d; CI %d;\n", pos.x, pos.y, rsize.x );
|
|
}
|
|
}
|
|
}
|
|
pen_finish();
|
|
return;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
void HPGL_Plotter::flash_pad_rect(wxPoint pos, wxSize padsize,
|
|
int orient, GRTraceMode trace_mode)
|
|
/**************************************************************************/
|
|
/*
|
|
* Trace 1 pad rectangulaire vertical ou horizontal ( Pad rectangulaire )
|
|
* donne par son centre et ses dimensions X et Y
|
|
* Units are user units
|
|
*/
|
|
{
|
|
wxASSERT(output_file);
|
|
wxSize size;
|
|
int delta;
|
|
int ox, oy, fx, fy;
|
|
|
|
size.x = padsize.x / 2; size.y = padsize.y / 2;
|
|
if( trace_mode != FILAIRE )
|
|
{
|
|
size.x = (padsize.x - (int) pen_diameter) / 2;
|
|
size.y = (padsize.y - (int) pen_diameter) / 2;
|
|
}
|
|
|
|
if( size.x < 0 )
|
|
size.x = 0;
|
|
if( size.y < 0 )
|
|
size.y = 0;
|
|
|
|
/* Si une des dimensions est nulle, le trace se reduit a 1 trait */
|
|
if( size.x == 0 )
|
|
{
|
|
ox = pos.x; oy = pos.y - size.y;
|
|
RotatePoint( &ox, &oy, pos.x, pos.y, orient );
|
|
fx = pos.x; fy = pos.y + size.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
move_to( wxPoint( ox, oy ) );
|
|
finish_to( wxPoint( fx, fy ) );
|
|
return;
|
|
}
|
|
if( size.y == 0 )
|
|
{
|
|
ox = pos.x - size.x; oy = pos.y;
|
|
RotatePoint( &ox, &oy, pos.x, pos.y, orient );
|
|
fx = pos.x + size.x; fy = pos.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
move_to( wxPoint( ox, oy ) );
|
|
finish_to( wxPoint( fx, fy ) );
|
|
return;
|
|
}
|
|
|
|
ox = pos.x - size.x; oy = pos.y - size.y;
|
|
RotatePoint( &ox, &oy, pos.x, pos.y, orient );
|
|
move_to( wxPoint( ox, oy ) );
|
|
|
|
fx = pos.x - size.x; fy = pos.y + size.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
line_to( wxPoint( fx, fy ) );
|
|
|
|
fx = pos.x + size.x; fy = pos.y + size.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
line_to( wxPoint( fx, fy ) );
|
|
|
|
fx = pos.x + size.x; fy = pos.y - size.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
line_to( wxPoint( fx, fy ) );
|
|
|
|
finish_to( wxPoint( ox, oy ) );
|
|
|
|
if( trace_mode == FILLED )
|
|
{
|
|
/* Trace en mode Remplissage */
|
|
delta = (int) (pen_diameter - pen_overlap);
|
|
if( delta > 0 )
|
|
while( (size.x > 0) && (size.y > 0) )
|
|
{
|
|
size.x -= delta; size.y -= delta;
|
|
if( size.x < 0 )
|
|
size.x = 0;
|
|
if( size.y < 0 )
|
|
size.y = 0;
|
|
|
|
ox = pos.x - size.x; oy = pos.y - size.y;
|
|
RotatePoint( &ox, &oy, pos.x, pos.y, orient );
|
|
move_to( wxPoint( ox, oy ) );
|
|
|
|
fx = pos.x - size.x; fy = pos.y + size.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
line_to( wxPoint( fx, fy ) );
|
|
|
|
fx = pos.x + size.x; fy = pos.y + size.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
line_to( wxPoint( fx, fy ) );
|
|
|
|
fx = pos.x + size.x; fy = pos.y - size.y;
|
|
RotatePoint( &fx, &fy, pos.x, pos.y, orient );
|
|
line_to( wxPoint( fx, fy ) );
|
|
|
|
finish_to( wxPoint( ox, oy ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************/
|
|
void HPGL_Plotter::flash_pad_trapez( wxPoint pos, wxSize size, wxSize delta,
|
|
int orient, GRTraceMode trace_mode )
|
|
/*******************************************************************/
|
|
/*
|
|
* Trace 1 pad trapezoidal donne par :
|
|
* son centre pos.x,pos.y
|
|
* ses dimensions dimX et dimY
|
|
* les variations deltaX et deltaY
|
|
* son orientation orient et 0.1 degres
|
|
* le mode de trace (FILLED, SKETCH, FILAIRE)
|
|
* Le trace n'est fait que pour un trapeze, c.a.d que deltaX ou deltaY
|
|
* = 0.
|
|
*
|
|
* les notation des sommets sont ( vis a vis de la table tracante )
|
|
* 0 ------------- 3
|
|
* . .
|
|
* . .
|
|
* . .
|
|
* 1 --- 2
|
|
*/
|
|
{
|
|
wxASSERT(output_file);
|
|
wxPoint polygone[4]; /* coord des sommets / centre du pad */
|
|
wxPoint coord[4]; /* coord reelles des sommets du trapeze a tracer */
|
|
int moveX, moveY; /* variation de position plume selon axe X et Y , lors
|
|
* du remplissage du trapeze */
|
|
moveX = moveY = pen_diameter;
|
|
|
|
size.x /= 2; size.y /= 2;
|
|
delta.x /= 2; delta.y /= 2;
|
|
|
|
polygone[0].x = -size.x - delta.y; polygone[0].y = +size.y + delta.x;
|
|
polygone[1].x = -size.x + delta.y; polygone[1].y = -size.y - delta.x;
|
|
polygone[2].x = +size.x - delta.y; polygone[2].y = -size.y + delta.x;
|
|
polygone[3].x = +size.x + delta.y; polygone[3].y = +size.y - delta.x;
|
|
|
|
/* Trace du contour */
|
|
polygone[0].x += moveX; polygone[0].y -= moveY;
|
|
polygone[1].x += moveX; polygone[1].y += moveY;
|
|
polygone[2].x -= moveX; polygone[2].y += moveY;
|
|
polygone[3].x -= moveX; polygone[3].y -= moveY;
|
|
|
|
for(int ii = 0; ii < 4; ii++ )
|
|
{
|
|
coord[ii].x = polygone[ii].x + pos.x;
|
|
coord[ii].y = polygone[ii].y + pos.y;
|
|
RotatePoint( &coord[ii], pos, orient );
|
|
}
|
|
|
|
// Plot edge:
|
|
move_to( coord[0] );
|
|
line_to( coord[1] );
|
|
line_to( coord[2] );
|
|
line_to( coord[3] );
|
|
finish_to( coord[0] );
|
|
|
|
if( trace_mode == FILLED )
|
|
{
|
|
int jj;
|
|
/* Fill the shape */
|
|
moveX = moveY = pen_diameter - pen_overlap;
|
|
/* calcul de jj = hauteur du remplissage */
|
|
if( delta.y ) /* Trapeze horizontal */
|
|
{
|
|
jj = size.y - (int) ( pen_diameter + (2 * pen_overlap) );
|
|
}
|
|
else
|
|
{
|
|
jj = size.x - (int) ( pen_diameter + (2 * pen_overlap) );
|
|
}
|
|
|
|
/* Calcul de jj = nombre de segments a tracer pour le remplissage */
|
|
jj = jj / (int) (pen_diameter - pen_overlap);
|
|
|
|
/* Trace du contour */
|
|
for( ; jj > 0; jj-- )
|
|
{
|
|
polygone[0].x += moveX; polygone[0].y -= moveY;
|
|
polygone[1].x += moveX; polygone[1].y += moveY;
|
|
polygone[2].x -= moveX; polygone[2].y += moveY;
|
|
polygone[3].x -= moveX; polygone[3].y -= moveY;
|
|
|
|
/* Test de limitation de variation des dimensions :
|
|
* si les sommets se "croisent", il ne faut plus modifier les
|
|
* coordonnees correspondantes */
|
|
if( polygone[0].x > polygone[3].x )
|
|
{ /* croisement sur axe X des 2 sommets 0 et 3 */
|
|
polygone[0].x = polygone[3].x = 0;
|
|
}
|
|
if( polygone[1].x > polygone[2].x )
|
|
{ /* croisement sur axe X des 2 sommets 1 et 2 */
|
|
polygone[1].x = polygone[2].x = 0;
|
|
}
|
|
if( polygone[1].y > polygone[0].y )
|
|
{ /* croisement sur axe Y des 2 sommets 0 et 1 */
|
|
polygone[0].y = polygone[1].y = 0;
|
|
}
|
|
if( polygone[2].y > polygone[3].y )
|
|
{ /* croisement sur axe Y des 2 sommets 2 et 3 */
|
|
polygone[2].y = polygone[3].y = 0;
|
|
}
|
|
|
|
for(int ii = 0; ii < 4; ii++ )
|
|
{
|
|
coord[ii].x = polygone[ii].x + pos.x;
|
|
coord[ii].y = polygone[ii].y + pos.y;
|
|
RotatePoint( &coord[ii], pos, orient );
|
|
}
|
|
|
|
move_to( coord[0] );
|
|
line_to( coord[1] );
|
|
line_to( coord[2] );
|
|
line_to( coord[3] );
|
|
finish_to( coord[0] );
|
|
}
|
|
}
|
|
}
|
|
|