pen.c

Go to the documentation of this file.

#include <stdio.h>
#include "pen.h"
#include "svd2x2.h"


#define FILE_BUFFER_CAPACITY    (1024*4)


const pentrans IdentityPenTrans = {1, 0, 0, 1, 0, 0};

static const unsigned long Pow10[] = {1,10,100,1000,10000,100000,
                                      1000000,10000000,100000000};


static int StubDrawLine(ATTRIBUTE_UNUSED pen *Pen,
    ATTRIBUTE_UNUSED float x1, ATTRIBUTE_UNUSED float y1,
    ATTRIBUTE_UNUSED float x2, ATTRIBUTE_UNUSED float y2)
{
    ErrorMessage("Pen::DrawLine callback has not been defined.\n");
    return 0;
}


static int StubDrawQBezier(pen *Pen, float x1, float y1,
    float x2, float y2, float x3, float y3)
{
    float L, t, xlast, ylast, xcur, ycur;
    int i, NumLines;
    
    /* Check whether DrawLine is available */
    if(!Pen || !(Pen->DrawLine) || Pen->DrawLine == StubDrawLine)
    {
        ErrorMessage("Pen::DrawQBezier callback has not been defined.\n");
        return 0;
    }
    
    /* Approximate the quadratic Bezier curve using lines */
    L = EstArcLenQBezier(x1, y1, x2, y2, x3, y3, Pen->Trans);
    NumLines = (int)(L*0.04);
    NumLines = (NumLines < 4) ? 4 : NumLines;
    xlast = x1;
    ylast = y1;
    
    for(i = 1; i <= NumLines; i++)
    {
        t = ((float)i)/NumLines;
        xcur = (1 - t)*((1 - t)*x1 + 2*t*x2) + t*t*x3;
        ycur = (1 - t)*((1 - t)*y1 + 2*t*y2) + t*t*y3;
        Pen->DrawLine(Pen, xlast, ylast, xcur, ycur);
        xlast = xcur;
        ylast = ycur;
    }
    
    return 1;
}


static int StubDrawEllipse(pen *Pen,
    float x, float y, float rx, float ry, float Theta)
{
    const float CosTheta = (float)cos(Theta), SinTheta = (float)sin(Theta);
    float C, t, xlast, ylast, xcur, ycur;
    int i, NumLines;
    
    /* Check whether DrawLine is available */
    if(!Pen || !(Pen->DrawLine) || Pen->DrawLine == StubDrawLine)
    {
        ErrorMessage("Pen::DrawEllipse callback has not been defined.\n");
        return 0;
    }
    
    /* Approximate the ellipse using lines */
    C = EstArcLenEllipse(x, y, rx, ry, Theta, Pen->Trans);
    NumLines = (int)(C*0.07);
    NumLines = (NumLines < 8) ? 8 : NumLines;
    
    xlast = x + CosTheta*rx;
    ylast = y - SinTheta*rx;
    
    for(i = 1; i <= NumLines; i++)
    {
        t = (i < NumLines) ? ((float)i)*M_2PI/NumLines : 0;
        xcur = x + CosTheta*rx*cos(t) + SinTheta*ry*sin(t);
        ycur = y - SinTheta*rx*cos(t) + CosTheta*ry*sin(t);
        Pen->DrawLine(Pen, xlast, ylast, xcur, ycur);
        xlast = xcur;
        ylast = ycur;
    }
    
    return 0;
}


pen *NewPen()
{
    static const pen InitPen = {NULL, NULL, 0, 0, PEN_DEFAULT_NUMDIGITS,
        {1, 0, 0, 1, 0, 0}, NULL, 0, 0, {0, 0, 0}, -1,
        NULL, StubDrawLine, StubDrawQBezier, StubDrawEllipse};
    pen *Pen;
        
    if((Pen = (pen *)Malloc(sizeof(pen))))
        *Pen = InitPen;
    
    return Pen;
}
    
    
void FreePen(pen *Pen)
{
    if(Pen)
    {
        Free(Pen->Palette);
        Free(Pen);
    }
}


FILE *PenGetFile(pen *Pen)
{
    return (Pen) ? Pen->File : NULL;
}


int PenDrawLine(pen *Pen, float x1, float y1, float x2, float y2)
{
    return (Pen && Pen->DrawLine(Pen, x1, y1, x2, y2));
}


int PenDrawRectangle(pen *Pen, float x1, float y1, float x2, float y2)
{
    return (Pen
        && Pen->DrawLine(Pen, x1, y1, x2, y1)
        && Pen->DrawLine(Pen, x2, y1, x2, y2)
        && Pen->DrawLine(Pen, x2, y2, x1, y2)
        && Pen->DrawLine(Pen, x1, y2, x1, y1));
}


