home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / gimpbrushgenerated.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-20  |  12.6 KB  |  529 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * gimp_brush_generated module Copyright 1998 Jay Cox <jaycox@earthlink.net>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19.  */
  20.  
  21. #include "config.h"
  22.  
  23. #include <stdio.h>
  24. #include <string.h>
  25.  
  26. #ifdef HAVE_UNISTD_H
  27. #include <unistd.h>
  28. #endif
  29.  
  30. #include <glib.h>
  31.  
  32. #include "apptypes.h"
  33.  
  34. #include "appenv.h"
  35. #include "gimpbrushgenerated.h"
  36. #include "paint_core.h"
  37. #include "gimprc.h"
  38. #include "gimpbrush.h"
  39.  
  40. #include "libgimp/gimpmath.h"
  41.  
  42. #define OVERSAMPLING 5
  43.  
  44.  
  45. static void gimp_brush_generated_generate (GimpBrushGenerated *brush);
  46.  
  47.  
  48. static GimpObjectClass *parent_class = NULL;
  49.  
  50.  
  51. static void
  52. gimp_brush_generated_destroy (GtkObject *object)
  53. {
  54.   if (GTK_OBJECT_CLASS (parent_class)->destroy)
  55.     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
  56. }
  57.  
  58. static void
  59. gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
  60. {
  61.   GtkObjectClass *object_class;
  62.  
  63.   object_class = GTK_OBJECT_CLASS (klass);
  64.  
  65.   parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
  66.  
  67.   object_class->destroy = gimp_brush_generated_destroy;
  68. }
  69.  
  70. static void
  71. gimp_brush_generated_init (GimpBrushGenerated *brush)
  72. {
  73.   brush->radius       = 5.0;
  74.   brush->hardness     = 0.0;
  75.   brush->angle        = 0.0;
  76.   brush->aspect_ratio = 1.0;
  77.   brush->freeze       = 0;
  78. }
  79.  
  80. guint
  81. gimp_brush_generated_get_type (void)
  82. {
  83.   static GtkType type = 0;
  84.  
  85.   if (!type)
  86.     {
  87.       GtkTypeInfo info =
  88.       {
  89.     "GimpBrushGenerated",
  90.     sizeof (GimpBrushGenerated),
  91.     sizeof (GimpBrushGeneratedClass),
  92.     (GtkClassInitFunc) gimp_brush_generated_class_init,
  93.     (GtkObjectInitFunc) gimp_brush_generated_init,
  94.     /* reserved_1 */ NULL,
  95.     /* reserved_2 */ NULL,
  96.     (GtkClassInitFunc) NULL
  97.       };
  98.  
  99.       type = gtk_type_unique (GIMP_TYPE_BRUSH, &info);
  100.     }
  101.  
  102.   return type;
  103. }
  104.  
  105. GimpBrush *
  106. gimp_brush_generated_new (gfloat radius,
  107.               gfloat hardness,
  108.               gfloat angle,
  109.               gfloat aspect_ratio)
  110. {
  111.   GimpBrushGenerated *brush;
  112.  
  113.   /* set up normal brush data */
  114.   brush =
  115.     GIMP_BRUSH_GENERATED (gtk_type_new (gimp_brush_generated_get_type ()));
  116.  
  117.   GIMP_BRUSH (brush)->name    = g_strdup ("Untitled");
  118.   GIMP_BRUSH (brush)->spacing = 20;
  119.  
  120.   /* set up gimp_brush_generated data */
  121.   brush->radius       = radius;
  122.   brush->hardness     = hardness;
  123.   brush->angle        = angle;
  124.   brush->aspect_ratio = aspect_ratio;
  125.  
  126.   /* render brush mask */
  127.   gimp_brush_generated_generate (brush);
  128.  
  129.   return GIMP_BRUSH (brush);
  130. }
  131.  
  132. GimpBrush *
  133. gimp_brush_generated_load (const gchar *file_name)
  134. {
  135.   GimpBrushGenerated *brush;
  136.   FILE   *fp;
  137.   gchar   string[256];
  138.   gfloat  fl;
  139.   gfloat  version;
  140.  
  141.   if ((fp = fopen (file_name, "rb")) == NULL)
  142.     return NULL;
  143.  
  144.   /* make sure the file we are reading is the right type */
  145.   fgets (string, 255, fp);
  146.   
  147.   if (strncmp (string, "GIMP-VBR", 8) != 0)
  148.     return NULL;
  149.   
  150.   /* make sure we are reading a compatible version */
  151.   fgets (string, 255, fp);
  152.   sscanf (string, "%f", &version);
  153.   g_return_val_if_fail (version < 2.0, NULL);
  154.  
  155.   /* create new brush */
  156.   brush =
  157.     GIMP_BRUSH_GENERATED (gtk_type_new (gimp_brush_generated_get_type ()));
  158.  
  159.   GIMP_BRUSH (brush)->filename = g_strdup (file_name);
  160.  
  161.   gimp_brush_generated_freeze (brush);
  162.  
  163.   /* read name */
  164.   fgets (string, 255, fp);
  165.   if (string[strlen (string) - 1] == '\n')
  166.     string[strlen (string) - 1] = 0;
  167.   GIMP_BRUSH (brush)->name = g_strdup (string);
  168.  
  169.   /* read brush spacing */
  170.   fscanf (fp, "%f", &fl);
  171.   GIMP_BRUSH (brush)->spacing = fl;
  172.  
  173.   /* read brush radius */
  174.   fscanf (fp, "%f", &fl);
  175.   gimp_brush_generated_set_radius (brush, fl);
  176.  
  177.   /* read brush hardness */
  178.   fscanf (fp, "%f", &fl);
  179.   gimp_brush_generated_set_hardness (brush, fl);
  180.  
  181.   /* read brush aspect_ratio */
  182.   fscanf (fp, "%f", &fl);
  183.   gimp_brush_generated_set_aspect_ratio (brush, fl);
  184.  
  185.   /* read brush angle */
  186.   fscanf (fp, "%f", &fl);
  187.   gimp_brush_generated_set_angle (brush, fl);
  188.  
  189.   fclose (fp);
  190.  
  191.   gimp_brush_generated_thaw (brush);
  192.  
  193.   if (stingy_memory_use)
  194.     temp_buf_swap (GIMP_BRUSH (brush)->mask);
  195.  
  196.   return GIMP_BRUSH (brush);
  197. }
  198.  
  199. void
  200. gimp_brush_generated_save (GimpBrushGenerated *brush, 
  201.                const gchar        *file_name)
  202. {
  203.   FILE *fp;
  204.  
  205.   if ((fp = fopen (file_name, "wb")) == NULL)
  206.     {
  207.       g_warning ("Unable to save file %s", file_name);
  208.       return;
  209.     }
  210.  
  211.   /* write magic header */
  212.   fprintf (fp, "GIMP-VBR\n");
  213.  
  214.   /* write version */
  215.   fprintf (fp, "1.0\n");
  216.  
  217.   /* write name */
  218.   fprintf (fp, "%.255s\n", GIMP_BRUSH (brush)->name);
  219.  
  220.   /* write brush spacing */
  221.   fprintf (fp, "%f\n", (float) GIMP_BRUSH (brush)->spacing);
  222.  
  223.   /* write brush radius */
  224.   fprintf (fp, "%f\n", brush->radius);
  225.  
  226.   /* write brush hardness */
  227.   fprintf (fp, "%f\n", brush->hardness);
  228.  
  229.   /* write brush aspect_ratio */
  230.   fprintf (fp, "%f\n", brush->aspect_ratio);
  231.  
  232.   /* write brush angle */
  233.   fprintf (fp, "%f\n", brush->angle);
  234.  
  235.   fclose (fp);
  236. }
  237.  
  238. void
  239. gimp_brush_generated_delete (GimpBrushGenerated *brush)
  240. {
  241.   if (GIMP_BRUSH (brush)->filename)
  242.     {
  243.       unlink (GIMP_BRUSH (brush)->filename);
  244.     }
  245. }
  246.  
  247. void
  248. gimp_brush_generated_freeze (GimpBrushGenerated *brush)
  249. {
  250.   g_return_if_fail (brush != NULL);
  251.   g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
  252.  
  253.   brush->freeze++;
  254. }
  255.  
  256. void
  257. gimp_brush_generated_thaw (GimpBrushGenerated *brush)
  258. {
  259.   g_return_if_fail (brush != NULL);
  260.   g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
  261.   
  262.   if (brush->freeze > 0)
  263.     brush->freeze--;
  264.  
  265.   if (brush->freeze == 0)
  266.     gimp_brush_generated_generate (brush);
  267. }
  268.  
  269. static double
  270. gauss (gdouble f)
  271. { 
  272.   /* this aint' a real gauss function */
  273.   if (f < -.5)
  274.     {
  275.       f = -1.0 - f;
  276.       return (2.0 * f*f);
  277.     }
  278.  
  279.   if (f < .5)
  280.     return (1.0 - 2.0 * f*f);
  281.  
  282.   f = 1.0 -f;
  283.   return (2.0 * f*f);
  284. }
  285.  
  286. void
  287. gimp_brush_generated_generate (GimpBrushGenerated *brush)
  288. {
  289.   register GimpBrush *gbrush = NULL;
  290.   register gint       x, y;
  291.   register guchar    *centerp;
  292.   register gdouble    d;
  293.   register gdouble    exponent;
  294.   register guchar     a;
  295.   register gint       length;
  296.   register guchar    *lookup;
  297.   register gdouble    sum, c, s, tx, ty;
  298.   gdouble buffer[OVERSAMPLING];
  299.   gint    width, height;
  300.  
  301.   g_return_if_fail (brush != NULL);
  302.   g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
  303.   
  304.   if (brush->freeze) /* if we are frozen defer rerendering till later */
  305.     return;
  306.  
  307.   gbrush = GIMP_BRUSH (brush);
  308.  
  309.   if (stingy_memory_use && gbrush->mask)
  310.     temp_buf_unswap (gbrush->mask);
  311.  
  312.   if (gbrush->mask)
  313.     {
  314.       temp_buf_free(gbrush->mask);
  315.     }
  316.  
  317.   /* compute the range of the brush. should do a better job than this? */
  318.   s = sin (gimp_deg_to_rad (brush->angle));
  319.   c = cos (gimp_deg_to_rad (brush->angle));
  320.  
  321.   tx = MAX (fabs (c*ceil (brush->radius) - s*ceil (brush->radius)
  322.           / brush->aspect_ratio), 
  323.         fabs (c*ceil (brush->radius) + s*ceil (brush->radius)
  324.           / brush->aspect_ratio));
  325.   ty = MAX (fabs (s*ceil (brush->radius) + c*ceil (brush->radius)
  326.           / brush->aspect_ratio),
  327.         fabs (s*ceil (brush->radius) - c*ceil (brush->radius)
  328.           / brush->aspect_ratio));
  329.  
  330.   if (brush->radius > tx)
  331.     width = ceil (tx);
  332.   else
  333.     width = ceil (brush->radius);
  334.  
  335.   if (brush->radius > ty)
  336.     height = ceil (ty);
  337.   else
  338.     height = ceil (brush->radius);
  339.  
  340.   /* compute the axis for spacing */
  341.   GIMP_BRUSH (brush)->x_axis.x =        c * brush->radius;
  342.   GIMP_BRUSH (brush)->x_axis.y = -1.0 * s * brush->radius;
  343.  
  344.   GIMP_BRUSH (brush)->y_axis.x = (s * brush->radius / brush->aspect_ratio);
  345.   GIMP_BRUSH (brush)->y_axis.y = (c * brush->radius / brush->aspect_ratio);
  346.   
  347.   gbrush->mask = temp_buf_new (width * 2 + 1,
  348.                    height * 2 + 1,
  349.                    1, width, height, 0);
  350.   centerp = &gbrush->mask->data[height * gbrush->mask->width + width];
  351.  
  352.   if ((1.0 - brush->hardness) < 0.000001)
  353.     exponent = 1000000; 
  354.   else
  355.     exponent = 1/(1.0 - brush->hardness);
  356.  
  357.   /* set up lookup table */
  358.   length = ceil (sqrt (2 * ceil (brush->radius+1) * ceil (brush->radius+1))+1) * OVERSAMPLING;
  359.   lookup = g_malloc (length);
  360.   sum = 0.0;
  361.  
  362.   for (x = 0; x < OVERSAMPLING; x++)
  363.     {
  364.       d = fabs ((x + 0.5) / OVERSAMPLING - 0.5);
  365.       if (d > brush->radius)
  366.     buffer[x] = 0.0;
  367.       else
  368.     /* buffer[x] =  (1.0 - pow (d/brush->radius, exponent)); */
  369.     buffer[x] = gauss (pow (d/brush->radius, exponent));
  370.       sum += buffer[x];
  371.     }
  372.  
  373.   for (x = 0; d < brush->radius || sum > 0.00001; d += 1.0 / OVERSAMPLING)
  374.     {
  375.       sum -= buffer[x % OVERSAMPLING];
  376.       if (d > brush->radius)
  377.     buffer[x % OVERSAMPLING] = 0.0;
  378.       else
  379.     /* buffer[x%OVERSAMPLING] =  (1.0 - pow (d/brush->radius, exponent)); */
  380.     buffer[x % OVERSAMPLING] = gauss (pow (d/brush->radius, exponent));
  381.       sum += buffer[x%OVERSAMPLING];
  382.       lookup[x++] = RINT (sum * (255.0 / OVERSAMPLING));
  383.     }
  384.   while (x < length)
  385.     {
  386.       lookup[x++] = 0;
  387.     }
  388.   /* compute one half and mirror it */
  389.   for (y = 0; y <= height; y++)
  390.     {
  391.       for (x = -width; x <= width; x++)
  392.     {
  393.       tx = c*x - s*y;
  394.       ty = c*y + s*x;
  395.       ty *= brush->aspect_ratio;
  396.       d = sqrt (tx*tx + ty*ty);
  397.       if (d < brush->radius+1)
  398.         a = lookup[(gint) RINT (d * OVERSAMPLING)];
  399.       else
  400.         a = 0;
  401.       centerp[   y*gbrush->mask->width + x] = a;
  402.       centerp[-1*y*gbrush->mask->width - x] = a;
  403.     }
  404.     }
  405.   g_free (lookup);
  406.  
  407.   gtk_signal_emit_by_name (GTK_OBJECT (brush), "dirty");
  408. }
  409.  
  410. gfloat
  411. gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
  412.                  gfloat              radius)
  413. {
  414.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  415.  
  416.   if (radius < 0.0)
  417.     radius = 0.0;
  418.   else if (radius > 32767.0)
  419.     radius = 32767.0;
  420.  
  421.   if (radius == brush->radius)
  422.     return radius;
  423.  
  424.   brush->radius = radius;
  425.  
  426.   if (!brush->freeze)
  427.     gimp_brush_generated_generate (brush);
  428.  
  429.   return brush->radius;
  430. }
  431.  
  432. gfloat
  433. gimp_brush_generated_set_hardness (GimpBrushGenerated *brush,
  434.                    gfloat              hardness)
  435. {
  436.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  437.  
  438.   if (hardness < 0.0)
  439.     hardness = 0.0;
  440.   else if (hardness > 1.0)
  441.     hardness = 1.0;
  442.  
  443.   if (brush->hardness == hardness)
  444.     return hardness;
  445.  
  446.   brush->hardness = hardness;
  447.  
  448.   if (!brush->freeze)
  449.     gimp_brush_generated_generate (brush);
  450.  
  451.   return brush->hardness;
  452. }
  453.  
  454. gfloat
  455. gimp_brush_generated_set_angle (GimpBrushGenerated *brush,
  456.                 gfloat              angle)
  457. {
  458.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  459.  
  460.   if (angle < 0.0)
  461.     angle = -1.0 * fmod (angle, 180.0);
  462.   else if (angle > 180.0)
  463.     angle = fmod (angle, 180.0);
  464.  
  465.   if (brush->angle == angle)
  466.     return angle;
  467.  
  468.   brush->angle = angle;
  469.  
  470.   if (!brush->freeze)
  471.     gimp_brush_generated_generate (brush);
  472.  
  473.   return brush->angle;
  474. }
  475.  
  476. gfloat
  477. gimp_brush_generated_set_aspect_ratio (GimpBrushGenerated *brush,
  478.                        gfloat              ratio)
  479. {
  480.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  481.  
  482.   if (ratio < 1.0)
  483.     ratio = 1.0;
  484.   else if (ratio > 1000)
  485.     ratio = 1000;
  486.  
  487.   if (brush->aspect_ratio == ratio)
  488.     return ratio;
  489.  
  490.   brush->aspect_ratio = ratio;
  491.  
  492.   if (!brush->freeze)
  493.     gimp_brush_generated_generate(brush);
  494.  
  495.   return brush->aspect_ratio;
  496. }
  497.  
  498. gfloat
  499. gimp_brush_generated_get_radius (const GimpBrushGenerated *brush)
  500. {
  501.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  502.  
  503.   return brush->radius;
  504. }
  505.  
  506. gfloat
  507. gimp_brush_generated_get_hardness (const GimpBrushGenerated *brush)
  508. {
  509.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  510.  
  511.   return brush->hardness;
  512. }
  513.  
  514. gfloat
  515. gimp_brush_generated_get_angle (const GimpBrushGenerated *brush)
  516. {
  517.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  518.  
  519.   return brush->angle;
  520. }
  521.  
  522. gfloat
  523. gimp_brush_generated_get_aspect_ratio (const GimpBrushGenerated *brush)
  524. {
  525.   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
  526.  
  527.   return brush->aspect_ratio;
  528. }
  529.