home *** CD-ROM | disk | FTP | other *** search
/ PC Graphics Unleashed / PC Graphics Unleashed.iso / ch03 / morph.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-11  |  8.5 KB  |  287 lines
  1. /****************************************************************
  2. * FILE:    morph.c
  3. * DESC:    Create a metamorphosing sequence between two given
  4. *        images. This program lets you specify two files to
  5. *        morph, then prompts you for control lines. It uses
  6. *        the lines to warp the underlying images a step at
  7. *        a time, combine them, and optionally save them as
  8. *        numbered PCX files.
  9. * 
  10. * HISTORY:    Created     1/13/1993
  11. * LAST CHANGED:  5/ 6/1993
  12. * 
  13. *    Copyright (c) 1993 by Scott Anderson
  14. *
  15. ****************************************************************/
  16.  
  17. /* ----------------------INCLUDES----------------------------- */
  18.  
  19. #include <conio.h>
  20. #include <stdio.h>
  21. #include <io.h>
  22. #include <math.h>
  23. #include <graph.h>
  24. #include <malloc.h>
  25. #include <memory.h>
  26. #include <string.h>
  27.  
  28. #include "define.h"
  29.  
  30. /* ----------------------DEFINES------------------------------ */
  31.  
  32. #define MORPH_TWEENS    1
  33.  
  34. /* ----------------------PROTOTYPES--------------------------- */
  35.  
  36. int        tweenMorph(PICTURE *src, PICTURE *dst);
  37.  
  38. /* ----------------------EXTERNALS---------------------------- */
  39.  
  40. /**** color routines ****/
  41. extern int    closestColor(int r, int g, int b, PALETTE *palPtr);
  42. extern void    collapseColors(PALETTE *palPtr);
  43.  
  44. /**** line routines ****/
  45. extern int    setLength(LINE *line);
  46. extern int    sumLines(PICTURE *picture, COLOR *color,
  47.                     LINE *origline, POINT *warp, LINE *warpline);
  48.  
  49. /**** io routines ****/
  50. extern LINE_LIST    *loadLines(char *filename, char *extension);
  51. extern void          saveLines(char *filename,
  52.                         LINE_LIST *lineList, char *extension);
  53.  
  54. /***** variables used to compute intermediate images ****/
  55.  
  56. /* number of colors in tweened image before reduction*/
  57. extern int     Ncolors;
  58.  
  59. /* r, g, b frequency counter array */
  60. extern unsigned int far Freq[MAX_COMP][MAX_COMP][MAX_COMP];
  61.  
  62. /* tweened images red, grn, and blu components*/
  63. extern unsigned char far Red[MAX_WIDE][MAX_TALL];
  64. extern unsigned char far Grn[MAX_WIDE][MAX_TALL];
  65. extern unsigned char far Blu[MAX_WIDE][MAX_TALL];
  66.  
  67. extern PALETTE TweenPal;            /* resulting palette */
  68.  
  69. /**** other variables ****/ 
  70. extern char        *OutFilename;
  71. /* set from last picture loaded */
  72. extern int        Xmin, Ymin, Xmax, Ymax;
  73. /* ID of palette currently being displayed */
  74. extern int         CurrentPal;
  75.  
  76. /* ----------------------GLOBAL DATA-------------------------- */
  77.  
  78. PICTURE *Src;        /* source & destination picture pointers */
  79. PICTURE *Dst;
  80.  
  81. LINE     SrcLine[MAX_LINES];
  82. LINE     DstLine[MAX_LINES];
  83.  
  84. int        Tweens;
  85. int        NumLines;
  86.  
  87. /*****************************************************************
  88. * FUNC: main (int argc, char *argv[])
  89. * 
  90. * DESC: Read in a filename to load
  91. *****************************************************************/
  92.  
  93. main (int argc, char *argv[])
  94. {
  95.     int        segment;
  96.     LINE_LIST *lineSrcList;
  97.     LINE_LIST *lineDstList;
  98.     char    answer;
  99.  
  100.     /* load the pcx file if one is given */
  101.     if ((3 > argc) || (argc > 5)) {
  102.         printf("Usage: morph <source> <dest> [<steps> [<output>]]\n\n");
  103.         printf("Where: <source> is the source PCX filename\n");
  104.         printf("       <dest>     is the destination filename\n");
  105.         printf("       <steps>  is the optional sequence size\n");
  106.         printf("                (the max is %d, the default is %d)\n",
  107.                                 MAX_TWEENS, MORPH_TWEENS+2);
  108.         printf("       <output> is the optional output filename\n");
  109.         printf("                (defaults to no output)\n\n");
  110.         printf("Note:  The output filename can be at most %d characters long.\n",
  111.                                 MAX_NAME_SIZE);
  112.         printf("       The PCX extension is added automatically, so don't\n");
  113.         printf("       include it in the filename.\n");
  114.         printf("       Morph only accepts PCX files with %d X %d resolution\n",
  115.                                 MAX_WIDE, MAX_TALL);
  116.         printf("       and %d colors.\n", COLORS);
  117.         exit(0);
  118.     }
  119.     if (argc > 3) {
  120.         /* subtract two from the series count to get the tweens
  121.          * since the starting and ending frame are included. */
  122.         Tweens = clip (atoi(argv[3]) - 2, 1, MAX_TWEENS);
  123.         if (argc > 4)
  124.             OutFilename = argv[4];
  125.     }
  126.     else
  127.         Tweens = MORPH_TWEENS;
  128.     
  129.     printf("Loading the file %s\n", argv[1]);
  130.     Src = loadPicture(argv[1]);
  131.     if (Src == NULL)
  132.         quit(MEMORY_ERR, "");
  133.     
  134.     printf("Loading the file %s\n", argv[2]);
  135.     Dst = loadPicture(argv[2]);
  136.     if (Dst == NULL)
  137.         quit(MEMORY_ERR, "");
  138.     lineSrcList = loadLines(argv[1], EXT_LINE1);
  139.     if (lineSrcList->number != 0) {
  140.         if (lineAsk(argv[1]) == 'N')
  141.             createLines(Src, lineSrcList);
  142.         else
  143.             editLines(Src, lineSrcList);
  144.     }
  145.     else
  146.         createLines(Src, lineSrcList);
  147.     
  148.     TargFlag = 1;    /* For the screen intro message */
  149.     NumLines = lineSrcList->number;
  150.     if (NumLines) {
  151.         lineDstList = loadLines(argv[2], EXT_LINE1);
  152.             /* inconsistent warp target*/
  153.         if (lineDstList->number !=  NumLines)
  154.             lineDstList->number = 0;
  155.         if (lineDstList->number) {    /* ask what he wants to do */
  156.             if (lineAsk(argv[2]) == 'N')
  157.                 lineDstList->number = 0;
  158.         }
  159.         if (lineDstList->number == 0) {    /* create a warp target */
  160.             /* copy the source lines */
  161.             lineDstList->number = NumLines;
  162.             for (segment = 0; segment < NumLines; segment++) 
  163.                 lineDstList->line[segment]
  164.                                 = lineSrcList->line[segment];
  165.         }
  166.  
  167.         editLines(Dst, lineDstList);
  168.         saveLines(argv[1], lineSrcList, EXT_LINE1);
  169.         saveLines(argv[2], lineDstList, EXT_LINE1);
  170.         beep();
  171.         for (segment = 0; segment < NumLines; segment++) {
  172.             DstLine[segment].p[0]=lineDstList->line[segment].p[0];
  173.             DstLine[segment].p[1]=lineDstList->line[segment].p[1];
  174.             setLength(&DstLine[segment]);
  175.             SrcLine[segment].p[0]=lineSrcList->line[segment].p[0];
  176.             SrcLine[segment].p[1]=lineSrcList->line[segment].p[1];
  177.             setLength(&SrcLine[segment]);
  178.         }
  179.     }
  180.  
  181.     tweenMorph(Src, Dst);
  182.     setTextMode();
  183. }
  184.  
  185. /*****************************************************************
  186. * FUNC: int    tweenMorph(PICTURE *src, PICTURE *dst)
  187. * 
  188. * DESC: calculate a pixel to plot, from the warping function
  189. *****************************************************************/
  190.  
  191. #define TOTAL_WEIGHT        (100)    /* Good for up to 99 tweens */
  192.  
  193. tweenMorph(PICTURE *src, PICTURE *dst)
  194. {
  195.     int color;
  196.     POINT warp;
  197.     int    x,y;
  198.     COLOR scolor, dcolor;
  199.     LINE warpLine[MAX_LINES];
  200.     int t, i, p;
  201.     int r, g, b;
  202.     unsigned int srcweight, srcpaletteindex;
  203.     unsigned int dstweight, dstpaletteindex;
  204.  
  205.     displayPicture(src);
  206.     saveScreen(&src->pal);
  207.  
  208.     /* src is on screen, now tween to the target */
  209.     for (t = 1; t <= Tweens; t++) {
  210.         /* Tween the lines used to warp the images */
  211.         for (i = 0; i < NumLines; i++) {
  212.             for (p = 0; p < 2; p++) {
  213.                 warpLine[i].p[p].x = SrcLine[i].p[p].x +
  214.                     ((DstLine[i].p[p].x - SrcLine[i].p[p].x) * t)
  215.                     /(Tweens+1);
  216.                 warpLine[i].p[p].y = SrcLine[i].p[p].y +
  217.                     ((DstLine[i].p[p].y - SrcLine[i].p[p].y) * t)
  218.                     /(Tweens+1);
  219.             }
  220.             setLength(&warpLine[i]);
  221.         }
  222.  
  223.         dstweight = t * TOTAL_WEIGHT / (Tweens+1);
  224.         srcweight = TOTAL_WEIGHT - dstweight;
  225.  
  226.         /* Zero out the buffers */
  227.         initFreq();
  228.         /* set background to black */
  229.         _fmemset(Red, 0, sizeof Red);
  230.         _fmemset(Grn, 0, sizeof Grn);
  231.         _fmemset(Blu, 0, sizeof Blu);
  232.  
  233.         /* Go through the screen and get warped source pixels */
  234.         for (warp.y = Ymin; warp.y <= Ymax; warp.y++)    {
  235.             if (quitCheck())
  236.                 quit(0, "");
  237.             for (warp.x = Xmin; warp.x <= Xmax; warp.x++)    {    
  238.                 sumLines(src, &scolor, SrcLine, &warp, warpLine);
  239.                 sumLines(dst, &dcolor, DstLine, &warp, warpLine);
  240.                 r = (scolor.r * srcweight +    dcolor.r * dstweight)
  241.                             / TOTAL_WEIGHT;
  242.                 g = (scolor.g * srcweight +    dcolor.g * dstweight)
  243.                             / TOTAL_WEIGHT;
  244.                 b = (scolor.b * srcweight +    dcolor.b * dstweight)
  245.                             / TOTAL_WEIGHT;
  246.                 if (Freq[r][g][b] == 0)        /* A new color */
  247.                     Ncolors++;
  248.                 /* Keep it to one byte */
  249.                 if (Freq[r][g][b] < MAX_FREQ)
  250.                     Freq[r][g][b]++;
  251.                 /* put RGB components into temporary buffer */
  252.                 Red[warp.x][warp.y] = r;
  253.                 Grn[warp.x][warp.y] = g;
  254.                 Blu[warp.x][warp.y] = b;
  255.             }
  256.         }
  257.         collapseColors(&TweenPal);
  258.         setPalette(&TweenPal);
  259.  
  260.         for (y = Ymin; y <= Ymax; y++)    {
  261.             if (quitCheck())
  262.                 quit(0, "");
  263.             for (x = Xmin; x <= Xmax; x++)    {
  264.                 color = closestColor(    Red[x][y],
  265.                                         Grn[x][y],
  266.                                         Blu[x][y],
  267.                                         &TweenPal);
  268.                 _setcolor (color);
  269.                 _setpixel (x, y);
  270.             }
  271.         }
  272.         /* no output file name on command line */
  273.         if (!OutFilename) {
  274.             beep();
  275.             waitForKey();    /* so pause to enjoy the pictures */
  276.         }
  277.         else
  278.             saveScreen(&TweenPal);
  279.     }
  280.     if (OutFilename) {    /* save the last pic in this series */
  281.         CurrentPal = 0;         /* force a new palette */
  282.         displayPicture(dst);
  283.         saveScreen(&dst->pal);
  284.     }
  285. }
  286.  
  287.