Changeset 2904 for libpipi


Ignore:
Timestamp:
Oct 9, 2008, 1:50:46 AM (12 years ago)
Author:
Sam Hocevar
Message:

Start writing Visual Studio projects.

Location:
libpipi/trunk
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed
  • libpipi/trunk/pipi/colorstring.c

    r2902 r2904  
    3737struct color_table color_table[] =
    3838{
    39     {.name = "black"  , 1,   0,    0,    0},
    40     {.name = "white"  , 1,   1,    1,    1},
    41     {.name = "red"    , 1,   1,    0,    0},
    42     {.name = "green"  , 1,   0,    1,    0},
    43     {.name = "blue"   , 1,   0,    0,    1},
    44     {.name = "yellow" , 1,   1,    1,    0},
    45     {.name = "cyan"   , 1,   0,    1,    1},
    46     {.name = "magenta", 1,   1,    0,    1},
    47     {.name = "grey"   , 1,   0.5,  0.5,  0.5},
    48     {.name = "gray"   , 1,   0.5,  0.5,  0.5},
    49     {.name = "grey50" , 1,   0.5,  0.5,  0.5},
    50     {.name = "gray50" , 1,   0.5,  0.5,  0.5},
    51     {.name = "grey25" , 1,   0.25, 0.25, 0.25},
    52     {.name = "gray25" , 1,   0.25, 0.25, 0.25},
     39    { "black"  , 1,   0,    0,    0 },
     40    { "white"  , 1,   1,    1,    1 },
     41    { "red"    , 1,   1,    0,    0 },
     42    { "green"  , 1,   0,    1,    0 },
     43    { "blue"   , 1,   0,    0,    1 },
     44    { "yellow" , 1,   1,    1,    0 },
     45    { "cyan"   , 1,   0,    1,    1 },
     46    { "magenta", 1,   1,    0,    1 },
     47    { "grey"   , 1,   0.5,  0.5,  0.5 },
     48    { "gray"   , 1,   0.5,  0.5,  0.5 },
     49    { "grey50" , 1,   0.5,  0.5,  0.5 },
     50    { "gray50" , 1,   0.5,  0.5,  0.5 },
     51    { "grey25" , 1,   0.25, 0.25, 0.25 },
     52    { "gray25" , 1,   0.25, 0.25, 0.25 },
    5353};
    5454
     
    5757pipi_pixel_t *pipi_get_color_from_string(const char* s)
    5858{
     59        pipi_pixel_t *color;
     60
    5961    if(!s) return NULL;
    6062
    61 
    62     pipi_pixel_t *color = malloc(sizeof(pipi_pixel_t));
    63 
     63    color = malloc(sizeof(pipi_pixel_t));
    6464
    6565    if(s[0] == '#')
  • libpipi/trunk/pipi/dither/ordered.c

    r2902 r2904  
    2121#include <stdlib.h>
    2222#include <math.h>
     23#ifndef M_PI
     24#   define M_PI 3.14159265358979323846
     25#endif
    2326
    2427#include "pipi.h"
  • libpipi/trunk/pipi/filter/blur.c

    r2902 r2904  
    2323#include <string.h>
    2424#include <math.h>
     25#ifndef M_PI
     26#   define M_PI 3.14159265358979323846
     27#endif
    2528
    2629#include "pipi.h"
  • libpipi/trunk/pipi/histogram/histogram.c

    r2902 r2904  
    3636int pipi_get_image_histogram(pipi_image_t *img, pipi_histogram_t*h, int flags)
    3737{
     38    uint8_t  *data;
     39    float n;
     40    unsigned int max;
    3841    int i;
    3942
    4043    if(!h) return -1;
    4144
    42     uint8_t  *data = (uint8_t *)pipi_getpixels(img, PIPI_PIXELS_RGBA_C)->pixels;
     45        data = (uint8_t *)pipi_getpixels(img, PIPI_PIXELS_RGBA_C)->pixels;
    4346
    4447    for(i=0; i< img->w*img->h*4; i+=4)
     
    6467
    6568    /* Normalize dataset */
    66     unsigned int max;
    67     float n;
    68 
    6969    if(flags&PIPI_COLOR_R)
    7070    {
     
    113113    }
    114114
    115 
    116115    return 0;
    117116}
     
    119118int pipi_render_histogram(pipi_image_t *img, pipi_histogram_t*h, int flags)
    120119{
    121     if(!img || !h) return -1;
    122 
    123120    int x;
    124121
     122    if(!img || !h) return -1;
    125123
    126124    for(x=0; x<256; x++)
  • libpipi/trunk/pipi/paint/floodfill.c

    r2902 r2904  
    125125                                        uint32_t new, uint32_t old)
    126126{
    127     if(new==old) return;
    128 
    129     clear_stack(dstp->h);
    130 
    131127    int yt;
    132128    int left, right;
    133129
    134130    uint32_t *dstdata = (uint32_t *)dstp->pixels;
     131
     132    if(new==old) return;
     133
     134    clear_stack(dstp->h);
    135135
    136136    if(!push(x, y, dstp->h)) return;
     
    182182                                                 float or, float og, float ob, float oa)
    183183{
    184     if((nr==or) && (ng==og) && (nb==ob)) return;
    185 
    186     clear_stack(dstp->h);
    187 
    188184    int yt;
    189185    int left, right;
    190186    float *dstdata = (float *)dstp->pixels;
     187
     188    if((nr==or) && (ng==og) && (nb==ob)) return;
     189
     190    clear_stack(dstp->h);
    191191
    192192    if(!push(x, y, dstp->h)) return;
  • libpipi/trunk/pipi/paint/line.c

    r2902 r2904  
    2424#include <string.h>
    2525
    26 #undef __USE_MISC  /* THAT sucks */
    27 #undef __USE_XOPEN /* THAT sucks, too (avoid declaring y1 in math.h) */
    2826#include <math.h>
    2927
     
    3129#include "pipi_internals.h"
    3230
    33 /* math.h doesn't like y1 (sucker) */
    34 float floorf(float x);
    35 float truncf(float x);
    36 float fabsf(float x);
    37 
    3831#if !defined TEMPLATE_FILE /* This file uses the template system */
    3932
     
    4336struct line
    4437{
    45     int x1, y1;
    46     int x2, y2;
     38    int xa, ya;
     39    int xb, yb;
    4740    void (*draw) (pipi_image_t*, struct line*);
    4841    union {
     
    6558static uint8_t clip_bits(pipi_image_t*, int, int);
    6659
    67 int pipi_draw_line(pipi_image_t *img , int x1, int y1, int x2, int y2, uint32_t c, int aa)
     60int pipi_draw_line(pipi_image_t *img , int xa, int ya, int xb, int yb, uint32_t c, int aa)
    6861{
    6962    struct line s;
    70     s.x1 = x1;
    71     s.y1 = y1;
    72     s.x2 = x2;
    73     s.y2 = y2;
     63    s.xa = xa;
     64    s.ya = ya;
     65    s.xb = xb;
     66    s.yb = yb;
    7467
    7568
     
    139132    uint8_t bits1, bits2;
    140133
    141     bits1 = clip_bits(img, s->x1, s->y1);
    142     bits2 = clip_bits(img, s->x2, s->y2);
     134    bits1 = clip_bits(img, s->xa, s->ya);
     135    bits2 = clip_bits(img, s->xb, s->yb);
    143136
    144137    if(bits1 & bits2)
     
    152145        {
    153146            int tmp;
    154             tmp = s->x1; s->x1 = s->x2; s->x2 = tmp;
    155             tmp = s->y1; s->y1 = s->y2; s->y2 = tmp;
     147            tmp = s->xa; s->xa = s->xb; s->xb = tmp;
     148            tmp = s->ya; s->ya = s->yb; s->yb = tmp;
    156149            clip_line(img, s);
    157150        }
     
    161154    if(bits1 & (1<<0))
    162155    {
    163         s->y1 = s->y2 - (s->x2 - 0) * (s->y2 - s->y1) / (s->x2 - s->x1);
    164         s->x1 = 0;
     156        s->ya = s->yb - (s->xb - 0) * (s->yb - s->ya) / (s->xb - s->xa);
     157        s->xa = 0;
    165158    }
    166159    else if(bits1 & (1<<1))
    167160    {
    168161        int xmax = img->w - 1;
    169         s->y1 = s->y2 - (s->x2 - xmax) * (s->y2 - s->y1) / (s->x2 - s->x1);
    170         s->x1 = xmax;
     162        s->ya = s->yb - (s->xb - xmax) * (s->yb - s->ya) / (s->xb - s->xa);
     163        s->xa = xmax;
    171164    }
    172165    else if(bits1 & (1<<2))
    173166    {
    174         s->x1 = s->x2 - (s->y2 - 0) * (s->x2 - s->x1) / (s->y2 - s->y1);
    175         s->y1 = 0;
     167        s->xa = s->xb - (s->yb - 0) * (s->xb - s->xa) / (s->yb - s->ya);
     168        s->ya = 0;
    176169    }
    177170    else if(bits1 & (1<<3))
    178171    {
    179172        int ymax = img->h - 1;
    180         s->x1 = s->x2 - (s->y2 - ymax) * (s->x2 - s->x1) / (s->y2 - s->y1);
    181         s->y1 = ymax;
     173        s->xa = s->xb - (s->yb - ymax) * (s->xb - s->xa) / (s->yb - s->ya);
     174        s->ya = ymax;
    182175    }
    183176
     
    242235static void T(aaline)(pipi_image_t *img, struct line* s)
    243236{
    244     float x1 = s->x1, y1 = s->y1, x2 = s->x2, y2 = s->y2;
     237    float xa = s->xa, ya = s->ya, xb = s->xb, yb = s->yb;
    245238    float g, xd, yd, xgap, xend, yend, xf, yf, val1, val2;
    246     int x, y, ix1, ix2, iy1, iy2;
    247 
    248     xd = x2 - x1;
    249     yd = y2 - y1;
     239    int x, y, ixa, ixb, iya, iyb;
     240
     241    xd = xb - xa;
     242    yd = yb - ya;
    250243
    251244    /* "Horizontal" line (X greater than Y)*/
    252245    if (fabsf(xd) > fabsf(yd))
    253246    {
    254         if (x1 > x2)
     247        if (xa > xb)
    255248        {
    256249            float tmp;
    257             tmp = x1; x1 = x2; x2 = tmp;
    258             tmp = y1; y1 = y2; y2 = tmp;
    259             xd = (x2-x1);
    260             yd = (y2-y1);
     250            tmp = xa; xa = xb; xb = tmp;
     251            tmp = ya; ya = yb; yb = tmp;
     252            xd = (xb-xa);
     253            yd = (yb-ya);
    261254        }
    262255        g = yd/xd;
    263256
    264         xend = truncf(x1+0.5);
    265         yend = y1 + g*(xend-x1);
    266         xgap = fractinvf(x1+0.5);
    267         ix1 = (int)xend;
    268         iy1 = (int)yend;
     257        xend = (float)(int)(xa+0.5);
     258        yend = ya + g*(xend-xa);
     259        xgap = fractinvf(xa+0.5);
     260        ixa = (int)xend;
     261        iya = (int)yend;
    269262        val1 = fractinvf(yend)*xgap;
    270263        val2 = fractf(yend)*xgap;
    271264
    272         PLOT(ix1, iy1,   val1);
    273         PLOT(ix1, (iy1+1)<y1?(iy1+1):iy1, val2);
     265        PLOT(ixa, iya,   val1);
     266        PLOT(ixa, (iya+1)<ya?(iya+1):iya, val2);
    274267
    275268        yf = yend+g;
    276         xend = truncf(x2+0.5);
    277         yend = y2 + g*(xend-x2);
    278         xgap = fractinvf(x2-0.5);
    279         ix2 = (int)xend;
    280         iy2 = (int)yend;
     269        xend = (float)(int)(xb+0.5);
     270        yend = yb + g*(xend-xb);
     271        xgap = fractinvf(xb-0.5);
     272        ixb = (int)xend;
     273        iyb = (int)yend;
    281274        val1 = fractinvf(yend)*xgap;
    282275        val2 = fractf(yend)*xgap;
    283276
    284         PLOT(ix2, iy2,   val1);
    285         PLOT(ix2, iy2+1<y2?iy2+1:iy2, val2);
    286 
    287         for (x = (ix1+1); x < ix2; x++)
     277        PLOT(ixb, iyb,   val1);
     278        PLOT(ixb, iyb+1<yb?iyb+1:iyb, val2);
     279
     280        for (x = (ixa+1); x < ixb; x++)
    288281        {
    289282            float focus;
     
    296289
    297290            PLOT(x, yf, val1);
    298             PLOT(x, (yf+1)<y1?(yf+1):yf, val2);
     291            PLOT(x, (yf+1)<ya?(yf+1):yf, val2);
    299292
    300293            yf = yf + g;
     
    304297    else
    305298    {
    306         if (x1 > x2)
     299        if (xa > xb)
    307300        {
    308301            float tmp;
    309             tmp = x1; x1 = x2; x2 = tmp;
    310             tmp = y1; y1 = y2; y2 = tmp;
    311             xd = (x2-x1);
    312             yd = (y2-y1);
     302            tmp = xa; xa = xb; xb = tmp;
     303            tmp = ya; ya = yb; yb = tmp;
     304            xd = (xb-xa);
     305            yd = (yb-ya);
    313306        }
    314307
    315308        g = xd/yd;
    316309
    317         xend = truncf(x1+0.5);
    318         yend = y1 + g*(xend-x1);
    319         xgap = fractf(x1+0.5);
    320         ix1 = (int)xend;
    321         iy1 = (int)yend;
     310        xend = (float)(int)(xa+0.5);
     311        yend = ya + g*(xend-xa);
     312        xgap = fractf(xa+0.5);
     313        ixa = (int)xend;
     314        iya = (int)yend;
    322315        val1 = fractinvf(yend)*xgap;
    323316        val2 = fractf(yend)*xgap;
    324317
    325         PLOT(ix1, iy1, val1);
    326         PLOT(ix1, (iy1+1)<y1?(iy1+1):iy1, val2);
     318        PLOT(ixa, iya, val1);
     319        PLOT(ixa, (iya+1)<ya?(iya+1):iya, val2);
    327320
    328321        xf = xend + g;
    329322
    330         xend = truncf(x2+0.5);
    331         yend = y2 + g*(xend-x2);
    332         xgap = fractinvf(x2-0.5);
    333         ix2 = (int)xend;
    334         iy2 = (int)yend;
     323        xend = (float)(int)(xb+0.5);
     324        yend = yb + g*(xend-xb);
     325        xgap = fractinvf(xb-0.5);
     326        ixb = (int)xend;
     327        iyb = (int)yend;
    335328        val1 = fractinvf(yend)*xgap;
    336329        val2 = fractf(yend)*xgap;
    337330
    338         PLOT(ix2, iy2,   val1);
    339         PLOT(ix2, (iy2+1)<y2?(iy2+1):iy2, val2);
    340 
    341 
    342         for (y = (iy1+1); y < iy2; y++)
     331        PLOT(ixb, iyb,   val1);
     332        PLOT(ixb, (iyb+1)<yb?(iyb+1):iyb, val2);
     333
     334
     335        for (y = (iya+1); y < iyb; y++)
    343336        {
    344337            float focus;
     
    363356static void T(line)(pipi_image_t *img, struct line* s)
    364357{
    365     int x1, y1, x2, y2;
     358    int xa, ya, xb, yb;
    366359    int dx, dy;
    367360    int xinc, yinc;
    368361
    369     x1 = s->x1; y1 = s->y1; x2 = s->x2; y2 = s->y2;
    370 
    371     dx = abs(x2 - x1);
    372     dy = abs(y2 - y1);
    373 
    374     xinc = (x1 > x2) ? -1 : 1;
    375     yinc = (y1 > y2) ? -1 : 1;
     362    xa = s->xa; ya = s->ya; xb = s->xb; yb = s->yb;
     363
     364    dx = abs(xb - xa);
     365    dy = abs(yb - ya);
     366
     367    xinc = (xa > xb) ? -1 : 1;
     368    yinc = (ya > yb) ? -1 : 1;
    376369
    377370    if(dx >= dy)
     
    388381                    /* TODO */;
    389382                else
    390                     s->buf_f[x1 + y1 * img->w] = s->colorf[0];
     383                    s->buf_f[xa + ya * img->w] = s->colorf[0];
    391384            }
    392385            else
    393386            {
    394387                if(FLAG_8BIT)
    395                     s->buf_u32[x1 + y1 * img->w] = s->color32;
     388                    s->buf_u32[xa + ya * img->w] = s->color32;
    396389                else
    397390                {
    398                     s->buf_f[4 * (y1 * img->w + x1)] = s->colorf[0];
    399                     s->buf_f[4 * (y1 * img->w + x1) + 1] = s->colorf[1];
    400                     s->buf_f[4 * (y1 * img->w + x1) + 2] = s->colorf[2];
     391                    s->buf_f[4 * (ya * img->w + xa)] = s->colorf[0];
     392                    s->buf_f[4 * (ya * img->w + xa) + 1] = s->colorf[1];
     393                    s->buf_f[4 * (ya * img->w + xa) + 2] = s->colorf[2];
    401394                }
    402395            }
     
    404397            if(delta > 0)
    405398            {
    406                 x1 += xinc;
    407                 y1 += yinc;
     399                xa += xinc;
     400                ya += yinc;
    408401                delta += dpru;
    409402            }
    410403            else
    411404            {
    412                 x1 += xinc;
     405                xa += xinc;
    413406                delta += dpr;
    414407            }
     
    428421                    /* TODO */;
    429422                else
    430                     s->buf_f[x1 + y1 * img->w] = s->colorf[0];
     423                    s->buf_f[xa + ya * img->w] = s->colorf[0];
    431424            }
    432425            else
    433426            {
    434427                if(FLAG_8BIT)
    435                     s->buf_u32[x1 + y1 * img->w] = s->color32;
     428                    s->buf_u32[xa + ya * img->w] = s->color32;
    436429                else
    437430                {
    438                     s->buf_f[4 * (y1 * img->w + x1)] = s->colorf[0];
    439                     s->buf_f[4 * (y1 * img->w + x1) + 1] = s->colorf[1];
    440                     s->buf_f[4 * (y1 * img->w + x1) + 2] = s->colorf[2];
     431                    s->buf_f[4 * (ya * img->w + xa)] = s->colorf[0];
     432                    s->buf_f[4 * (ya * img->w + xa) + 1] = s->colorf[1];
     433                    s->buf_f[4 * (ya * img->w + xa) + 2] = s->colorf[2];
    441434                }
    442435            }
     
    444437            if(delta > 0)
    445438            {
    446                 x1 += xinc;
    447                 y1 += yinc;
     439                xa += xinc;
     440                ya += yinc;
    448441                delta += dpru;
    449442            }
    450443            else
    451444            {
    452                 y1 += yinc;
     445                ya += yinc;
    453446                delta += dpr;
    454447            }
  • libpipi/trunk/pipi/quantize/reduce.c

    r2902 r2904  
    2323#include <string.h>
    2424#include <math.h>
    25 
    26 #include <pipi.h>
     25#ifndef M_PI
     26#   define M_PI 3.14159265358979323846
     27#endif
     28
     29#include "pipi.h"
     30#include "pipi_internals.h"
    2731
    2832#define R 0
     
    3236#define Y 4
    3337#define A 5
    34 
    35 //#define debug printf
    36 #define debug(...) /* */
    3738
    3839#define BRIGHT(x) (0.299*(x)[0] + 0.587*(x)[1] + 0.114*(x)[2])
     
    8182static hull_t *compute_hull(int ncolors, double const *palette)
    8283{
     84    double pal[MAXCOLORS][3];
     85    double gray[3];
     86    double *dark = NULL, *light = NULL;
     87    double tmp, min = 1.0, max = 0.0;
    8388    hull_t *ret = malloc(sizeof(hull_t));
    84     double tmp;
    85     int i, j;
     89    int i, j, n;
    8690
    8791    debug("\n### NEW HULL ###\n\n");
     
    8993    debug("Analysing %i colors\n", ncolors);
    9094
    91     double pal[ncolors][3];
    9295    for(i = 0; i < ncolors; i++)
    9396    {
     
    101104     * 1. Find the darkest and lightest colours
    102105     */
    103     double *dark = NULL, *light = NULL;
    104     double min = 1.0, max = 0.0;
    105106    for(i = 0; i < ncolors; i++)
    106107    {
     
    118119    }
    119120
    120     double gray[3];
    121 
    122121    gray[R] = light[R] - dark[R];
    123122    gray[G] = light[G] - dark[G];
     
    130129     * 3. Browse the grey axis and do stuff
    131130     */
    132     int n;
    133131    for(n = 0; n <= STEPS; n++)
    134132    {
    135         double pts[ncolors * (ncolors - 1) / 2][5];
     133        double pts[MAXCOLORS * (MAXCOLORS - 1) / 2][5];
    136134        double ptmp[5];
     135        double p0[3];
    137136#define SWAP(p1,p2) do { memcpy(ptmp, p1, sizeof(ptmp)); \
    138137                         memcpy(p1, p2, sizeof(ptmp)); \
    139138                         memcpy(p2, ptmp, sizeof(ptmp)); } while(0)
     139        double ctx, cty, weight;
    140140        double t = n * 1.0 / STEPS;
    141         int npts = 0;
     141        int npts = 0, left;
    142142
    143143        debug("Slice %i/%i\n", n, STEPS);
    144144
    145         double p0[3];
    146145        p0[R] = dark[R] + t * gray[R];
    147146        p0[G] = dark[G] + t * gray[G];
     
    156155        {
    157156            double k1[3];
     157                        double yk1;
    158158            k1[R] = pal[i][R] - p0[R];
    159159            k1[G] = pal[i][G] - p0[G];
     
    162162
    163163            /* If k1.y > t.y.y, we don't want this point */
    164             double yk1 = y[R] * k1[R] + y[G] * k1[G] + y[B] * k1[B];
     164            yk1 = y[R] * k1[R] + y[G] * k1[G] + y[B] * k1[B];
    165165            if(yk1 > t * ylen * ylen + EPSILON)
    166166                continue;
     
    168168            for(j = 0; j < ncolors; j++)
    169169            {
    170                 if(i == j)
     170                double k2[3];
     171                double yk2, s;
     172
     173                                if(i == j)
    171174                    continue;
    172175
    173                 double k2[3];
    174176                k2[R] = pal[j][R] - p0[R];
    175177                k2[G] = pal[j][G] - p0[G];
     
    178180
    179181                /* If k2.y < t.y.y, we don't want this point */
    180                 double yk2 = y[R] * k2[R] + y[G] * k2[G] + y[B] * k2[B];
     182                yk2 = y[R] * k2[R] + y[G] * k2[G] + y[B] * k2[B];
    181183                if(yk2 < t * ylen * ylen - EPSILON)
    182184                    continue;
     
    185187                    continue;
    186188
    187                 double s = yk1 == yk2 ?
    188                            0.5 : (t * ylen * ylen - yk1) / (yk2 - yk1);
     189                s = yk1 == yk2 ? 0.5 : (t * ylen * ylen - yk1) / (yk2 - yk1);
    189190
    190191                pts[npts][R] = p0[R] + k1[R] + s * (k2[R] - k1[R]);
     
    212213
    213214        /* Find the leftmost point */
    214         int left = -1;
     215        left = -1;
    215216        tmp = 10.;
    216217        for(i = 0; i < npts; i++)
     
    249250        for(i = 2; i < npts; /* */)
    250251        {
     252                        double k1, k2;
     253
    251254            if(i < 2)
    252255            {
     
    255258            }
    256259
    257             double k1 = (pts[i - 1][X] - pts[i - 2][X])
     260            k1 = (pts[i - 1][X] - pts[i - 2][X])
    258261                          * (pts[i][Y] - pts[i - 2][Y]);
    259             double k2 = (pts[i][X] - pts[i - 2][X])
     262            k2 = (pts[i][X] - pts[i - 2][X])
    260263                          * (pts[i - 1][Y] - pts[i - 2][Y]);
    261264            if(k1 <= k2 + EPSILON)
     
    274277
    275278        /* Compute the barycentre coordinates */
    276         double ctx = 0., cty = 0., weight = 0.;
     279        ctx = 0.;
     280        cty = 0.;
     281        weight = 0.;
    277282        for(i = 2; i < npts; i++)
    278283        {
     
    281286            double acx = pts[i][X] - pts[0][X];
    282287            double acy = pts[i][Y] - pts[0][Y];
     288                        double area;
    283289            double sqarea = (abx * abx + aby * aby) * (acx * acx + acy * acy)
    284290                          - (abx * acx + aby * acy) * (abx * acx + aby * acy);
     
    286292                continue;
    287293
    288             double area = sqrt(sqarea);
     294            area = sqrt(sqarea);
    289295            ctx += area * (abx + acx) / 3;
    290296            cty += area * (aby + acy) / 3;
     
    352358    };
    353359
    354     int i, j;
     360    pipi_image_t *dst;
     361        pipi_pixels_t *srcp, *dstp;
     362        float *srcdata, *dstdata;
     363        hull_t *rgbhull, *myhull;
     364    int i, j, w, h;
    355365
    356366    init_uv();
    357367
    358     hull_t *rgbhull = compute_hull(8, rgbpal);
    359     hull_t *myhull = compute_hull(ncolors, palette);
     368    rgbhull = compute_hull(8, rgbpal);
     369    myhull = compute_hull(ncolors, palette);
    360370
    361371    /*
     
    365375    debug("\n### PROCESSING IMAGE ###\n\n");
    366376
    367     pipi_pixels_t *srcp = pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
    368     float *srcdata = (float *)srcp->pixels;
    369 
    370     int w = srcp->w, h = srcp->h;
    371 
    372     pipi_image_t *dst = pipi_new(w, h);
    373     pipi_pixels_t *dstp = pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
    374     float *dstdata = (float *)dstp->pixels;
     377    srcp = pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
     378    srcdata = (float *)srcp->pixels;
     379
     380    w = srcp->w;
     381    h = srcp->h;
     382
     383    dst = pipi_new(w, h);
     384    dstp = pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
     385    dstdata = (float *)dstp->pixels;
    375386
    376387    for(j = 0; j < h; j++)
     
    378389        {
    379390            double p[3];
     391            double xp, yp, angle, xa, ya, xb, yb, t, s;
     392            int slice, n, count;
     393
    380394            /* FIXME: Imlib fucks up the RGB order. */
    381395            p[B] = srcdata[4 * (j * w + i)];
     
    385399            debug("Pixel +%i+%i (%g,%g,%g)\n", i, j, p[R], p[G], p[B]);
    386400
    387             int slice = (int)(BRIGHT(p) * STEPS + 0.5);
     401            slice = (int)(BRIGHT(p) * STEPS + 0.5);
    388402
    389403            debug("  slice %i\n", slice);
    390404
    391405            /* Convert to 2D. The origin is the slice's barycentre. */
    392             double xp = (p[R] - rgbhull->bary[slice][R]) * u[R]
    393                       + (p[G] - rgbhull->bary[slice][G]) * u[G]
    394                       + (p[B] - rgbhull->bary[slice][B]) * u[B];
    395             double yp = (p[R] - rgbhull->bary[slice][R]) * v[R]
    396                       + (p[G] - rgbhull->bary[slice][G]) * v[G]
    397                       + (p[B] - rgbhull->bary[slice][B]) * v[B];
     406            xp = (p[R] - rgbhull->bary[slice][R]) * u[R]
     407               + (p[G] - rgbhull->bary[slice][G]) * u[G]
     408               + (p[B] - rgbhull->bary[slice][B]) * u[B];
     409            yp = (p[R] - rgbhull->bary[slice][R]) * v[R]
     410               + (p[G] - rgbhull->bary[slice][G]) * v[G]
     411               + (p[B] - rgbhull->bary[slice][B]) * v[B];
    398412
    399413            debug("    2D pt (%g,%g)\n", xp, yp);
     
    405419
    406420            /* First, find the relevant triangle. */
    407             int n, count = rgbhull->hullsize[slice];
    408             double angle = atan2(yp, xp);
     421            count = rgbhull->hullsize[slice];
     422            angle = atan2(yp, xp);
    409423            for(n = 0; n < count; n++)
    410424            {
     
    424438            /* Now compute the distance to the triangle's edge. If the edge
    425439             * intersection is M, then t is such as P = t.M (can be zero) */
    426             double xa = rgbhull->pts[slice][n % count][X];
    427             double ya = rgbhull->pts[slice][n % count][Y];
    428             double xb = rgbhull->pts[slice][(n + 1) % count][X];
    429             double yb = rgbhull->pts[slice][(n + 1) % count][Y];
    430             double t = (xp * (yb - ya) - yp * (xb - xa)) / (xa * yb - xb * ya);
     440            xa = rgbhull->pts[slice][n % count][X];
     441            ya = rgbhull->pts[slice][n % count][Y];
     442            xb = rgbhull->pts[slice][(n + 1) % count][X];
     443            yb = rgbhull->pts[slice][(n + 1) % count][Y];
     444            t = (xp * (yb - ya) - yp * (xb - xa)) / (xa * yb - xb * ya);
    431445
    432446            if(t > 1.0)
     
    459473            xb = myhull->pts[slice][(n + 1) % count][X];
    460474            yb = myhull->pts[slice][(n + 1) % count][Y];
    461             double s = (xp * (yb - ya) - yp * (xb - xa)) / (xa * yb - xb * ya);
     475            s = (xp * (yb - ya) - yp * (xb - xa)) / (xa * yb - xb * ya);
    462476
    463477            debug("    best custom %g (%g,%g) (%g,%g)\n", s, xa, ya, xb, yb);
  • libpipi/trunk/pipi/render/screen.c

    r2902 r2904  
    2323#include <string.h>
    2424#include <math.h>
     25
     26#ifndef M_PI
     27#   define M_PI 3.14159265358979323846
     28#endif
    2529
    2630#include "pipi.h"
Note: See TracChangeset for help on using the changeset viewer.