home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / path_curves.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-09  |  9.3 KB  |  329 lines
  1. /* The GIMP -- an image manipulation program
  2.  *
  3.  * This file Copyright (C) 1999 Simon Budig
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18.  */
  19.  
  20. #include <math.h>
  21. #include "path_curves.h"
  22. #include "path_bezier.h"
  23.  
  24. /* only here temporarily */
  25. PathSegment * path_split_segment   (PathSegment *, gdouble);
  26.  
  27. /* Here the different curves register their functions */
  28.  
  29. static CurveDescription CurveTypes[] =
  30. { 
  31.     /* SEGMENT_LINE */
  32.    {
  33.       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  34.     },
  35.  
  36.     /* SEGMENT_BEZIER */
  37.    {
  38.       NULL, /* path_bezier_get_points, */
  39.       path_bezier_get_point,
  40.       path_bezier_draw_handles,
  41.       NULL, /* path_bezier_draw_segment, */
  42.       NULL, /* path_bezier_on_segment, */
  43.       path_bezier_drag_segment,
  44.       path_bezier_on_handles,
  45.       path_bezier_drag_handles, 
  46.       NULL, /* path_bezier_insert_anchor, */
  47.       NULL, /* path_bezier_update_segment, */
  48.       path_bezier_flip_segment,
  49.       path_bezier_init_segment,
  50.       NULL /* path_bezier_cleanup_segment */
  51.     }
  52. };
  53.  
  54.  
  55. /*
  56.  * these functions implement the dispatching for the different
  57.  * curve-types. It implements default actions, which happen
  58.  * to work with straight lines.
  59.  */
  60.  
  61.  
  62. guint
  63. path_curve_get_points (PathTool *path_tool,
  64.                        PathSegment *segment,
  65.                GdkPoint *points,
  66.                guint npoints,
  67.                gdouble start,
  68.                gdouble end)
  69. {
  70.    gdouble pos, x, y;
  71.    gint index=0;
  72.  
  73.    if (segment && segment->next) {
  74.       if (CurveTypes[segment->type].get_points)
  75.      return (* CurveTypes[segment->type].get_points) (path_tool, segment, points, npoints, start, end);
  76.       else {
  77.      if (npoints > 1 && segment && segment->next) {
  78.            for (pos = start; pos <= end; pos += (end - start) / (npoints -1)) {
  79.               path_curve_get_point (path_tool, segment, pos, &x, &y);
  80.               points[index].x = (guint) (x + 0.5);
  81.               points[index].y = (guint) (y + 0.5);
  82.               index++;
  83.            }
  84.            return index;
  85.           } else
  86.                return 0;
  87.       }
  88.    }
  89. #ifdef PATH_TOOL_DEBUG
  90.    else
  91.       fprintf (stderr, "path_curve_get_point called without valid curve");
  92. #endif
  93.    return 0;
  94. }
  95.  
  96.  
  97. void
  98. path_curve_get_point (PathTool *path_tool,
  99.               PathSegment *segment,
  100.               gdouble position,
  101.               gdouble *x,
  102.               gdouble *y)
  103. {
  104.    if (segment && segment->next) {
  105.       if (CurveTypes[segment->type].get_point)
  106.      (* CurveTypes[segment->type].get_point) (path_tool, segment, position, x, y);
  107.       else {
  108. #if 0
  109.      *x = segment->x + (segment->next->x - segment->x) * position;
  110.          *y = segment->y + (segment->next->y - segment->y) * position;
  111. #else
  112.      /* Only here for debugging purposes: A bezier curve fith fixed tangents */
  113.  
  114.      *x = (1-position)*(1-position)*(1-position) * segment->x +
  115.         3 * position *(1-position)*(1-position) * (segment->x - 60) +
  116.         3 * position * position *(1-position) * (segment->next->x + 60) +
  117.         position * position * position * (segment->next->x);
  118.      *y = (1-position)*(1-position)*(1-position) * segment->y +
  119.         3 * position *(1-position)*(1-position) * (segment->y + 60) +
  120.         3 * position * position *(1-position) * (segment->next->y + 60) +
  121.         position * position * position * (segment->next->y);
  122. #endif
  123.       }
  124.    }
  125. #ifdef PATH_TOOL_DEBUG
  126.    else
  127.       fprintf (stderr, "path_curve_get_point called without valid curve");
  128. #endif
  129.    return;
  130. }
  131.  
  132. void
  133. path_curve_draw_handles (Tool *tool,
  134.              PathSegment *segment)
  135. {
  136.    if (segment && CurveTypes[segment->type].draw_handles)
  137.       (* CurveTypes[segment->type].draw_handles) (tool, segment);
  138.  
  139.    /* straight lines do not have handles... */
  140.    return;
  141. }
  142.               
  143. void
  144. path_curve_draw_segment (Tool *tool,
  145.              PathSegment *segment)
  146. {
  147.    gint x, y, numpts, index;
  148.  
  149.    if (segment && segment->next) {
  150.       if (CurveTypes[segment->type].draw_segment) {
  151.          (* CurveTypes[segment->type].draw_segment) (tool, segment);
  152.          return;
  153.       } else {
  154.      GdkPoint *coordinates = g_new (GdkPoint, 100);
  155.          numpts = path_curve_get_points (((PathTool *) tool->private), segment,
  156.                          coordinates, 100, 0, 1);
  157.      for (index=0; index < numpts; index++) {
  158.         gdisplay_transform_coords (tool->gdisp_ptr,
  159.                                coordinates[index].x,
  160.                        coordinates[index].y,
  161.                        &x, &y, FALSE);
  162.         coordinates[index].x = x;
  163.         coordinates[index].y = y;
  164.      }
  165.      gdk_draw_lines (((PathTool *) tool->private)->core->win,
  166.                      ((PathTool *) tool->private)->core->gc,
  167.              coordinates, numpts);
  168.      g_free (coordinates);
  169.       }
  170.  
  171. #ifdef PATH_TOOL_DEBUG
  172.    } else {
  173.       fprintf (stderr, "Fatal Error: path_curve_draw_segment called without valid segment *\n");
  174. #endif
  175.       
  176.    }
  177.  
  178.    return;
  179. }
  180.               
  181.  
  182. gdouble
  183. path_curve_on_segment (Tool *tool,
  184.                PathSegment *segment,
  185.                gint x,
  186.                gint y,
  187.                gint halfwidth,
  188.                gint *distance)
  189. {
  190.  
  191.    if (segment && CurveTypes[segment->type].on_segment)
  192.       return (* CurveTypes[segment->type].on_segment) (tool, segment, x, y, halfwidth, distance);
  193.    else {
  194.       if (segment && segment->next) {
  195. #if 1
  196.      gint x1, y1, numpts, index;
  197.      GdkPoint *coordinates = g_new (GdkPoint, 100);
  198.      gint bestindex = -1;
  199.  
  200.      *distance = halfwidth * halfwidth + 1;
  201.  
  202.          numpts = path_curve_get_points (((PathTool *) tool->private), segment,
  203.                          coordinates, 100, 0, 1);
  204.      for (index=0; index < numpts; index++) {
  205.         x1 = coordinates[index].x;
  206.         y1 = coordinates[index].y;
  207.         if (((x - x1) * (x - x1) + (y - y1) * (y - y1)) < *distance) {
  208.            *distance = (x - x1) * (x - x1) + (y - y1) * (y - y1);
  209.            bestindex = index;
  210.         }
  211.      }
  212.      g_free (coordinates);
  213.      if (numpts == 1) {
  214.         *distance = (gint) sqrt ((gdouble) *distance);
  215.         return bestindex;
  216.      }
  217.      if (bestindex >= 0 && (*distance <= halfwidth * halfwidth)) {
  218.         *distance = (gint) sqrt ((gdouble) *distance);
  219.         return bestindex == 0 ? 0 : ((gdouble) bestindex) / (numpts - 1);
  220.      }
  221.  
  222. #else
  223.  
  224.          /* Special case for lines */
  225.          gdouble Ax, Ay, Bx, By, r, d;
  226.          Ax = segment->x;
  227.          Ay = segment->y;
  228.          Bx = segment->next->x;
  229.          By = segment->next->y;
  230.  
  231.          r = (( x - Ax)*(Bx - Ax) + ( y - Ay)* (By - Ay)) /
  232.              ((Bx - Ax)*(Bx - Ax) + (By - Ay)* (By - Ay)) ;
  233.  
  234.          if (r >= 0 && r <= 1) {
  235.             d = (((Ax + (Bx - Ax) * r) - x) * ((Ax + (Bx - Ax) * r) - x) +
  236.              ((Ay + (By - Ay) * r) - y) * ((Ay + (By - Ay) * r) - y));
  237.         if (d <= halfwidth * halfwidth) {
  238.            *distance = (gint) (d + 0.5);
  239.                return r;
  240.         }
  241.      }
  242. #endif
  243.       }
  244.    }
  245.       
  246.    return -1;
  247. }
  248.  
  249. void
  250. path_curve_drag_segment (PathTool *path_tool,
  251.              PathSegment *segment,
  252.              gdouble position,
  253.              gdouble dx,
  254.              gdouble dy)
  255. {
  256.    if (segment && CurveTypes[segment->type].drag_segment)
  257.       (* CurveTypes[segment->type].drag_segment) (path_tool, segment, position, dx, dy);
  258.    return;
  259. }
  260.  
  261. gint
  262. path_curve_on_handle (PathTool *path_tool,
  263.               PathSegment *segment,
  264.               gdouble x,
  265.               gdouble y,
  266.               gdouble halfwidth)
  267. {
  268.    if (segment && CurveTypes[segment->type].on_handles)
  269.       return (* CurveTypes[segment->type].on_handles) (path_tool, segment, x, y, halfwidth);
  270.    return FALSE;
  271. }
  272.  
  273. void
  274. path_curve_drag_handle (PathTool *path_tool,
  275.             PathSegment *segment,
  276.             gdouble dx,
  277.             gdouble dy,
  278.             gint handle_id)
  279. {
  280.    if (segment && CurveTypes[segment->type].drag_handle)
  281.       (* CurveTypes[segment->type].drag_handle) (path_tool, segment, dx, dy, handle_id);
  282. }
  283.  
  284. PathSegment *
  285. path_curve_insert_anchor (PathTool *path_tool,
  286.               PathSegment *segment,
  287.               gdouble position)
  288. {
  289.    if (segment && CurveTypes[segment->type].insert_anchor)
  290.       return (* CurveTypes[segment->type].insert_anchor) (path_tool, segment, position);
  291.    else {
  292.       return path_split_segment (segment, position);
  293.    }
  294. }
  295.  
  296. void
  297. path_curve_flip_segment (PathSegment *segment)
  298. {
  299.    if (segment && CurveTypes[segment->type].flip_segment)
  300.       (* CurveTypes[segment->type].flip_segment) (segment);
  301.    return;
  302. }
  303.  
  304. void
  305. path_curve_update_segment (PathTool *path_tool,
  306.                PathSegment *segment)
  307. {
  308.    if (segment && CurveTypes[segment->type].update_segment)
  309.       (* CurveTypes[segment->type].update_segment) (path_tool, segment);
  310.    return;
  311. }
  312.  
  313. void
  314. path_curve_init_segment (PathSegment *segment)
  315. {
  316.    if (segment && CurveTypes[segment->type].init_segment)
  317.       (* CurveTypes[segment->type].init_segment) (segment);
  318.    return;
  319. }
  320.  
  321. void
  322. path_curve_cleanup_segment (PathSegment *segment)
  323. {
  324.    if (segment && CurveTypes[segment->type].cleanup_segment)
  325.       (* CurveTypes[segment->type].cleanup_segment) (segment);
  326.    return;
  327. }
  328.  
  329.