int PenDrawQBezier(pen *Pen, float x1, float y1,
    float x2, float y2, float x3, float y3)
{
    return (Pen && Pen->DrawQBezier(Pen, x1, y1, x2, y2, x3, y3));
}


int PenDrawCircle(pen *Pen, float x, float y, float r)
{
    return (Pen && Pen->DrawEllipse(Pen, x, y, r, r, 0));
}


int PenDrawEllipse(pen *Pen,
    float x, float y, float rx, float ry, float Theta)
{
    return (Pen && Pen->DrawEllipse(Pen, x, y, rx, ry, Theta));
}


void PenWriteDouble(FILE *File, double Value, int NumDigits)
{
    int i;
    unsigned long Digit, Whole, Frac;

    /* Write sign and negate if Value is negative */
    if(Value < 0)
    {
        putc('-', File);
        Value = -Value;
    }
        
    if(NumDigits > 0)
    {
        if(NumDigits > PEN_MAXDIGITS)
            NumDigits = PEN_MAXDIGITS;
        
        /* Write the whole part */
        Whole = (unsigned long)Value;
        /* Represent fractional part as an integer */
        Frac = (unsigned long)(Pow10[NumDigits]*(Value - Whole) + 0.5f);
        
        /* Carry the rounding +0.5/Pow10[NumDigits] if necessary */
        if(Frac >= Pow10[NumDigits])
        {
            Whole++;
            Frac -= Pow10[NumDigits];
        }
        
        fprintf(File, "%lu", Whole);
        
        /* Write fractional part without trailing zeros */
        if(Frac > 0)
        {
            putc('.', File);
            
            for(i = NumDigits - 1; Frac > 0 && i >= 0; i--)
            {
                Digit = Frac / Pow10[i];
                Frac %= Pow10[i];
                putc('0' + (char)Digit, File);
            }
        }
    }
    else
        fprintf(File, "%lu", (unsigned long)(Value + 0.5f));
}


int PenGetNumDigits(pen *Pen)
{
    return (Pen) ? Pen->NumDigits : PEN_DEFAULT_NUMDIGITS;
}


void PenSetNumDigits(pen *Pen, int NumDigits)
{
    if(Pen)
        Pen->NumDigits = (NumDigits < PEN_MAXDIGITS)
            ? NumDigits : PEN_MAXDIGITS;
}

                            
pentrans PenGetTrans(pen *Pen)
{
    return (Pen) ? Pen->Trans : IdentityPenTrans;
}


void PenSetTrans(pen *Pen, pentrans Trans)
{
    if(Pen)
        Pen->Trans = Trans;
}


void PenTransformCanvas(pen *Pen, double a, double b,
    double c, double d, double e, double f)
{
    if(Pen)
    {
        pentrans NewTrans;
        
        NewTrans.a = Pen->Trans.a*a
            + Pen->Trans.c*b;
        NewTrans.b = Pen->Trans.b*a
            + Pen->Trans.d*b;
        NewTrans.c = Pen->Trans.a*c
            + Pen->Trans.c*d;
        NewTrans.d = Pen->Trans.b*c
            + Pen->Trans.d*d;
        
        NewTrans.e = Pen->Trans.e
            + Pen->Trans.a*e
            + Pen->Trans.c*f;
        NewTrans.f = Pen->Trans.f
            + Pen->Trans.b*e
            + Pen->Trans.d*f;
            
        Pen->Trans = NewTrans;
    }
}


void PenTranslateCanvas(pen *Pen, double tx, double ty)
{
    if(Pen)
        PenTransformCanvas(Pen, 1, 0, 0, 1, tx, ty);
}


void PenScaleCanvas(pen *Pen, double XScale, double YScale)
{
    if(Pen)
        PenTransformCanvas(Pen, XScale, 0, 0, YScale, 0, 0);
}


void PenRotateCanvas(pen *Pen, double Theta)
{
    if(Pen)
    {
        const double CosTheta = cos(Theta);
        const double SinTheta = sin(Theta);
        PenTransformCanvas(Pen, CosTheta, -SinTheta, SinTheta, CosTheta, 0, 0);
    }
}


void PenXSkewCanvas(pen *Pen, double Skew)
{
    if(Pen)
        PenTransformCanvas(Pen, 1, 0, Skew, 1, 0, 0);
}


void PenYSkewCanvas(pen *Pen, double Skew)
{
    if(Pen)
        PenTransformCanvas(Pen, 1, Skew, 0, 1, 0, 0);
}


