Changeset 2725


Ignore:
Timestamp:
Aug 16, 2008, 2:53:50 AM (14 years ago)
Author:
Sam Hocevar
Message:
  • color.c: implement pipi_brightness() and pipi_contrast().
  • pipi.c: add --brightness and --contrast.
Location:
libpipi/trunk
Files:
5 edited

Legend:

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

    r2718 r2725  
    219219        ctx->images[ctx->nimages - 1] = dst;
    220220    }
     221    else if(!strcmp(cmd, "brightness"))
     222    {
     223        pipi_image_t *src, *dst;
     224        char const *arg;
     225        va_list ap;
     226        double val;
     227
     228        if(ctx->nimages < 1)
     229            return -1;
     230        va_start(ap, cmd);
     231        arg = va_arg(ap, char const *);
     232        va_end(ap);
     233        val = atof(arg);
     234        src = ctx->images[ctx->nimages - 1];
     235        dst = pipi_brightness(src, val);
     236        if(dst == NULL)
     237            return -1;
     238        pipi_free(src);
     239        ctx->images[ctx->nimages - 1] = dst;
     240    }
     241    else if(!strcmp(cmd, "contrast"))
     242    {
     243        pipi_image_t *src, *dst;
     244        char const *arg;
     245        va_list ap;
     246        double val;
     247
     248        if(ctx->nimages < 1)
     249            return -1;
     250        va_start(ap, cmd);
     251        arg = va_arg(ap, char const *);
     252        va_end(ap);
     253        val = atof(arg);
     254        src = ctx->images[ctx->nimages - 1];
     255        dst = pipi_contrast(src, val);
     256        if(dst == NULL)
     257            return -1;
     258        pipi_free(src);
     259        ctx->images[ctx->nimages - 1] = dst;
     260    }
    221261    else if(!strcmp(cmd, "mean"))
    222262    {
  • libpipi/trunk/pipi/filter/color.c

    r2718 r2725  
    2828#include "pipi_internals.h"
    2929
     30pipi_image_t *pipi_brightness(pipi_image_t *src, double val)
     31{
     32    pipi_image_t *dst;
     33    pipi_pixels_t *srcp, *dstp;
     34    float *srcdata, *dstdata;
     35    int x, y, w, h, gray;
     36
     37    w = src->w;
     38    h = src->h;
     39
     40    gray = (src->last_modified == PIPI_PIXELS_Y_F);
     41
     42    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
     43                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
     44    srcdata = (float *)srcp->pixels;
     45
     46    dst = pipi_new(w, h);
     47    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
     48                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
     49    dstdata = (float *)dstp->pixels;
     50
     51    if(val >= 0.0)
     52    {
     53        for(y = 0; y < h; y++)
     54        {
     55            for(x = 0; x < w; x++)
     56            {
     57                if(gray)
     58                {
     59                    double p = srcdata[y * w + x];
     60                    dstdata[y * w + x] = p < 1. - val ? p + val : 1.;
     61                }
     62                else
     63                {
     64                    double p;
     65                    int d = 4 * (y * w + x);
     66
     67                    p = srcdata[d];
     68                    dstdata[d] = p < 1. - val ? p + val : 1.;
     69                    p = srcdata[d + 1];
     70                    dstdata[d + 1] = p < 1. - val ? p + val : 1.;
     71                    p = srcdata[d + 2];
     72                    dstdata[d + 2] = p < 1. - val ? p + val : 1.;
     73                    p = srcdata[d + 3];
     74                    dstdata[d + 3] = p < 1. - val ? p + val : 1.;
     75                }
     76            }
     77        }
     78    }
     79    else
     80    {
     81        for(y = 0; y < h; y++)
     82        {
     83            for(x = 0; x < w; x++)
     84            {
     85                if(gray)
     86                {
     87                    double p = srcdata[y * w + x];
     88                    dstdata[y * w + x] = p > -val ? p + val : 0.;
     89                }
     90                else
     91                {
     92                    double p;
     93                    int d = 4 * (y * w + x);
     94
     95                    p = srcdata[d];
     96                    dstdata[d] = p > -val ? p + val : 0.;
     97                    p = srcdata[d + 1];
     98                    dstdata[d + 1] = p > -val ? p + val : 0.;
     99                    p = srcdata[d + 2];
     100                    dstdata[d + 2] = p > -val ? p + val : 0.;
     101                    p = srcdata[d + 3];
     102                    dstdata[d + 3] = p > -val ? p + val : 0.;
     103                }
     104            }
     105        }
     106    }
     107
     108    return dst;
     109}
     110
     111pipi_image_t *pipi_contrast(pipi_image_t *src, double val)
     112{
     113    pipi_image_t *dst;
     114    pipi_pixels_t *srcp, *dstp;
     115    float *srcdata, *dstdata;
     116    int x, y, w, h, gray;
     117
     118    w = src->w;
     119    h = src->h;
     120
     121    gray = (src->last_modified == PIPI_PIXELS_Y_F);
     122
     123    srcp = gray ? pipi_getpixels(src, PIPI_PIXELS_Y_F)
     124                : pipi_getpixels(src, PIPI_PIXELS_RGBA_F);
     125    srcdata = (float *)srcp->pixels;
     126
     127    dst = pipi_new(w, h);
     128    dstp = gray ? pipi_getpixels(dst, PIPI_PIXELS_Y_F)
     129                : pipi_getpixels(dst, PIPI_PIXELS_RGBA_F);
     130    dstdata = (float *)dstp->pixels;
     131
     132    if(val >= 0.0)
     133    {
     134        if(val > 0.99999)
     135            val = 0.99999;
     136
     137        val = 1. / (1. - val);
     138
     139        for(y = 0; y < h; y++)
     140        {
     141            for(x = 0; x < w; x++)
     142            {
     143                if(gray)
     144                {
     145                    double p = (srcdata[y * w + x] - 0.5) * val + 0.5;
     146                    dstdata[y * w + x] = p < 0. ? 0. : p > 1. ? 1. : p;
     147                }
     148                else
     149                {
     150                    double p;
     151                    int d = 4 * (y * w + x);
     152
     153                    p = (srcdata[d] - 0.5) * val + 0.5;
     154                    dstdata[d] = p < 0. ? 0. : p > 1. ? 1. : p;
     155                    p = (srcdata[d + 1] - 0.5) * val + 0.5;
     156                    dstdata[d + 1] = p < 0. ? 0. : p > 1. ? 1. : p;
     157                    p = (srcdata[d + 2] - 0.5) * val + 0.5;
     158                    dstdata[d + 2] = p < 0. ? 0. : p > 1. ? 1. : p;
     159                    p = (srcdata[d + 3] - 0.5) * val + 0.5;
     160                    dstdata[d + 3] = p < 0. ? 0. : p > 1. ? 1. : p;
     161                }
     162            }
     163        }
     164    }
     165    else
     166    {
     167        if(val < -1.)
     168            val = -1.;
     169
     170        val = 1. + val;
     171
     172        for(y = 0; y < h; y++)
     173        {
     174            for(x = 0; x < w; x++)
     175            {
     176                if(gray)
     177                {
     178                    double p = srcdata[y * w + x];
     179                    dstdata[y * w + x] = (p - 0.5) * val + 0.5;
     180                }
     181                else
     182                {
     183                    double p;
     184                    int d = 4 * (y * w + x);
     185
     186                    p = srcdata[d];
     187                    dstdata[d] = (p - 0.5) * val + 0.5;
     188                    p = srcdata[d + 1];
     189                    dstdata[d + 1] = (p - 0.5) * val + 0.5;
     190                    p = srcdata[d + 2];
     191                    dstdata[d + 2] = (p - 0.5) * val + 0.5;
     192                    p = srcdata[d + 3];
     193                    dstdata[d + 3] = (p - 0.5) * val + 0.5;
     194                }
     195            }
     196        }
     197    }
     198
     199    return dst;
     200}
     201
    30202pipi_image_t *pipi_invert(pipi_image_t *src)
    31203{
  • libpipi/trunk/pipi/paint/tile.c

    r2717 r2725  
    1919#include "config.h"
    2020#include "common.h"
     21
     22#include <strings.h>
    2123
    2224#include "pipi.h"
  • libpipi/trunk/pipi/pipi.h

    r2722 r2725  
    123123extern pipi_image_t *pipi_box_blur(pipi_image_t *, int);
    124124extern pipi_image_t *pipi_box_blur_ext(pipi_image_t *, int, int);
     125extern pipi_image_t *pipi_brightness(pipi_image_t *, double);
     126extern pipi_image_t *pipi_contrast(pipi_image_t *, double);
    125127extern pipi_image_t *pipi_autocontrast(pipi_image_t *);
    126128extern pipi_image_t *pipi_invert(pipi_image_t *);
  • libpipi/trunk/src/pipi.c

    r2718 r2725  
    7070            if(pipi_command(ctx, "gray") != 0)
    7171                return EXIT_FAILURE;
     72        }
     73        else if(!strcmp(argv[0], "--brightness"))
     74        {
     75            if(argv[1] == NULL)
     76                return EXIT_FAILURE;
     77            if(pipi_command(ctx, "brightness", argv[1]) != 0)
     78                return EXIT_FAILURE;
     79            argv++;
     80        }
     81        else if(!strcmp(argv[0], "--contrast"))
     82        {
     83            if(argv[1] == NULL)
     84                return EXIT_FAILURE;
     85            if(pipi_command(ctx, "contrast", argv[1]) != 0)
     86                return EXIT_FAILURE;
     87            argv++;
    7288        }
    7389        else if(!strcmp(argv[0], "--autocontrast"))
Note: See TracChangeset for help on using the changeset viewer.