Return to gddemo.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd

Annotation of embedaddon/php/ext/gd/libgd/gddemo.c, revision 1.1

1.1     ! misho       1: #include <stdio.h>
        !             2: #include "gd.h"
        !             3: #include "gdfontg.h"
        !             4: #include "gdfonts.h"
        !             5: 
        !             6: int
        !             7: main (void)
        !             8: {
        !             9:   /* Input and output files */
        !            10:   FILE *in;
        !            11:   FILE *out;
        !            12: 
        !            13:   /* Input and output images */
        !            14:   gdImagePtr im_in = 0, im_out = 0;
        !            15: 
        !            16:   /* Brush image */
        !            17:   gdImagePtr brush;
        !            18: 
        !            19:   /* Color indexes */
        !            20:   int white;
        !            21:   int blue;
        !            22:   int red;
        !            23:   int green;
        !            24: 
        !            25:   /* Points for polygon */
        !            26:   gdPoint points[3];
        !            27: 
        !            28:   /* Create output image, 256 by 256 pixels, true color. */
        !            29:   im_out = gdImageCreateTrueColor (256, 256);
        !            30:   /* First color allocated is background. */
        !            31:   white = gdImageColorAllocate (im_out, 255, 255, 255);
        !            32: 
        !            33:   /* Set transparent color. */
        !            34:   gdImageColorTransparent (im_out, white);
        !            35: 
        !            36:   /* Try to load demoin.png and paste part of it into the
        !            37:      output image. */
        !            38:   in = fopen ("demoin.png", "rb");
        !            39:   if (!in)
        !            40:     {
        !            41:       fprintf (stderr, "Can't load source image; this demo\n");
        !            42:       fprintf (stderr, "is much more impressive if demoin.png\n");
        !            43:       fprintf (stderr, "is available.\n");
        !            44:       im_in = 0;
        !            45:     }
        !            46:   else
        !            47:     {
        !            48:       im_in = gdImageCreateFromPng (in);
        !            49:       fclose (in);
        !            50:       /* Now copy, and magnify as we do so */
        !            51:       gdImageCopyResized (im_out, im_in,
        !            52:                          32, 32, 0, 0, 192, 192, 255, 255);
        !            53:     }
        !            54:   red = gdImageColorAllocate (im_out, 255, 0, 0);
        !            55:   green = gdImageColorAllocate (im_out, 0, 255, 0);
        !            56:   blue = gdImageColorAllocate (im_out, 0, 0, 255);
        !            57:   /* Rectangle */
        !            58:   gdImageLine (im_out, 16, 16, 240, 16, green);
        !            59:   gdImageLine (im_out, 240, 16, 240, 240, green);
        !            60:   gdImageLine (im_out, 240, 240, 16, 240, green);
        !            61:   gdImageLine (im_out, 16, 240, 16, 16, green);
        !            62:   /* Circle */
        !            63:   gdImageArc (im_out, 128, 128, 60, 20, 0, 720, blue);
        !            64:   /* Arc */
        !            65:   gdImageArc (im_out, 128, 128, 40, 40, 90, 270, blue);
        !            66:   /* Flood fill: doesn't do much on a continuously
        !            67:      variable tone jpeg original. */
        !            68:   gdImageFill (im_out, 8, 8, blue);
        !            69:   /* Polygon */
        !            70:   points[0].x = 64;
        !            71:   points[0].y = 0;
        !            72:   points[1].x = 0;
        !            73:   points[1].y = 128;
        !            74:   points[2].x = 128;
        !            75:   points[2].y = 128;
        !            76:   gdImageFilledPolygon (im_out, points, 3, green);
        !            77:   /* Brush. A fairly wild example also involving a line style! */
        !            78:   if (im_in)
        !            79:     {
        !            80:       int style[8];
        !            81:       brush = gdImageCreateTrueColor (16, 16);
        !            82:       gdImageCopyResized (brush, im_in,
        !            83:                          0, 0, 0, 0,
        !            84:                          gdImageSX (brush), gdImageSY (brush),
        !            85:                          gdImageSX (im_in), gdImageSY (im_in));
        !            86:       gdImageSetBrush (im_out, brush);
        !            87:       /* With a style, so they won't overprint each other.
        !            88:          Normally, they would, yielding a fat-brush effect. */
        !            89:       style[0] = 0;
        !            90:       style[1] = 0;
        !            91:       style[2] = 0;
        !            92:       style[3] = 0;
        !            93:       style[4] = 0;
        !            94:       style[5] = 0;
        !            95:       style[6] = 0;
        !            96:       style[7] = 1;
        !            97:       gdImageSetStyle (im_out, style, 8);
        !            98:       /* Draw the styled, brushed line */
        !            99:       gdImageLine (im_out, 0, 255, 255, 0, gdStyledBrushed);
        !           100:     }
        !           101:   /* Text */
        !           102:   gdImageString (im_out, gdFontGiant, 32, 32,
        !           103:                 (unsigned char *) "hi", red);
        !           104:   gdImageStringUp (im_out, gdFontSmall, 64, 64,
        !           105:                   (unsigned char *) "hi", red);
        !           106:   /* Make output image interlaced (progressive, in the case of JPEG) */
        !           107:   gdImageInterlace (im_out, 1);
        !           108:   out = fopen ("demoout.png", "wb");
        !           109:   /* Write PNG */
        !           110:   gdImagePng (im_out, out);
        !           111:   fclose (out);
        !           112:   gdImageDestroy (im_out);
        !           113:   if (im_in)
        !           114:     {
        !           115:       gdImageDestroy (im_in);
        !           116:     }
        !           117:   return 0;
        !           118: }