Ignore:
Timestamp:
Jan 3, 2005, 4:00:45 PM (17 years ago)
Author:
Sam Hocevar
Message:
  • moved generic filter functions to filters.c
  • fixed uninitialised value in trick().
File:
1 edited

Legend:

Unmodified
Added
Removed
  • pwntcha/trunk/src/slashdot.c

    r383 r385  
    3535
    3636/* Functions */
    37 
    38 void flood_fill(struct image *img, int x, int y, int r, int g, int b)
    39 {
    40     int oldr, oldg, oldb;
    41     int nextr, nextg, nextb;
    42 
    43     if(x < 0 || y < 0 || x >= img->width || y >= img->height)
    44         return;
    45 
    46     getpixel(img, x, y, &oldr, &oldg, &oldb);
    47     setpixel(img, x, y, r, g, b);
    48 
    49     getpixel(img, x + 1, y, &nextr, &nextg, &nextb);
    50     if(nextr == oldr && nextg == oldg && nextb == oldb)
    51         flood_fill(img, x + 1, y, r, g, b);
    52 
    53     getpixel(img, x - 1, y, &nextr, &nextg, &nextb);
    54     if(nextr == oldr && nextg == oldg && nextb == oldb)
    55         flood_fill(img, x - 1, y, r, g, b);
    56 
    57     getpixel(img, x, y + 1, &nextr, &nextg, &nextb);
    58     if(nextr == oldr && nextg == oldg && nextb == oldb)
    59         flood_fill(img, x, y + 1, r, g, b);
    60 
    61     getpixel(img, x, y - 1, &nextr, &nextg, &nextb);
    62     if(nextr == oldr && nextg == oldg && nextb == oldb)
    63         flood_fill(img, x, y - 1, r, g, b);
    64 }
    6537
    6638struct image *count_objects(struct image *img)
     
    179151}
    180152
    181 struct image *fill_holes(struct image *img)
     153struct image *cut_cells(struct image *img)
    182154{
    183155    struct image *dst;
     
    194166        }
    195167
    196     for(y = 0; y < dst->height; y++)
    197         for(x = 2; x < dst->width - 2; x++)
    198         {
    199             int c1, c2, c3, c4, c5;
    200             getpixel(img, x-2, y, &c1, &g, &b);
    201             getpixel(img, x-1, y, &c2, &g, &b);
    202             getpixel(img, x, y, &c3, &g, &b);
    203             getpixel(img, x+1, y, &c4, &g, &b);
    204             getpixel(img, x+2, y, &c5, &g, &b);
    205             if(c1 < 127 && c2 < 127 && c3 > 128 && c4 < 127)
    206                 c3 = (c1 + c2 + c4) / 3;
    207             else if(c2 < 127 && c3 > 128 && c4 < 127 && c5 < 127)
    208                 c3 = (c2 + c4 + c5) / 3;
    209             setpixel(dst, x, y, c3, c3, c3);
    210         }
    211 
    212     for(x = 0; x < dst->width; x++)
    213         for(y = 2; y < dst->height - 2; y++)
    214         {
    215             int c1, c2, c3, c4, c5;
    216             getpixel(img, x, y-2, &c1, &g, &b);
    217             getpixel(img, x, y-1, &c2, &g, &b);
    218             getpixel(img, x, y, &c3, &g, &b);
    219             getpixel(img, x, y+1, &c4, &g, &b);
    220             getpixel(img, x, y+2, &c5, &g, &b);
    221             if(c1 < 127 && c2 < 127 && c3 > 128 && c4 < 127)
    222                 c3 = (c1 + c2 + c4) / 3;
    223             else if(c2 < 127 && c3 > 128 && c4 < 127 && c5 < 127)
    224                 c3 = (c2 + c4 + c5) / 3;
    225             setpixel(dst, x, y, c3, c3, c3);
    226         }
    227 
    228     return dst;
    229 }
    230 
    231 struct image *cut_cells(struct image *img)
    232 {
    233     struct image *dst;
    234     int x, y;
    235     int r, g, b;
    236 
    237     dst = new_image(img->width, img->height);
    238 
    239     for(y = 0; y < img->height; y++)
    240         for(x = 0; x < img->width; x++)
    241         {
    242             getpixel(img, x, y, &r, &g, &b);
    243             setpixel(dst, x, y, r, g, b);
    244         }
    245 
    246168    for(x = 0; x < img->width; x++)
    247169    {
     
    255177            setpixel(dst, x * img->width / 7, y, 255, 255, 255);
    256178            setpixel(dst, (x + 1) * img->width / 7 - 1, y, 255, 255, 255);
    257         }
    258 
    259     return dst;
    260 }
    261 
    262 struct image *detect_lines(struct image *img)
    263 {
    264     struct image *dst;
    265     int x, y;
    266     int r, ra, rb, g, b;
    267 
    268     dst = new_image(img->width, img->height);
    269 
    270     /* Remove white lines */
    271     for(y = 0; y < img->height; y++)
    272         for(x = 0; x < img->width; x++)
    273         {
    274             getpixel(img, x, y, &r, &g, &b);
    275             setpixel(dst, x, y, r, g, b);
    276 #if 1
    277             if(y > 0 && y < img->height - 1)
    278             {
    279                 getpixel(img, x, y - 1, &ra, &g, &b);
    280                 getpixel(img, x, y + 1, &rb, &g, &b);
    281                 if(r > ra && (r - ra) * (r - rb) > 5000)
    282                     setpixel(dst, x, y, ra, ra, ra);
    283             }
    284 #endif
    285         }
    286 
    287     /* Remove black lines */
    288     for(y = 0; y < img->height; y++)
    289         for(x = 0; x < img->width; x++)
    290         {
    291             getpixel(dst, x, y, &r, &g, &b);
    292             if(y > 0 && y < img->height - 1)
    293             {
    294                 getpixel(img, x, y - 1, &ra, &g, &b);
    295                 getpixel(img, x, y + 1, &rb, &g, &b);
    296                 if(r < ra && (r - ra) * (r - rb) > 500)
    297                     setpixel(dst, x, y, ra, ra, ra);
    298             }
    299         }
    300 
    301     return dst;
    302 }
    303 
    304 struct image *equalize(struct image *img)
    305 {
    306     struct image *dst;
    307     int x, y;
    308     int r, g, b;
    309 
    310     dst = new_image(img->width, img->height);
    311 
    312     for(y = 0; y < img->height; y++)
    313         for(x = 0; x < img->width; x++)
    314         {
    315             getpixel(img, x, y, &r, &g, &b);
    316             if(r < 200) r = 50; else r = 200;
    317             setpixel(dst, x, y, r, r, r);
    318         }
    319 
    320     return dst;
    321 }
    322 
    323 struct image *trick(struct image *img)
    324 {
    325 #define TSIZE 3
    326     struct image *dst;
    327     int x, y, i, j, val, m, more, l, less;
    328     int r, g, b;
    329 
    330     dst = new_image(img->width, img->height);
    331 
    332     for(y = 0; y < img->height; y++)
    333         for(x = 0; x < img->width; x++)
    334             setpixel(dst, x, y, 255, 255, 255);
    335 
    336     for(y = TSIZE/2; y < img->height - TSIZE/2; y++)
    337         for(x = TSIZE/2; x < img->width - TSIZE/2; x++)
    338         {
    339             getpixel(img, x + j - TSIZE/2, y + i - TSIZE/2, &val, &g, &b);
    340             m = more = l = less = 0;
    341             for(i = 0; i < TSIZE; i++)
    342                 for(j = 0; j < TSIZE; j++)
    343                 {
    344                     getpixel(img, x + j - TSIZE/2, y + i - TSIZE/2, &r, &g, &b);
    345                     if(r > val)
    346                     {
    347                         more += r;
    348                         m++;
    349                     }
    350                     else if(r < val)
    351                     {
    352                         less += r;
    353                         l++;
    354                     }
    355                 }
    356 
    357             if(l >= 6)
    358                 i = less / l;
    359             else if(m >= 6)
    360                 i = more / m;
    361             else
    362                 i = val;
    363             setpixel(dst, x, y, i, i, i);
    364         }
    365 
    366     return dst;
    367 }
    368 
    369 struct image *smooth(struct image *img)
    370 {
    371 #define SSIZE 3
    372     struct image *dst;
    373     int x, y, i, j, val;
    374     int r, g, b;
    375 
    376     dst = new_image(img->width, img->height);
    377 
    378     for(y = 0; y < img->height; y++)
    379         for(x = 0; x < img->width; x++)
    380             setpixel(dst, x, y, 255, 255, 255);
    381 return dst;
    382 
    383     for(y = SSIZE/2; y < img->height - SSIZE/2; y++)
    384         for(x = SSIZE/2; x < img->width - SSIZE/2; x++)
    385         {
    386             val = 0;
    387             for(i = 0; i < SSIZE; i++)
    388                 for(j = 0; j < SSIZE; j++)
    389                 {
    390                     getpixel(img, x + j - SSIZE/2, y + i - SSIZE/2, &r, &g, &b);
    391                     val += r;
    392                 }
    393 
    394             i = val / (SSIZE * SSIZE);
    395             setpixel(dst, x, y, i, i, i);
    396         }
    397 
    398     return dst;
    399 }
    400 
    401 struct image *median(struct image *img)
    402 {
    403 #define MSIZE 4
    404     struct image *dst;
    405     int x, y, i, j, val[MSIZE*MSIZE];
    406     int r, g, b;
    407 
    408     dst = new_image(img->width, img->height);
    409 
    410     for(y = 0; y < img->height; y++)
    411         for(x = 0; x < img->width; x++)
    412             setpixel(dst, x, y, 255, 255, 255);
    413 
    414     for(y = MSIZE/2; y < img->height - MSIZE/2; y++)
    415         for(x = MSIZE/2; x < img->width - MSIZE/2; x++)
    416         {
    417             for(i = 0; i < MSIZE; i++)
    418                 for(j = 0; j < MSIZE; j++)
    419                 {
    420                     getpixel(img, x + j - SSIZE/2, y + i - SSIZE/2, &r, &g, &b);
    421                     val[i * MSIZE + j] = r;
    422                 }
    423 
    424             /* Bubble sort power! */
    425             for(i = 0; i < MSIZE * MSIZE / 2 + 1; i++)
    426                 for(j = i + 1; j < MSIZE * MSIZE; j++)
    427                     if(val[i] > val[j])
    428                     {
    429                         register int k = val[i];
    430                         val[i] = val[j];
    431                         val[j] = k;
    432                     }
    433 
    434             i = val[MSIZE * MSIZE / 2];
    435             setpixel(dst, x, y, i, i, i);
    436179        }
    437180
Note: See TracChangeset for help on using the changeset viewer.