int PenColorToIndex(pen *Pen, const float *Color)
{
    int i;
    
    if(!Pen || !(Pen->Palette))
        return -1;
    
    for(i = 0; i < Pen->NumPalette; i++)
        if(Pen->Palette[i][0] == Color[0]
            && Pen->Palette[i][1] == Color[1]
            && Pen->Palette[i][2] == Color[2])
            return i;
    
    return -1;
}


int PenDefineColor(pen *Pen, const float *Color)
{
    const int NumPalette = Pen->NumPalette;
    int i;
    
    if(!Pen || !Color)
        return 0;
    
    /* Check if Color is already in Pen->Palette */
    if(PenColorToIndex(Pen, Color) >= 0)
        return 1;
    
    /* Allocate space for the new color if necessary */
    if(NumPalette >= Pen->CapacityPalette)
    {
        float (*NewPalette)[3];
        int NewCapacity = NumPalette + 1 + (NumPalette + 5)/10;
        
        if(!(NewPalette = (float (*)[3])Realloc(Pen->Palette,
            sizeof(float)*3*NewCapacity)))
            return 0;
        
        Pen->Palette = NewPalette;
        Pen->CapacityPalette = NewCapacity;
    }
    
    for(i = 0; i < 3; i++)
        Pen->Palette[NumPalette][i] = Color[i];
    
    (Pen->NumPalette)++;
    return 1;
}


int PenSetColor(pen *Pen, const float *Color)
{
    if(Pen && Color)
    {
        Pen->Color[0] = Color[0];
        Pen->Color[1] = Color[1];
        Pen->Color[2] = Color[2];
        
        if(Pen->SetColor)
            Pen->SetColor(Pen, Color);
    }
    
    return (Pen->ColorIndex = PenColorToIndex(Pen, Color));
}


void TransformEllipse(float *x, float *y, float *rx, float *ry, float *Theta,
    pentrans Trans)
{
    const double CosTheta = cos(*Theta), SinTheta = sin(*Theta);
    double XTrans, YTrans, A[2][2], ThetaTrans, RxTrans, RyTrans, Phi;
    int Sign1, Sign2;
    
    A[0][0] = (Trans.a*CosTheta - Trans.c*SinTheta)*(*rx);
    A[1][0] = (Trans.b*CosTheta - Trans.d*SinTheta)*(*rx);
    A[0][1] = (Trans.a*SinTheta + Trans.c*CosTheta)*(*ry);
    A[1][1] = (Trans.b*SinTheta + Trans.d*CosTheta)*(*ry);
    
    /* Compute singular value decomposition of A */
    Svd2x2(&ThetaTrans, &RxTrans, &RyTrans, &Phi, &Sign1, &Sign2, A);
    
    /* If ThetaTrans = +/- pi/2, swap x and y so that the rotation is zero. */
    if(fabs(fabs(ThetaTrans) - M_PI/2) < 1e-12)
    {
        *rx = (float)RyTrans;
        *ry = (float)RxTrans;
        *Theta = 0;
    }
    else
    {
        *rx = (float)RxTrans;
        *ry = (float)RyTrans;
        *Theta = (float)ThetaTrans;
    }
    
    XTrans = Trans.a*(*x) + Trans.c*(*y) + Trans.e;
    YTrans = Trans.b*(*x) + Trans.d*(*y) + Trans.f;
    *x = (float)XTrans;
    *y = (float)YTrans;
}


float EstArcLenQBezier(float x1, float y1, float x2, float y2,
    float x3, float y3, pentrans Trans)
{
    float Temp;
    
    Temp = Trans.a*x1 + Trans.c*y1 + Trans.e;
    y1 = Trans.b*x1 + Trans.d*y1 + Trans.f;
    x1 = Temp;
    Temp = Trans.a*x2 + Trans.c*y2 + Trans.e;
    y2 = Trans.b*x2 + Trans.d*y2 + Trans.f;
    x2 = Temp;
    Temp = Trans.a*x3 + Trans.c*y3 + Trans.e;
    y3 = Trans.b*x3 + Trans.d*y3 + Trans.f;
    x3 = Temp;
    
    /* Crude overestimate of the arc length */
    return sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2))
        + sqrt((x2 - x3)*(x2 - x3) + (y2 - y3)*(y2 - y3));
}


float EstArcLenEllipse(float x, float y, float rx, float ry, float Theta,
    pentrans Trans)
{
    float Temp;
    
    TransformEllipse(&x, &y, &rx, &ry, &Theta, Trans);
    Temp = (rx - ry)/(rx + ry);
    Temp *= Temp;
    return M_PI*(rx + ry)*(1 + 3*Temp/(10 + sqrt(4 - 3*Temp)));
}



