home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / unofficial-plug-ins / mathmap / builtins.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-21  |  5.9 KB  |  291 lines
  1. /*
  2.  * builtins.c
  3.  *
  4.  * MathMap
  5.  *
  6.  * Copyright (C) 1997-2000 Mark Probst
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License
  10.  * as published by the Free Software Foundation; either version 2
  11.  * of the License, or (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23. #include <math.h>
  24. #include <string.h>
  25. #include <stdlib.h>
  26. #include <stdio.h>
  27. #include <assert.h>
  28.  
  29. #include <libgimp/gimp.h>
  30.  
  31. #include "builtins.h"
  32. #include "postfix.h"
  33. #include "tags.h"
  34. #include "overload.h"
  35. #include "mathmap.h"
  36.  
  37. extern gint preview_width, preview_height;
  38. extern guchar *fast_image_source;
  39. extern int imageWidth,
  40.     imageHeight,
  41.     previewing;
  42. extern gint sel_x1, sel_y1,
  43.     sel_width, sel_height;
  44. extern double middleX,
  45.     middleY;
  46. extern unsigned char *imageData;
  47. extern int intersamplingEnabled,
  48.     oversamplingEnabled;
  49. extern double user_curve_values[];
  50. extern int user_curve_points;
  51. extern tuple_t gradient_samples[];
  52. extern int num_gradient_samples;
  53. extern int edge_behaviour_color, edge_behaviour_wrap, edge_behaviour_reflect;
  54. extern int edge_behaviour_mode;
  55. extern unsigned char edge_color[4];
  56.  
  57. builtin *firstBuiltin = 0;
  58.  
  59. void mathmap_get_pixel (int drawable_index, int x, int y, unsigned char *pixel);
  60.  
  61. static void
  62. get_pixel (int x, int y, guchar *pixel, int drawable_index)
  63. { 
  64.     if (edge_behaviour_mode == edge_behaviour_wrap)
  65.     {
  66.     if (x < 0)
  67.         x = x % img_width + img_width;
  68.     else if (x >= img_width)
  69.         x %= img_width;
  70.     if (y < 0)
  71.         y = y % img_height + img_height;
  72.     else if (y >= img_height)
  73.         y %= img_height;
  74.     }
  75.     else if (edge_behaviour_mode == edge_behaviour_reflect)
  76.     {
  77.     if (x < 0)
  78.         x = -x % img_width;
  79.     else if (x >= img_width)
  80.         x = (img_width - 1) - (x % img_width);
  81.     if (y < 0)
  82.         y = -y % img_height;
  83.     else if (y >= img_height)
  84.         y = (img_height - 1) - (y % img_height);
  85.     }
  86.  
  87.     if (previewing)
  88.     {
  89.     x = (x - sel_x1) * preview_width / sel_width;
  90.     y = (y - sel_y1) * preview_height / sel_height;
  91.  
  92.     mathmap_get_fast_pixel(drawable_index, x, y, pixel);
  93.     }
  94.     else
  95.     mathmap_get_pixel(drawable_index, x, y, pixel);
  96. }
  97.  
  98. void
  99. getOrigValPixel (float x, float y, unsigned char *pixel, int drawable_index)
  100. {
  101.     x += originX + middleX;
  102.     y = -y + originY + middleY;
  103.  
  104.     if (!oversamplingEnabled)
  105.     {
  106.     x += 0.5;
  107.     y += 0.5;
  108.     }
  109.  
  110.     get_pixel(floor(x), floor(y), pixel, drawable_index);
  111. }
  112.  
  113. void
  114. getOrigValIntersamplePixel (float x, float y, unsigned char *pixel, int drawable_index)
  115. {
  116.     int x1,
  117.     x2,
  118.     y1,
  119.     y2;
  120.     float x2fact,
  121.     y2fact,
  122.     x1fact,
  123.     y1fact,
  124.     p1fact,
  125.     p2fact,
  126.     p3fact,
  127.     p4fact;
  128.     unsigned char pixel1a[4],
  129.     pixel2a[4],
  130.     pixel3a[4],
  131.     pixel4a[4];
  132.     unsigned char *pixel1 = pixel1a,
  133.     *pixel2 = pixel2a,
  134.     *pixel3 = pixel3a,
  135.     *pixel4 = pixel4a;
  136.     int i;
  137.  
  138.     x += middleX + originX;
  139.     y = -y + middleY + originY;
  140.  
  141.     x1 = floor(x);
  142.     x2 = x1 + 1;
  143.     y1 = floor(y);
  144.     y2 = y1 + 1;
  145.     x2fact = (x - x1);
  146.     y2fact = (y - y1);
  147.     x1fact = 1.0 - x2fact;
  148.     y1fact = 1.0 - y2fact;
  149.     p1fact = x1fact * y1fact;
  150.     p2fact = x1fact * y2fact;
  151.     p3fact = x2fact * y1fact;
  152.     p4fact = x2fact * y2fact;
  153.  
  154.     get_pixel(x1, y1, pixel1, drawable_index);
  155.     get_pixel(x1, y2, pixel2, drawable_index);
  156.     get_pixel(x2, y1, pixel3, drawable_index);
  157.     get_pixel(x2, y2, pixel4, drawable_index);
  158.  
  159.     for (i = 0; i < 4; ++i)
  160.     pixel[i] = pixel1[i] * p1fact
  161.         + pixel2[i] * p2fact
  162.         + pixel3[i] * p3fact
  163.         + pixel4[i] * p4fact;
  164. }
  165.  
  166. #define MAX_LINEAR_DIM       10
  167. #define MAT(r,c)             (a[exch[r] * dim + (c)])
  168. #define RHS(r)               (b[exch[r]])
  169.  
  170. void
  171. solve_linear_equations (int dim, float *a, float *b)
  172. {
  173.     float r[MAX_LINEAR_DIM];
  174.     int exch[MAX_LINEAR_DIM];
  175.     int i;
  176.  
  177.     assert(dim <= MAX_LINEAR_DIM);
  178.  
  179.     for (i = 0; i < dim; ++i)
  180.     exch[i] = i;
  181.  
  182.     for (i = 0; i < dim - 1; ++i)
  183.     {
  184.     int p;
  185.  
  186.     for (p = i; p < dim; ++p) /* find pivot element */
  187.         if (MAT(p, i) != 0.0)
  188.         break;
  189.  
  190.     if (p != dim)
  191.     {
  192.         int j;
  193.  
  194.         if (p != i)
  195.         {
  196.         int tmp;
  197.  
  198.         tmp = exch[p];
  199.         exch[p] = exch[i];
  200.         exch[i] = tmp;
  201.         }
  202.  
  203.         for (j = i + 1; j < dim; ++j)
  204.         {
  205.         if (MAT(j, i) != 0.0)
  206.         {
  207.             float f = MAT(i, i) / MAT(j, i);
  208.             int k;
  209.  
  210.             MAT(j, i) = 0.0;
  211.             for (k = i + 1; k < dim; ++k)
  212.             MAT(j, k) = MAT(j, k) * f - MAT(i, k);
  213.  
  214.             RHS(j) = RHS(j) * f - RHS(i);
  215.         }
  216.         }
  217.     }
  218.     }
  219.  
  220.     for (i = dim - 1; i >= 0; --i)
  221.     {
  222.     if (MAT(i, i) == 0.0)
  223.         RHS(i) = 0.0;    /* this should be an error condition */
  224.     else
  225.     {
  226.         int j;
  227.         float v = 0.0;
  228.  
  229.         for (j = i + 1; j < dim; ++j)
  230.         v += MAT(i, j) * r[j];
  231.  
  232.         r[i] = (RHS(i) - v) / MAT(i, i);
  233.     }
  234.     }
  235.  
  236.     for (i = 0; i < dim; ++i)
  237.     b[i] = r[i];
  238.  
  239.     /*
  240.     if (dim == 2)
  241.     {
  242.     float r[2];
  243.  
  244.     if (a[2] != 0)
  245.     {
  246.         r[1] = (b[0] - a[0] * b[1] / a[2]) / (a[1] - a[3] * a[0] / a[2]);
  247.         r[0] = (b[1] - a[3] * r[1]) / a[2];
  248.     }
  249.     else if (a[0] != 0)
  250.     {
  251.         r[1] = (b[1] - a[2] * b[0] / a[0]) / (a[3] - a[1] * a[2] / a[0]);
  252.         r[0] = (b[0] - a[1] * r[1]) / a[0];
  253.     }
  254.     else
  255.         r[0] = r[1] = 0;
  256.  
  257.     b[0] = r[0];
  258.     b[1] = r[1];
  259.     }
  260.     else
  261.     assert(0);
  262.     */
  263.  
  264.     /*
  265.     integer n = dim;
  266.     integer nrhs = 1;
  267.     integer lda = dim;
  268.     integer ldb = dim;
  269.     integer info;
  270.     integer ipiv[dim];
  271.  
  272.     sgesv_(&n, &nrhs, a, &lda, ipiv, b, &ldb, &info);
  273.     */
  274. }
  275.  
  276. #include "builtins_interpreter.c"
  277.  
  278. builtin_function_t
  279. builtin_with_name (const char *name)
  280. {
  281.     if (strcmp(name, "origVal") == 0)
  282.     {
  283.     if (intersamplingEnabled)
  284.         return builtin_origValXYIntersample;
  285.     else
  286.         return builtin_origValXY;
  287.     }
  288.  
  289.     return 0;
  290. }
  291.