home *** CD-ROM | disk | FTP | other *** search
/ PC Graphics Unleashed / PC Graphics Unleashed.iso / ch03 / linecalc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-21  |  11.4 KB  |  419 lines
  1. /****************************************************************
  2. * FILE:    linecalc.c
  3. * DESC:    These routines include the warping calculations and
  4. *        the line-handling functions.
  5. * 
  6. * HISTORY:    Created      3/11/1993
  7. * LAST CHANGED:  5/ 6/1993
  8. * 
  9. *    Copyright (c) 1993 by Scott Anderson
  10. *
  11. ****************************************************************/
  12.  
  13. /* ----------------------INCLUDES----------------------------- */
  14.  
  15. #include <conio.h>
  16. #include <stdio.h>
  17. #include <io.h>
  18. #include <math.h>
  19. #include <graph.h>
  20.  
  21. #include <malloc.h>
  22. #include <memory.h>
  23. #include <string.h>
  24.  
  25. #include "define.h"
  26.  
  27. /* -----------------------MACROS------------------------------ */
  28.  
  29. #define PIXEL(p,x,y)    (p->pixmap[y * (long) p->wide + x])
  30. #define SQUARE(x)         (((long) x)*(x))
  31.  
  32. /* ----------------------PROTOTYPES--------------------------- */
  33.  
  34. /**** line routines ****/
  35. int        xorLine(int x1, int y1, int x2, int y2);
  36. int        getLine(int *argx1, int *argy1, int *argx2, int *argy2);
  37. int        findPoint(LINE_LIST *lineList, int * line, int * point,
  38.                                                 int x, int y);
  39. int        movePoint();
  40.  
  41. /**** warping and morphing routines ****/
  42. int        sumLines(PICTURE *picture, COLOR *color, LINE *origline,
  43.                                     POINT *warp, LINE *warpline);
  44. float    getSourceLoc(POINT *orig, LINE *origline, POINT *warp,
  45.                                     LINE *warpline);
  46. int        setLength(LINE *line);
  47.  
  48. void    setupScreen(PICTURE *pic, int editFlag);
  49.  
  50. /* ----------------------EXTERNALS---------------------------- */
  51.  
  52. /* set from last picture loaded */
  53. extern int        Xmin, Ymin, Xmax, Ymax;
  54.  
  55. extern int        NumLines;
  56.  
  57. extern LINE        SrcLine[MAX_LINES];
  58. extern LINE        DstLine[MAX_LINES];
  59.  
  60. /* ----------------------GLOBAL DATA-------------------------- */
  61.  
  62. int        TargFlag=0;
  63.  
  64. /********   These are the basic warping calculations   **********/
  65.  
  66. /*****************************************************************
  67. * FUNC: int    sumLines(PICTURE *picture, COLOR *color,
  68. *                    LINE *origline, POINT *warp, LINE *warpline)
  69. * 
  70. * DESC: Sum and weight the contribution of each warping line
  71. *****************************************************************/
  72.  
  73. int
  74. sumLines(PICTURE *picture, COLOR *color, LINE *origline,
  75.                                     POINT *warp, LINE *warpline)
  76. {
  77.     int        x, y;
  78.     float    weight, weightSum;
  79.     float    distance;
  80.     int        line;
  81.     POINT    orig;
  82.     int        paletteIndex;
  83.     float    deltaSumX = 0.0;
  84.     float    deltaSumY = 0.0;
  85.  
  86.     /* if no control lines, get an unwarped pixel */
  87.     if (NumLines == 0)
  88.         orig = *warp;
  89.     else {
  90.         weightSum = 0.0;
  91.         for (line = 0; line < NumLines; line++,
  92.                             origline++, warpline++)    {
  93.             distance = getSourceLoc(&orig,origline,warp,warpline);
  94.             weight = 1/(.001+distance*distance);
  95.             deltaSumX += (orig.x - warp->x) * weight;
  96.             deltaSumY += (orig.y - warp->y) * weight;
  97.             weightSum += weight;
  98.         }
  99.         orig.x = warp->x + deltaSumX / weightSum + .5;
  100.         orig.y = warp->y + deltaSumY / weightSum + .5;
  101.     }
  102.  
  103.     /* clip it to the nearest border pixel */
  104.     x = clip(orig.x, Xmin, Xmax);
  105.     y = clip(orig.y, Ymin, Ymax);
  106.     paletteIndex = PIXEL (picture, x, y);
  107.     color->r = picture->pal.c[paletteIndex].r;
  108.     color->g = picture->pal.c[paletteIndex].g;
  109.     color->b = picture->pal.c[paletteIndex].b;
  110.     return (paletteIndex);
  111. }
  112.  
  113. /*****************************************************************
  114. * FUNC: float getSourceLoc(POINT *orig, LINE *origline,
  115. *                                    POINT *warp, LINE *warpline)
  116. * 
  117. * DESC: For a given line, locate the corresponding warped pixel
  118. *****************************************************************/
  119.  
  120. float
  121. getSourceLoc(POINT *orig, LINE *origline, POINT *warp,
  122.                                                 LINE *warpline)
  123. {
  124.     float fraction, fdist;
  125.     int dx, dy;
  126.     float distance;
  127.  
  128.     dx = warp->x - warpline->p[0].x;
  129.     dy = warp->y - warpline->p[0].y;
  130.     fraction = (dx * (long) warpline->delta_x + dy
  131.                 * (long) warpline->delta_y)
  132.                 / (float) (warpline->length_square);
  133.     fdist = (dx * (long) -warpline->delta_y + dy
  134.                 * (long) warpline->delta_x)
  135.                 / (float) warpline->length;
  136.     if (fraction <= 0 )
  137.         distance = sqrt(dx*(long) dx + dy * (long) dy);
  138.     else if (fraction >= 1) {
  139.         dx = warp->x - warpline->p[1].x;
  140.         dy = warp->y - warpline->p[1].y;
  141.         distance = sqrt(dx*(long) dx + dy * (long) dy);
  142.     }                 
  143.     else if (fdist >= 0)
  144.         distance =  fdist;
  145.     else
  146.         distance = -fdist;
  147.     orig->x = origline->p[0].x + fraction * origline->delta_x -
  148.                 fdist * origline->delta_y
  149.                 / (float) origline->length + .5;
  150.     orig->y = origline->p[0].y + fraction * origline->delta_y +
  151.                 fdist * origline->delta_x
  152.                 / (float) origline->length + .5;
  153.     return distance;
  154. }
  155.  
  156. /*****************************************************************
  157. * FUNC: int    setLength(LINE *line)
  158. * 
  159. * DESC: Set the deltas, the length and the length squared
  160. *        for a given line.
  161. *****************************************************************/
  162.  
  163. int
  164. setLength (LINE *line)
  165. {
  166.     line->delta_x = line->p[1].x - line->p[0].x;
  167.     line->delta_y = line->p[1].y - line->p[0].y;
  168.     line->length_square = SQUARE(line->delta_x)
  169.                         + SQUARE(line->delta_y);
  170.     line->length = sqrt(line->length_square);
  171. }
  172.  
  173. /*********************  The line routines  **********************/
  174.  
  175. /*****************************************************************
  176. * FUNC: int    xorLine(int x1, int y1, int x2, int y2)
  177. * 
  178. * DESC: Draw a line on the screen using the XOR of the
  179. *        screen index.
  180. *****************************************************************/
  181.  
  182. int
  183. xorLine(int x1, int y1, int x2, int y2)
  184. {
  185.     int oldcolor = _getcolor();
  186.  
  187.     _setcolor(WHITE);            /* Use white as the xor color */
  188.     _setwritemode(_GXOR);
  189.     _moveto (x1,y1);
  190.     _lineto (x2,y2);
  191.     _setcolor(oldcolor);    /* restore the old color */
  192. }
  193.  
  194. /*****************************************************************
  195. * FUNC: int    getLine(int *argx1, int *argy1, int *argx2, int*argy2)
  196. * 
  197. * DESC: Input a line on the screen with the mouse.
  198. *****************************************************************/
  199.  
  200. int
  201. getLine (int *argx1, int *argy1, int *argx2, int *argy2)
  202. {
  203.     int        x1,y1, x2,y2;
  204.     int        oldx, oldy;
  205.     int        input;
  206.  
  207.     /* save the current mode */
  208.     short    old_mode = _getwritemode();
  209.  
  210.     /* get input until we have a real line, not just a point */
  211.     do {
  212.         /* wait for button or key press */
  213.         while (!(input = mousePos (&x1, &y1)));
  214.         if (input & KEYPRESS) {
  215.             _setwritemode(old_mode);
  216.             return 1;
  217.         }
  218.         oldx=x1, oldy=y1;
  219.         hideMouse();
  220.         /* prime the pump with this dot */
  221.         xorLine (x1, y1, oldx, oldy);
  222.         showMouse();
  223.         while (input = mousePos (&x2, &y2)) {
  224.             /* rubber band a line while the mouse is dragged */
  225.             if (x2 != oldx || y2 != oldy)
  226.             {
  227.                 hideMouse();
  228.                 xorLine (x1, y1, oldx, oldy);
  229.                 xorLine (x1, y1, x2, y2);
  230.                 showMouse();
  231.                 oldx=x2, oldy=y2;
  232.             }
  233.         }
  234.     } while (x1 == x2 && y1 == y2);
  235.  
  236.     *argx1 = x1, *argy1 = y1;
  237.     *argx2 = x2, *argy2 = y2;
  238.  
  239.     _setwritemode(old_mode);        /* get out of XOR mode */
  240.     return (0);
  241. }
  242.  
  243. /*****************************************************************
  244. * FUNC: int    findPoint(LINE_LIST *lineList, int * line,
  245. *        int * point, int x, int y)
  246. * 
  247. * DESC: loop thru dstline and find point within GRAB_DISTANCE,
  248. *        return 1 if found, 0 otherwise.
  249. *****************************************************************/
  250.  
  251. int
  252. findPoint (LINE_LIST *lineList, int * line, int * point,
  253.                                                     int x, int y)
  254. {
  255.     int l, p;
  256.     int minl, minp;
  257.     long length;
  258.     long minlength = SQUARE(640) + SQUARE(480);
  259.  
  260.     for (l = 0; l < lineList->number; l++) {
  261.         for (p = 0; p <= 1; p++) {
  262.             length = SQUARE(lineList->line[l].p[p].x - x)
  263.                    + SQUARE(lineList->line[l].p[p].y - y);
  264.             if (length < minlength) {
  265.                 minlength = length;
  266.                 minl = l;
  267.                 minp = p;
  268.             }
  269.         }
  270.     }
  271.     if (minlength > GRAB_DISTANCE)
  272.         return 0;
  273.     *line = minl;
  274.     *point = minp;
  275.     return 1;
  276. }
  277.  
  278. /*****************************************************************
  279. * FUNC: int    movePoint(LINE_LIST *lineList)
  280. * 
  281. * DESC: Grab a point and move it. Return 1 when key is pressed,
  282. *        else return 0.
  283. *****************************************************************/
  284.  
  285. int
  286. movePoint(LINE_LIST *lineList)
  287. {
  288.     int        stuckx, stucky, movex,movey;
  289.     int        oldx, oldy;
  290.     int        input;
  291.     int     line, point;
  292.  
  293.     /* save the current mode */
  294.     short    old_mode = _getwritemode();
  295.  
  296.     do {
  297.         /* keep getting input until we have a mouse button */
  298.         while (!(input = mousePos (&movex, &movey)));
  299.         if (input & KEYPRESS) {
  300.             _setwritemode(old_mode);
  301.             return 1;
  302.         }
  303.         if (!findPoint(lineList, &line, &point, movex, movey)) {
  304.             _setwritemode(old_mode);
  305.             return 0;
  306.         }
  307.  
  308.         /* establish fixed end point */
  309.         stuckx = lineList->line[line].p[1-point].x;
  310.         stucky = lineList->line[line].p[1-point].y;
  311.  
  312.         oldx=movex, oldy=movey;
  313.         hideMouse();
  314.         /* erase the old line */
  315.         xorLine (stuckx,
  316.                 stucky,
  317.                 lineList->line[line].p[point].x,
  318.                 lineList->line[line].p[point].y);
  319.         /* and prime the pump with the new line */
  320.         xorLine (stuckx, stucky, oldx, oldy);
  321.         showMouse();
  322.  
  323.         while (input = mousePos (&movex, &movey)) {
  324.             /* rubber band a line while the mouse is dragged */
  325.             if (movex != oldx || movey != oldy) {
  326.                 hideMouse();
  327.                 xorLine (stuckx, stucky, oldx, oldy);
  328.                 xorLine (stuckx, stucky, movex, movey);
  329.                 showMouse();
  330.                 oldx=movex, oldy=movey;
  331.             }
  332.         }
  333.     } while (stuckx == movex && stucky == movey);
  334.  
  335.     lineList->line[line].p[point].x = movex;
  336.     lineList->line[line].p[point].y = movey;
  337.  
  338.     _setwritemode(old_mode);        /* get out of XOR mode */
  339.     return (0);
  340. }
  341.  
  342. /*****************************************************************
  343. * FUNC: void    createLines(PICTURE *pic, LINE_LIST *lineList)
  344. * 
  345. * DESC: create a list of line segments for a picture
  346. *****************************************************************/
  347.  
  348. void
  349. createLines(PICTURE *pic, LINE_LIST *lineList)
  350. {
  351.     setupScreen(pic, 0);    /* set for enter prompt */
  352.  
  353.     initMouse();
  354.     showMouse();
  355.     for (lineList->number = 0;lineList->number < MAX_LINES;
  356.                                         lineList->number++) {
  357.         if (getLine(&lineList->line[lineList->number].p[0].x,
  358.                     &lineList->line[lineList->number].p[0].y,
  359.                     &lineList->line[lineList->number].p[1].x,
  360.                     &lineList->line[lineList->number].p[1].y))
  361.             break;
  362.     }
  363.     hideMouse();
  364. }
  365.  
  366.  
  367. /*****************************************************************
  368. * FUNC: void    editLines(PICTURE *pic, LINE_LIST *lineList)
  369. * 
  370. * DESC: move around some existing lines
  371. *****************************************************************/
  372.  
  373. void
  374. editLines(PICTURE *pic, LINE_LIST *lineList)
  375. {
  376.     int segment;
  377.  
  378.     setupScreen(pic, 1);    /* set for edit prompt */
  379.  
  380.     initMouse();
  381.     for (segment = 0; segment < lineList->number; segment++) {
  382.         xorLine(lineList->line[segment].p[0].x,
  383.                 lineList->line[segment].p[0].y,
  384.                 lineList->line[segment].p[1].x,
  385.                 lineList->line[segment].p[1].y);
  386.     }
  387.     showMouse();
  388.     /* move the endpoints around */
  389.     while(!movePoint(lineList));
  390.     hideMouse();
  391. }
  392.  
  393. /*****************************************************************
  394. * FUNC: void    setupScreen(PICTURE *pic, int editFlag)
  395. * 
  396. * DESC: Print a message introducing the screen, wait for input,
  397. *        then set the graphics mode and display the screen.
  398. *****************************************************************/
  399.  
  400. void
  401. setupScreen(PICTURE *pic, int editFlag)
  402. {
  403.     static char *editMess[2] = {"enter", "edit"};
  404.     static char *targMess[2] = {"source", "target"};
  405.     setTextMode();
  406.  
  407.     _settextposition(VTAB, HTAB);
  408.     printf("When you are ready to %s the control lines",
  409.             editMess[editFlag]);
  410.     _settextposition(VTAB+2, HTAB);
  411.     printf("for the %s image, press any key.",
  412.             targMess[TargFlag]);
  413.     waitForKey();
  414.  
  415.     setGraphicsMode();
  416.     displayPicture(pic);
  417. }
  418.  
  419.