/*****************************************************************************
 * Raster-specific code                                                      *
 *****************************************************************************/


#define SWAP(A,B)   \
    Temp = A; \
    A = B; \
    B = Temp;


static float fpart(float x)
{
    return (float)(x - floor(x));
}


static void PlotPixel(float *Image, int Width, int Height, int x, int y,
    float Alpha, const float *Color)
{
    if(0 <= x && x < Width && 0 <= y && y < Height)
    {
        const float CAlpha = 1 - Alpha;
        
        Image += 3*(x + Width*y);
        Image[0] = CAlpha*Image[0] + Alpha*Color[0];
        Image[1] = CAlpha*Image[1] + Alpha*Color[1];
        Image[2] = CAlpha*Image[2] + Alpha*Color[2];
    }
}


static int RasterDrawLine(pen *Pen, float x1, float y1, float x2, float y2)
{
    float *Image, *Color;
    float yend, Gap, dx, dy, Gradient, y, Temp;
    int Width, Height, xend, ix, iy, ix1, iy1, ix2, iy2, Swapped = 0;
    
            
    if(!Pen || !(Image = Pen->Image))
        return 0;
    
    Width = Pen->ImageWidth;
    Height = Pen->ImageHeight;
    Color = Pen->Color;
    
    /* Transform endpoint coordinates */
    Temp = Pen->Trans.a*x1 + Pen->Trans.c*y1 + Pen->Trans.e;
    y1 = Pen->Trans.b*x1 + Pen->Trans.d*y1 + Pen->Trans.f;
    x1 = Temp;
    Temp = Pen->Trans.a*x2 + Pen->Trans.c*y2 + Pen->Trans.e;
    y2 = Pen->Trans.b*x2 + Pen->Trans.d*y2 + Pen->Trans.f;
    x2 = Temp;
    
    dx = x2 - x1;
    dy = y2 - y1;
    
    if(fabs(dx) < fabs(dy))
    {
        SWAP(x1,y1)
        SWAP(x2,y2)
        SWAP(dx,dy)
        Swapped = 1;
    }
        
    if(x2 < x1)
    {
        SWAP(x1,x2)
        SWAP(y1,y2)
    }
    
    if(dx == 0)
        return 1;
    
    Gradient = dy/dx;
    
    xend = (int)floor(x1 + 0.5f);
    yend = y1 + Gradient * (xend - x1);
    y = yend + Gradient;
    Gap = 1 - fpart(x1 + 0.5f);
    ix1 = xend;
    iy1 = (int)floor(yend);
    
    if(!Swapped)
    {
        PlotPixel(Image, Width, Height, ix1, iy1, (1 - fpart(yend)) * Gap, Color);
        PlotPixel(Image, Width, Height, ix1, iy1 + 1, fpart(yend) * Gap, Color);
    }
    else
    {
        PlotPixel(Image, Width, Height, iy1, ix1, (1 - fpart(yend)) * Gap, Color);
        PlotPixel(Image, Width, Height, iy1 + 1, ix1, fpart(yend) * Gap, Color);
    }
        
    xend = (int)floor(x2 + 0.5f);
    yend = y2 + Gradient * (xend - x2);
    Gap = fpart(x2 + 0.5f);
    ix2 = xend;
    iy2 = (int)floor(yend);
    
    if(!Swapped)
    {
        PlotPixel(Image, Width, Height, ix2, iy2, (1 - fpart(yend)) * Gap, Color);
        PlotPixel(Image, Width, Height, ix2, iy2 + 1, fpart(yend) * Gap, Color);
        
        for(ix = ix1 + 1; ix < ix2; ix++)
        {
            iy = (int)y;
            PlotPixel(Image, Width, Height, ix, iy, 1 - fpart(y), Color);
            PlotPixel(Image, Width, Height, ix, iy + 1, fpart(y), Color);
            y += Gradient;
        }
    }
    else
    {
        PlotPixel(Image, Width, Height, iy2, ix2, (1 - fpart(yend)) * Gap, Color);
        PlotPixel(Image, Width, Height, iy2 + 1, ix2, fpart(yend) * Gap, Color);
        
        for(ix = ix1 + 1; ix < ix2; ix++)
        {
            iy = (int)y;
            PlotPixel(Image, Width, Height, iy, ix, 1 - fpart(y), Color);
            PlotPixel(Image, Width, Height, iy + 1, ix, fpart(y), Color);
            y += Gradient;
        }
    }
    
    return 1;
}


int PenRenderToImage(pen *Pen, float *Image, int Width, int Height)
{
    if(!Pen || !Image || Width <= 0 || Height <= 0)
        return 0;
    
    Pen->Image = Image;
    Pen->SetColor = NULL;
    Pen->ImageWidth = Width;
    Pen->ImageHeight = Height;
    Pen->DrawLine = RasterDrawLine;
    return 1;
}



/*****************************************************************************
 * EPS-specific code                                                         *
 *****************************************************************************/

void EpsSetColor(pen *Pen, const float *Color)
{
    FILE *File;
    
    if(Pen && (File = Pen->File))
    {
        PenWriteDouble(File, Color[0], Pen->NumDigits);
        putc(' ', File);
        PenWriteDouble(File, Color[1], Pen->NumDigits);
        putc(' ', File);
        PenWriteDouble(File, Color[2], Pen->NumDigits);
        fputs(" setrgbcolor\n", File);
    }
}


static int EpsDrawLine(pen *Pen, float x1, float y1, float x2, float y2)
{
    FILE *File;
    double xt1, yt1, xt2, yt2;
    int NumDigits;
        
    if(!Pen || !(File = Pen->File))
        return 0;
    
    NumDigits = Pen->NumDigits;
    
    xt1 = Pen->Trans.a*x1 + Pen->Trans.c*y1 + Pen->Trans.e;
    yt1 = Pen->Trans.b*x1 + Pen->Trans.d*y1 + Pen->Trans.f;
    xt2 = Pen->Trans.a*x2 + Pen->Trans.c*y2 + Pen->Trans.e;
    yt2 = Pen->Trans.b*x2 + Pen->Trans.d*y2 + Pen->Trans.f;
    
    PenWriteDouble(File, xt2 - xt1, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, yt2 - yt1, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, xt1, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, yt1, NumDigits);
    fputs(" m1\n", File);
    return 1;
}


static int EpsDrawQBezier(pen *Pen, float x1, float y1,
    float x2, float y2, float x3, float y3)
{
    FILE *File;
    double xt1, yt1, xt2, yt2, xt3, yt3;
    int NumDigits;
        
    if(!Pen || !(File = Pen->File))
        return 0;
    
    NumDigits = Pen->NumDigits;
    xt1 = Pen->Trans.a*x1 + Pen->Trans.c*y1 + Pen->Trans.e;
    yt1 = Pen->Trans.b*x1 + Pen->Trans.d*y1 + Pen->Trans.f;
    xt2 = Pen->Trans.a*x2 + Pen->Trans.c*y2 + Pen->Trans.e;
    yt2 = Pen->Trans.b*x2 + Pen->Trans.d*y2 + Pen->Trans.f;
    xt3 = Pen->Trans.a*x3 + Pen->Trans.c*y3 + Pen->Trans.e;
    yt3 = Pen->Trans.b*x3 + Pen->Trans.d*y3 + Pen->Trans.f;
    
    PenWriteDouble(File, (2.0/3.0)*(xt2 - xt1), NumDigits);
    putc(' ', File);
    PenWriteDouble(File, (2.0/3.0)*(yt2 - yt1), NumDigits);
    putc(' ', File);
    PenWriteDouble(File, (xt3 - xt1) + (2.0/3.0)*(xt2 - xt3), NumDigits);
    putc(' ', File);
    PenWriteDouble(File, (yt3 - yt1) + (2.0/3.0)*(yt2 - yt3), NumDigits);
    putc(' ', File);
    PenWriteDouble(File, xt3 - xt1, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, yt3 - yt1, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, xt1, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, yt1, NumDigits);
    fputs(" m2\n", File);
    return 1;
}


static int EpsDrawEllipse(pen *Pen, float x, float y,
    float rx, float ry, float Theta)
{
    FILE *File;
    int NumDigits;
        
    if(!Pen || !(File = Pen->File))
        return 0;
    
    NumDigits = Pen->NumDigits;
    TransformEllipse(&x, &y, &rx, &ry, &Theta, Pen->Trans);
        
    PenWriteDouble(File, rx, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, ry, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, Theta*(180/M_PI), NumDigits);
    putc(' ', File);
    PenWriteDouble(File, x, NumDigits);
    putc(' ', File);
    PenWriteDouble(File, y, NumDigits);
    fputs(" m3\n", File);
    return 1;
}


int EpsOpen(pen *Pen, const char *FileName, float Width, float Height)
{
    FILE *File = NULL;
    
    if(!(File = fopen(FileName, "wb")))
    {
        ErrorMessage("Failed to open for writing \"%s\".\n", FileName);
        return 0;
    }
    
    /* Tell File to use buffering */
    setvbuf(File, 0, _IOFBF, FILE_BUFFER_CAPACITY);
    
    fputs("%%!PS-Adobe-2.0\n%%%%BoundingBox: 0 0 ", File);
    PenWriteDouble(File, Width, Pen->NumDigits);
    putc(' ', File);
    PenWriteDouble(File, Height, Pen->NumDigits);
    putc('\n', File);
    
    /* Set PDF distiller info */
    fputs("<< /PageSize [", File);
    PenWriteDouble(File, Width, Pen->NumDigits);
    putc(' ', File);
    PenWriteDouble(File, Height, Pen->NumDigits);
    fputs("] >> setpagedevice\n", File);
    fputs("systemdict /setdistillerparams known {\n"
        "<< /AutoFilterGrayImages false /GrayImageFilter /FlateEncode "
        "/AutoFilterColorImages false /ColorImageFilter /FlateEncode "
        ">> setdistillerparams\n"
        "} if\n", File);
    /* Set PS macros and line width */
    fputs("/bdef {bind def} bind def\n"
        "/m1 {moveto rlineto stroke} bdef\n"
        "/m2 {moveto rcurveto stroke} bdef\n"
        "/m3 {/savematrix matrix currentmatrix def\n"
        "translate rotate scale 0 0 1 0 360 arc\n"
        "savematrix setmatrix stroke} bdef\n"
        "0.2 setlinewidth\n", File);
        
    if(ferror(File))
    {
        ErrorMessage("Failed to write \"%s\".\n", FileName);
        goto Catch;
    }
    
    Pen->File = File;
    Pen->SetColor = EpsSetColor;
    Pen->DrawLine = EpsDrawLine;
    Pen->DrawQBezier = EpsDrawQBezier;
    Pen->DrawEllipse = EpsDrawEllipse;
    return 1;
Catch:
    if(File)
        fclose(File);
    return 0;
}


int EpsClose(pen *Pen)
{
        if(!Pen || !(Pen->File)
        || fputs("showpage\n", Pen->File) == EOF
        || ferror(Pen->File)
        || fclose(Pen->File))
        return 0;
    
    return 1;
}


int WriteASCII85(FILE *File, const uint8_t *Data, int NumBytes)
{
    unsigned long Tuple, Plain[4];
    unsigned int Encoded[5];
    int i, k, LineCount, Padding;
    
    
    /* Write ASCII85-encoded data */
    for(i = 0, LineCount = 0; i < NumBytes; i += 4)
    {
        for(k = 0; k < 4; k++)  /* Get four bytes */
            Plain[k] = Data[i + k];
        
        Tuple = (Plain[0] << 24) | (Plain[1] << 16)
            | (Plain[2] << 8) | Plain[3];
        
        for(k = 4; k >= 0; k--) /* Convert to radix 85 */
        {
            Encoded[k] = Tuple % 85;
            Tuple /= 85;
        }
        
        for(k = 0; k < 5; k++)  /* Write ASCII85 tuple */
            fputc(33 + Encoded[k], File);
        
        /* Periodically emit newlines */
        if(++LineCount >= 15)
        {
            LineCount = 0;
            
            if(fprintf(File, "\n") < 0)
                return 0;
        }
    }
    
    /* Write final tuple */
    if(i < NumBytes)
    {
        for(k = 0; i + k < NumBytes; k++)
            Plain[k] = Data[i + k];
        
        for(Padding = 0; k < 4; k++, Padding++)
            Plain[k] = 0;
        
        Tuple = (Plain[0] << 24) | (Plain[1] << 16)
            | (Plain[2] << 8) | Plain[3];
        
        for(k = 4; k >= 0; k--) /* Convert to radix 85 */
        {
            Encoded[k] = Tuple % 85;
            Tuple /= 85;
        }
        
        for(k = 0; k < 5 - Padding; k++)  /* Write ASCII85 tuple */
            fputc(33 + Encoded[k], File);
        
        if(++LineCount >= 15
            && fprintf(File, "\n") < 0)
            return 0;
    }
    
    if(fprintf(File, "~>\n") < 0 || ferror(File))
        return 0;
    
    return 1;
}


int EpsWriteGrayImage(FILE *File,
    const uint8_t *Image, int Width, int Height)
{
    /* Specify ASCII85 sRGB 8-bit color image data */
    if(!File || !Image || fprintf(File,
        "gsave\n"
        "/DeviceGray setcolorspace\n"
        "0 %d translate %d %d scale\n"
        "<< /ImageType 1\n"
        "   /Width %d\n"
        "   /Height %d\n"
        "   /ImageMatrix [%d 0 0 -%d 0 0]\n"
        "   /BitsPerComponent 8\n"
        "   /Decode [0 1]\n"
        "   /DataSource currentfile /ASCII85Decode filter\n"
        "   /Interpolate false\n"
        ">> image\n",
        Height, Width, Height,
        Width, Height, Width, Height) < 0
        || !WriteASCII85(File, Image, Width*Height)
        || fprintf(File, "grestore\n") < 0)
        return 0;
    else
        return 1;
}


int EpsWriteColorImage(FILE *File,
    const uint8_t *Image, int Width, int Height)
{
    /* Specify ASCII85 sRGB 8-bit color image data */
    if(!File || !Image || fprintf(File,
        "gsave\n"
        "/DeviceRGB setcolorspace\n"
        "0 %d translate %d %d scale\n"
        "<< /ImageType 1\n"
        "   /Width %d\n"
        "   /Height %d\n"
        "   /ImageMatrix [%d 0 0 -%d 0 0]\n"
        "   /BitsPerComponent 8\n"
        "   /Decode [0 1 0 1 0 1]\n"
        "   /DataSource currentfile /ASCII85Decode filter\n"
        "   /Interpolate false\n"
        ">> image\n",
        Height, Width, Height,
        Width, Height, Width, Height) < 0
        || !WriteASCII85(File, Image, 3*Width*Height)
        || fprintf(File, "grestore\n") < 0)
        return 0;
    else
        return 1;
}



/*****************************************************************************
 * SVG-specific code                                                         *
 *****************************************************************************/

static void WriteHexColor(FILE *File, const float *Color)
{
    fprintf(File, "#%02X%02X%02X",
        (int)(255*Color[0] + 0.5f),
        (int)(255*Color[1] + 0.5f),
        (int)(255*Color[2] + 0.5f));
}


static int SvgDrawLine(pen *Pen, float x1, float y1, float x2, float y2)
{
    FILE *File;
    double xt, yt;
    int NumDigits;
        
    if(!Pen || !(File = Pen->File))
        return 0;
    
    NumDigits = Pen->NumDigits;
    fputs("<line ", File);
    
    if(Pen->ColorIndex >= 0)
        fprintf(File, "class=\"%c\" ", 'a' + Pen->ColorIndex);
    else
    {
        fputs("style=\"stroke:", File);
        WriteHexColor(File, Pen->Color);
        fputs("\" ", File);
    }
    
    xt = Pen->Trans.a*x1 + Pen->Trans.c*y1 + Pen->Trans.e;
    yt = Pen->Trans.b*x1 + Pen->Trans.d*y1 + Pen->Trans.f;
    fputs("x1=\"", File);
    PenWriteDouble(File, xt, NumDigits);
    fputs("\" y1=\"", File);
    PenWriteDouble(File, yt, NumDigits);
    
    xt = Pen->Trans.a*x2 + Pen->Trans.c*y2 + Pen->Trans.e;
    yt = Pen->Trans.b*x2 + Pen->Trans.d*y2 + Pen->Trans.f;
    fputs("\" x2=\"", File);
    PenWriteDouble(File, xt, NumDigits);
    fputs("\" y2=\"", File);
    PenWriteDouble(File, yt, NumDigits);
    fputs("\" />\n", File);
    return 1;
}


static int SvgDrawQBezier(pen *Pen,
    float x1, float y1, float x2, float y2, float x3, float y3)
{
    FILE *File;
    double xt0, yt0, xt, yt;
    int NumDigits;
        
    if(!Pen || !(File = Pen->File))
        return 0;
    
    NumDigits = Pen->NumDigits;
    fputs("<path ", File);
    
    if(Pen->ColorIndex >= 0)
        fprintf(File, "class=\"%c\" ", 'a' + Pen->ColorIndex);
    else
    {
        fputs("style=\"stroke:", File);
        WriteHexColor(File, Pen->Color);
        fputs("; fill:none\" ", File);
    }
        
    xt0 = Pen->Trans.a*x1 + Pen->Trans.c*y1 + Pen->Trans.e;
    yt0 = Pen->Trans.b*x1 + Pen->Trans.d*y1 + Pen->Trans.f;
    fputs("d=\"M", File);
    PenWriteDouble(File, xt0, NumDigits);
    putc(',', File);
    PenWriteDouble(File, yt0, NumDigits);
    fputs(" q", File);
    
    xt = Pen->Trans.a*x2 + Pen->Trans.c*y2 + Pen->Trans.e;
    yt = Pen->Trans.b*x2 + Pen->Trans.d*y2 + Pen->Trans.f;
    PenWriteDouble(File, xt - xt0, NumDigits);
    putc(',', File);
    PenWriteDouble(File, yt - yt0, NumDigits);
    putc(' ', File);
    
    xt = Pen->Trans.a*x3 + Pen->Trans.c*y3 + Pen->Trans.e;
    yt = Pen->Trans.b*x3 + Pen->Trans.d*y3 + Pen->Trans.f;
    PenWriteDouble(File, xt - xt0, NumDigits);
    putc(',', File);
    PenWriteDouble(File, yt - yt0, NumDigits);
    fputs("\" />\n", File);
    return 1;
}


static int SvgDrawEllipse(pen *Pen,
    float x, float y, float rx, float ry, float Theta)
{
    FILE *File;
    int NumDigits, IsCircle;
        
    if(!Pen || !(File = Pen->File))
        return 0;
    
    NumDigits = Pen->NumDigits;
    TransformEllipse(&x, &y, &rx, &ry, &Theta, Pen->Trans);
    IsCircle = (fabs(rx - ry) < 1e-2);
    
    if(IsCircle)
        fputs("<circle ", File);
    else
        fputs("<ellipse ", File);
    
    if(Pen->ColorIndex >= 0)
        fprintf(File, "class=\"%c\" ", 'a' + Pen->ColorIndex);
    else
    {
        fputs("style=\"stroke:", File);
        WriteHexColor(File, Pen->Color);
        fputs("\" ", File);
    }
    
    Theta *= 180/M_PI;
    
    if(!IsCircle && fabs(Theta) >= 1e-2 && abs(Theta - 180) >= 1e-2)
    {
        fputs("transform=\"rotate(", File);
        PenWriteDouble(File, Theta, NumDigits);
        putc(' ', File);
        PenWriteDouble(File, x, NumDigits);
        putc(' ', File);
        PenWriteDouble(File, y, NumDigits);
        fputs(")\" ", File);
    }
    
    fputs("cx=\"", File);
    PenWriteDouble(File, x, NumDigits);
    fputs("\" cy=\"", File);
    PenWriteDouble(File, y, NumDigits);
    
    if(IsCircle)
        fputs("\" r=\"", File);
    else
    {
        fputs("\" rx=\"", File);
        PenWriteDouble(File, rx, NumDigits);
        fputs("\" ry=\"", File);
    }
    
    PenWriteDouble(File, ry, NumDigits);
    fputs("\" />\n", File);
    return 1;
}


int SvgOpen(pen *Pen, const char *FileName, float Width, float Height)
{
    FILE *File = NULL;
    int i;
        
    if(!FileName || !(File = fopen(FileName, "wb")))
    {
        ErrorMessage("Failed to open for writing \"%s\".\n", FileName);
        goto Catch;
    }
    
    /* Tell File to use buffering */
    setvbuf(File, 0, _IOFBF, FILE_BUFFER_CAPACITY);
        
    /* Write the XML and DOCTYPE header */
    fputs( "<?xml version=\"1.0\" standalone=\"no\"?>\n"
           "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n"
           "  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n", File);
    
    /* Write SVG header */
    fputs("<svg width=\"", File);
    PenWriteDouble(File, Width, Pen->NumDigits);
    fputs("\" height=\"", File);
    PenWriteDouble(File, Height, Pen->NumDigits);
    fputs("\" version=\"1.1\"\n"
          "  xmlns=\"http://www.w3.org/2000/svg\""
          " xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n", File);
    
    /* Write colors in Pen->Palette in an internal stylesheet */
    if(Pen->NumPalette > 0)
    {
        fputs("<defs>\n<style type=\"text/css\"><![CDATA[\n", File);
        
        for(i = 0; i < Pen->NumPalette; i++)
        {
            fprintf(File, ".%c {stroke:", 'a' + i);
            WriteHexColor(File, Pen->Palette[i]);
            fputs("; stroke-width:2; fill:none}\n", File);
        }
        
        fputs("]]></style>\n</defs>\n", File);
    }
    
    if(ferror(File))
    {
        ErrorMessage("Failed to write \"%s\".\n", FileName);
        goto Catch;
    }
    
    Pen->File = File;
    Pen->SetColor = NULL;
    Pen->DrawLine = SvgDrawLine;
    Pen->DrawQBezier = SvgDrawQBezier;
    Pen->DrawEllipse = SvgDrawEllipse;
    return 1;
Catch:
    if(File)
        fclose(File);
    return 0;
}


int SvgClose(pen *Pen)
{
    if(!Pen || !(Pen->File)
        || fputs("</svg>\n", Pen->File) == EOF
        || ferror(Pen->File)
        || fclose(Pen->File))
        return 0;
    
    return 1;
}