Changeset 445 for pwntcha


Ignore:
Timestamp:
Jan 10, 2005, 12:23:38 PM (16 years ago)
Author:
Sam Hocevar
Message:
  • don't duplicate picture in filter functions.
  • removed OLE code; it doesn't work and won't be needed.
Location:
pwntcha/trunk/src
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • pwntcha/trunk/src/Makefile.am

    r444 r445  
    2020pwntcha_LDADD = $(ADDITIONAL_LDADD)
    2121
    22 #if USE_DEVIL
    23 #ADDITIONAL_CFLAGS =
    24 #ADDITIONAL_LDFLAGS =
    25 #ADDITIONAL_LDADD = -lDevIL
    26 #else
    27 #if USE_OLE
    28 #ADDITIONAL_CFLAGS =
    29 #ADDITIONAL_LDFLAGS =
    30 #ADDITIONAL_LDADD = -luuid -loleaut32 -lole32 -lgdi32
    31 #else
    3222if USE_SDL
    3323ADDITIONAL_CFLAGS = `sdl-config --cflags`
     
    5141endif
    5242endif
    53 #endif
    54 #endif
    5543
  • pwntcha/trunk/src/authimage.c

    r430 r445  
    2727    char *all = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    2828    char *result;
    29     struct image *tmp1, *tmp2, *tmp3;
     29    struct image *tmp;
    3030    int x, y, r, g, b, i;
    3131
     
    4747
    4848    /* half the captchas are inverse video; we set them back to normal */
    49     tmp1 = filter_scale(img, 2.0);
    50     getpixel(img, 0, 0, &r, &g, &b);
    51     tmp2 = filter_equalize(tmp1, r * 3 / 4);
    52     tmp3 = filter_smooth(tmp2);
     49    tmp = image_dup(img);
     50    filter_scale(tmp, 2.0);
     51    getpixel(tmp, 0, 0, &r, &g, &b);
     52    filter_equalize(tmp, r * 3 / 4);
     53    filter_smooth(tmp);
    5354
    5455    for(i = 0; i < 6; i++)
     
    6566                    newx = 35.0 + (x + 6 * i) * 218.0 / 34.0 + y * 5.0 / 6.0 + 0.5;
    6667                    newy = 33.0 - (x + 6 * i) * 18.0 / 34.0 + y * 42.0 / 6.0 + 0.5;
    67                     getpixel(tmp3, newx, newy, &r, &g, &b);
     68                    getpixel(tmp, newx, newy, &r, &g, &b);
    6869                    getpixel(font, x + 6 * ch, y, &r2, &g, &b);
    6970                    r = (r < 220) ? 0 : 255;
     
    8081    }
    8182
    82     image_free(tmp3);
    83     image_free(tmp2);
    84     image_free(tmp1);
     83    image_free(tmp);
    8584
    8685    return result;
  • pwntcha/trunk/src/clubic.c

    r430 r445  
    1818#include "common.h"
    1919
    20 static struct image *find_glyphs(struct image *img);
     20static void find_glyphs(struct image *img);
    2121
    2222/* Our macros */
     
    2828char *decode_clubic(struct image *img)
    2929{
    30     struct image *tmp1, *tmp2;
     30    struct image *tmp;
    3131
    3232    if(!font)
     
    4646    strcpy(result, "      ");
    4747
    48     tmp1 = filter_equalize(img, 200);
    49     tmp2 = find_glyphs(tmp1);
     48    tmp = image_dup(img);
     49    filter_equalize(tmp, 200);
     50    find_glyphs(tmp);
    5051
    51     image_free(tmp1);
    52     image_free(tmp2);
     52    image_free(tmp);
    5353
    5454    return result;
    5555}
    5656
    57 static struct image *find_glyphs(struct image *img)
     57static void find_glyphs(struct image *img)
    5858{
    5959    char all[] = "0123456789";
     
    6464    }
    6565    glyphs[10];
    66     struct image *dst;
     66    struct image *tmp;
    6767    int x, y, i = 0;
    6868    int r, g, b;
     
    7070    int distmin, distx, disty, distch;
    7171
    72     dst = image_new(img->width, img->height);
     72    tmp = image_new(img->width, img->height);
    7373
    7474    for(y = 0; y < img->height; y++)
     
    7676        {
    7777            getpixel(img, x, y, &r, &g, &b);
    78             setpixel(dst, x, y, 255, g, 255);
     78            setpixel(tmp, x, y, 255, g, 255);
    7979        }
    8080
     
    169169                getpixel(font, xmin + x, ymin + y, &r, &g, &b);
    170170                if(r > 128) continue;
    171                 setpixel(dst, distx + x, disty + y, r, g, b);
     171                setpixel(tmp, distx + x, disty + y, r, g, b);
    172172            }
    173173
     
    176176    }
    177177
    178     return dst;
     178    image_free(tmp);
    179179}
    180180
  • pwntcha/trunk/src/common.h

    r438 r445  
    3838struct image *image_load(const char *name);
    3939struct image *image_new(int width, int height);
     40struct image *image_dup(struct image *img);
    4041void image_free(struct image *img);
    4142void image_save(struct image *img, const char *name);
     43void image_swap(struct image *img1, struct image *img2);
    4244int getgray(struct image *img, int x, int y, int *g);
    4345int getpixel(struct image *img, int x, int y, int *r, int *g, int *b);
     
    4648/* image filters */
    4749void filter_flood_fill(struct image *img, int x, int y, int r, int g, int b);
    48 struct image *filter_fill_holes(struct image *img);
    49 struct image *filter_dup(struct image *img);
    50 struct image *filter_scale(struct image *img, float ratio);
    51 struct image *filter_black_stuff(struct image *img);
    52 struct image *filter_detect_lines(struct image *img);
    53 struct image *filter_equalize(struct image *img, int threshold);
    54 struct image *filter_trick(struct image *img);
    55 struct image *filter_smooth(struct image *img);
    56 struct image *filter_median(struct image *img);
    57 struct image *filter_contrast(struct image *img);
    58 struct image *filter_crop(struct image *img,
    59                           int xmin, int ymin, int xmax, int ymax);
     50void filter_fill_holes(struct image *img);
     51void filter_scale(struct image *img, float ratio);
     52void filter_black_stuff(struct image *img);
     53void filter_detect_lines(struct image *img);
     54void filter_equalize(struct image *img, int threshold);
     55void filter_trick(struct image *img);
     56void filter_smooth(struct image *img);
     57void filter_median(struct image *img);
     58void filter_contrast(struct image *img);
     59void filter_crop(struct image *img, int xmin, int ymin, int xmax, int ymax);
    6060int filter_count(struct image *img);
    6161
  • pwntcha/trunk/src/filters.c

    r441 r445  
    4747}
    4848
    49 struct image *filter_dup(struct image *img)
    50 {
    51     struct image *dst;
    52     int x, y;
    53     int r, g, b;
    54 
    55     dst = image_new(img->width, img->height);
    56 
    57     for(y = 0; y < img->height; y++)
    58         for(x = 0; x < img->width; x++)
    59         {
    60             getpixel(img, x, y, &r, &g, &b);
    61             setpixel(dst, x, y, r, g, b);
    62         }
    63 
    64     return dst;
    65 }
    66 
    67 struct image *filter_scale(struct image *img, float ratio)
     49void filter_scale(struct image *img, float ratio)
    6850{
    6951    struct image *dst;
     
    8365        }
    8466
    85     return dst;
    86 }
    87 
    88 struct image *filter_fill_holes(struct image *img)
     67    image_swap(img, dst);
     68    image_free(dst);
     69}
     70
     71void filter_fill_holes(struct image *img)
    8972{
    9073    struct image *dst;
     
    133116        }
    134117
    135     return dst;
    136 }
    137 
    138 struct image *filter_black_stuff(struct image *img)
     118    image_swap(img, dst);
     119    image_free(dst);
     120}
     121
     122void filter_black_stuff(struct image *img)
    139123{
    140124    struct image *dst;
     
    173157        }
    174158
    175     return dst;
    176 }
    177 
    178 struct image *filter_detect_lines(struct image *img)
     159    image_swap(img, dst);
     160    image_free(dst);
     161}
     162
     163void filter_detect_lines(struct image *img)
    179164{
    180165    struct image *dst;
     
    213198        }
    214199
    215     return dst;
    216 }
    217 
    218 struct image *filter_equalize(struct image *img, int threshold)
     200    image_swap(img, dst);
     201    image_free(dst);
     202}
     203
     204void filter_equalize(struct image *img, int threshold)
    219205{
    220206    struct image *dst;
     
    244230        }
    245231
    246     return dst;
    247 }
    248 
    249 struct image *filter_trick(struct image *img)
     232    image_swap(img, dst);
     233    image_free(dst);
     234}
     235
     236void filter_trick(struct image *img)
    250237{
    251238#define TSIZE 3
     
    290277        }
    291278
    292     return dst;
    293 }
    294 
    295 struct image *filter_smooth(struct image *img)
     279    image_swap(img, dst);
     280    image_free(dst);
     281}
     282
     283void filter_smooth(struct image *img)
    296284{
    297285#define SSIZE 3
     
    321309        }
    322310
    323     return dst;
    324 }
    325 
    326 struct image *filter_median(struct image *img)
     311    image_swap(img, dst);
     312    image_free(dst);
     313}
     314
     315void filter_median(struct image *img)
    327316{
    328317#define MSIZE 3
     
    361350        }
    362351
    363     return dst;
    364 }
    365 
    366 struct image *filter_contrast(struct image *img)
     352    image_swap(img, dst);
     353    image_free(dst);
     354}
     355
     356void filter_contrast(struct image *img)
    367357{
    368358    struct image *dst;
     
    394384        }
    395385
    396     return dst;
    397 }
    398 
    399 struct image *filter_crop(struct image *img,
    400                           int xmin, int ymin, int xmax, int ymax)
     386    image_swap(img, dst);
     387    image_free(dst);
     388}
     389
     390void filter_crop(struct image *img, int xmin, int ymin, int xmax, int ymax)
    401391{
    402392    struct image *dst;
     
    414404
    415405    if(xmin >= xmax || ymin >= ymax)
    416         return NULL;
     406        return;
    417407
    418408    dst = image_new(xmax - xmin, ymax - ymin);
     
    425415        }
    426416
    427     return dst;
     417    image_swap(img, dst);
     418    image_free(dst);
    428419}
    429420
  • pwntcha/trunk/src/image.c

    r442 r445  
    1212#include <stdio.h>
    1313#include <stdlib.h>
     14#include <string.h>
    1415
    1516#include "config.h"
    1617#include "common.h"
    1718
    18 #if defined(HAVE_IL_H)
    19 #   error "DevIL routines not implemented yet"
    20 #elif defined(HAVE_OLECTL_H)
    21 #   include <windows.h>
    22 #   include <ocidl.h>
    23 #   include <olectl.h>
    24 static BOOL oleload(LPCTSTR name, LPPICTURE* pic);
    25 struct priv
    26 {
    27     HBITMAP bitmap;
    28     BITMAPINFO info;
    29 };
    30 #elif defined(HAVE_SDL_IMAGE_H)
     19#if defined(HAVE_SDL_IMAGE_H)
    3120#   include <SDL_image.h>
    3221#elif defined(HAVE_IMLIB2_H)
     
    4231{
    4332    struct image *img;
    44 #if defined(HAVE_IL_H)
    45 #elif defined(HAVE_OLECTL_H)
    46     struct priv *priv = malloc(sizeof(struct priv));
    47     LPPICTURE pic = NULL;
    48     HDC dc;
    49     long scrwidth = 0, scrheight = 0;
    50     int width, height;
    51     void *data = NULL;
    52 #elif defined(HAVE_SDL_IMAGE_H)
     33#if defined(HAVE_SDL_IMAGE_H)
    5334    SDL_Surface *priv = IMG_Load(name);
    5435#elif defined(HAVE_IMLIB2_H)
     
    6142        return NULL;
    6243
    63 #if defined(HAVE_OLECTL_H)
    64     if(!oleload((LPCTSTR)name, &pic))
    65     {
    66         free(priv);
    67         return NULL;
    68     }
    69 
    70 #if 0
    71     for(i = 0; ; i++)
    72     {
    73         DEVMODE devMode;
    74         devMode.dmSize = sizeof(DEVMODE);
    75 
    76         if(EnumDisplaySettings(NULL, i, &devMode) != 1)
    77             break;
    78 
    79         printf("mode %i x %i - %i\n", (int)devMode.dmPelsWidth,
    80                (int)devMode.dmPelsHeight, (int)devMode.dmBitsPerPel);
    81     }
    82 #endif
    83 
    84     dc = CreateCompatibleDC(NULL);
    85 
    86     if(GetDeviceCaps(dc, BITSPIXEL) < 24)
    87     {
    88         fprintf(stderr, "%s: 24bpp screen depth or better required\n", argv0);
    89         DeleteDC(dc);
    90         free(priv);
    91         return NULL;
    92     }
    93 
    94     pic->lpVtbl->get_Width(pic, &scrwidth);
    95     pic->lpVtbl->get_Height(pic, &scrheight);
    96     width = (scrwidth * GetDeviceCaps(dc, LOGPIXELSX) + 2540 / 2) / 2540;
    97     height = (scrheight * GetDeviceCaps(dc, LOGPIXELSY) + 2540 / 2) / 2540;
    98 
    99     memset(&priv->info, 0, sizeof(BITMAPINFO));
    100     priv->info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    101     priv->info.bmiHeader.biBitCount = 24;
    102     priv->info.bmiHeader.biWidth = width;
    103     priv->info.bmiHeader.biHeight = -height;
    104     priv->info.bmiHeader.biCompression = BI_RGB;
    105     priv->info.bmiHeader.biPlanes = 1;
    106 
    107     priv->bitmap = CreateDIBSection(dc, &priv->info, DIB_RGB_COLORS, &data, 0, 0);
    108     SelectObject(dc, priv->bitmap);
    109     pic->lpVtbl->Render(pic, dc, 0, 0, width, height,
    110                         0, scrheight, scrwidth, -scrheight, NULL);
    111     pic->lpVtbl->Release(pic);
    112     DeleteDC(dc);
    113 #elif defined(HAVE_SDL_IMAGE_H)
     44#if defined(HAVE_SDL_IMAGE_H)
    11445    if(priv->format->BytesPerPixel == 1)
    11546    {
     
    12253
    12354    img = (struct image *)malloc(sizeof(struct image));
    124 #if defined(HAVE_IL_H)
    125 #elif defined(HAVE_OLECTL_H)
    126     img->width = width;
    127     img->height = height;
    128     img->pitch = 3 * width;
    129     img->channels = 3;
    130     img->pixels = data;
    131 #elif defined(HAVE_SDL_IMAGE_H)
     55#if defined(HAVE_SDL_IMAGE_H)
    13256    img->width = priv->w;
    13357    img->height = priv->h;
     
    15781{
    15882    struct image *img;
    159 #if defined(HAVE_IL_H)
    160 #elif defined(HAVE_OLECTL_H)
    161     struct priv *priv = malloc(sizeof(struct priv));
    162     HDC dc;
    163     void *data = NULL;
    164 #elif defined(HAVE_SDL_IMAGE_H)
     83#if defined(HAVE_SDL_IMAGE_H)
    16584    SDL_Surface *priv;
    16685    Uint32 rmask, gmask, bmask, amask;
     
    188107
    189108    img = (struct image *)malloc(sizeof(struct image));
    190 #if defined(HAVE_IL_H)
    191 #elif defined(HAVE_OLECTL_H)
    192     dc = CreateCompatibleDC(NULL);
    193     if(GetDeviceCaps(dc, BITSPIXEL) < 24)
    194     {
    195         fprintf(stderr, "a screen depth of at least 24bpp is required\n");
    196         DeleteDC(dc);
    197         free(priv);
    198         return NULL;
    199     }
    200     priv->info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    201     priv->info.bmiHeader.biWidth = width;
    202     priv->info.bmiHeader.biHeight = -height;
    203     priv->info.bmiHeader.biCompression = BI_RGB;
    204     priv->info.bmiHeader.biBitCount = 24;
    205     priv->info.bmiHeader.biPlanes = 1;
    206     priv->bitmap = CreateDIBSection(dc, &priv->info,
    207                                     DIB_RGB_COLORS, &data, 0, 0);
    208     DeleteDC(dc);
    209     img->width = width;
    210     img->height = height;
    211     img->pitch = 3 * width;
    212     img->channels = 3;
    213     img->pixels = data;
    214 #elif defined(HAVE_SDL_IMAGE_H)
     109#if defined(HAVE_SDL_IMAGE_H)
    215110    img->width = priv->w;
    216111    img->height = priv->h;
     
    237132}
    238133
     134struct image *image_dup(struct image *img)
     135{
     136    struct image *dst;
     137    int x, y;
     138    dst = image_new(img->width, img->height);
     139    for(y = 0; y < img->height; y++)
     140    {
     141        for(x = 0; x < img->width; x++)
     142        {
     143            int r, g, b;
     144            getpixel(img, x, y, &r, &g, &b);
     145            setpixel(dst, x, y, r, g, b);
     146        }
     147    }
     148    return dst;
     149}
     150
    239151void image_free(struct image *img)
    240152{
    241 #if defined(HAVE_IL_H)
    242 #elif defined(HAVE_OLECTL_H)
    243     struct priv *priv = img->priv;
    244     DeleteObject(priv->bitmap);
    245     free(img->priv);
    246 #elif defined(HAVE_SDL_IMAGE_H)
     153#if defined(HAVE_SDL_IMAGE_H)
    247154    SDL_FreeSurface(img->priv);
    248155#elif defined(HAVE_IMLIB2_H)
     
    260167void image_save(struct image *img, const char *name)
    261168{
    262 #if defined(HAVE_IL_H)
    263 #elif defined(HAVE_OLECTL_H)
    264 
    265 #elif defined(HAVE_SDL_IMAGE_H)
     169#if defined(HAVE_SDL_IMAGE_H)
    266170    SDL_SaveBMP(img->priv, name);
    267171#elif defined(HAVE_IMLIB2_H)
     
    271175    cvSaveImage(name, img->priv);
    272176#endif
     177}
     178
     179void image_swap(struct image *img1, struct image *img2)
     180{
     181    struct image tmp;
     182    memcpy(&tmp, img1, sizeof(tmp));
     183    memcpy(img1, img2, sizeof(tmp));
     184    memcpy(img2, &tmp, sizeof(tmp));
    273185}
    274186
     
    315227}
    316228
    317 #if defined(HAVE_OLECTL_H)
    318 static BOOL oleload(LPCTSTR name, LPPICTURE* pic)
    319 {
    320     HRESULT ret;
    321     HANDLE h;
    322     DWORD size, read = 0;
    323     LPVOID data;
    324     HGLOBAL buffer;
    325     LPSTREAM stream = NULL;
    326 
    327     h = CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
    328     if (h == INVALID_HANDLE_VALUE)
    329         return FALSE;
    330 
    331     size = GetFileSize(h, NULL);
    332     if(size == (DWORD)-1)
    333     {
    334         CloseHandle(h);
    335         return FALSE;
    336     }
    337 
    338     buffer = GlobalAlloc(GMEM_MOVEABLE, size);
    339     if(!buffer)
    340     {
    341         CloseHandle(h);
    342         return FALSE;
    343     }
    344 
    345     data = GlobalLock(buffer);
    346     if(!data)
    347     {
    348         GlobalUnlock(buffer);
    349         CloseHandle(h);
    350         return FALSE;
    351     }
    352 
    353     ret = ReadFile(h, data, size, &read, NULL);
    354     GlobalUnlock(buffer);
    355     CloseHandle(h);
    356 
    357     if(!ret)
    358         return FALSE;
    359 
    360     ret = CreateStreamOnHGlobal(buffer, TRUE, &stream);
    361     if(!SUCCEEDED(ret))
    362     {
    363         if(stream)
    364             stream->lpVtbl->Release(stream);
    365         return FALSE;
    366     }
    367 
    368     if(!stream)
    369         return FALSE;
    370 
    371     if(*pic)
    372         (*pic)->lpVtbl->Release(*pic);
    373 
    374     ret = OleLoadPicture(stream, size, FALSE, &IID_IPicture, (PVOID *)pic);
    375     stream->lpVtbl->Release(stream);
    376 
    377     if(!SUCCEEDED(ret))
    378         return FALSE;
    379 
    380     if(!*pic)
    381         return FALSE;
    382 
    383     return TRUE;
    384 }
    385 #endif
    386 
  • pwntcha/trunk/src/linuxfr.c

    r430 r445  
    4848    memset(result, '\0', 8);
    4949
    50     tmp = filter_equalize(img, 150);
     50    tmp = image_dup(img);
     51    filter_equalize(tmp, 150);
    5152
    52     for(y = 0; y < img->height; y++)
     53    for(y = 0; y < tmp->height; y++)
    5354    {
    5455        int count = 0;
    55         for(x = 0; x < img->width; x++)
     56        for(x = 0; x < tmp->width; x++)
    5657        {
    5758            getpixel(tmp, x, y, &r, &g, &b);
     
    6465    /* Find 7 consecutive lines that have at least 14 pixels; they're
    6566     * baseline candidates */
    66     for(y = 0; y < img->height - 11; y++)
     67    for(y = 0; y < tmp->height - 11; y++)
    6768    {
    6869        int ycan = 1;
     
    8182        /* Find 7 consecutive cells that have at least 2 pixels on
    8283         * each line; they're base column candidates */
    83         for(x = 0; x < img->width - 9 * 7 + 1; x++)
     84        for(x = 0; x < tmp->width - 9 * 7 + 1; x++)
    8485        {
    8586            int goodx = 1;
  • pwntcha/trunk/src/phpbb.c

    r430 r445  
    2727    char all[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
    2828    char *result;
    29     struct image *tmp1, *tmp2, *tmp3;
     29    struct image *tmp1, *tmp2;
    3030    int x, y, i = 0;
    3131    int r, g, b;
     
    4949    strcpy(result, "      ");
    5050
    51     tmp1 = filter_smooth(img);
    52     tmp2 = filter_equalize(tmp1, 128);
    53     tmp3 = image_new(img->width, img->height);
     51    tmp1 = image_dup(img);
     52    tmp2 = image_new(img->width, img->height);
     53
     54    filter_smooth(tmp1);
     55    filter_equalize(tmp1, 128);
    5456
    5557    for(x = 0; x < img->width; x++)
    5658        for(y = 0; y < img->height; y++)
    5759        {
    58             getpixel(tmp2, x, y, &r, &g, &b);
     60            getpixel(tmp1, x, y, &r, &g, &b);
    5961            if(r == 0 && offset == -1)
    6062                offset = x;
    6163            getpixel(img, x, y, &r, &g, &b);
    62             setpixel(tmp3, x, y, 255, g, 255);
     64            setpixel(tmp2, x, y, 255, g, 255);
    6365        }
    6466
     
    9092                            int r2;
    9193                            getgray(font, xmin + z, ymin + t, &r);
    92                             getgray(tmp2, x + z, y + t, &r2);
     94                            getgray(tmp1, x + z, y + t, &r2);
    9395                            if(r > r2)
    9496                                dist += r - r2;
     
    124126                getpixel(font, xmin + x, ymin + y, &r2, &g, &b);
    125127                if(r2 > 128) continue;
    126                 getpixel(tmp3, distx + x, disty + y, &r, &g, &b);
    127                 setpixel(tmp3, distx + x, disty + y, r2, g, b);
     128                getpixel(tmp2, distx + x, disty + y, &r, &g, &b);
     129                setpixel(tmp2, distx + x, disty + y, r2, g, b);
    128130            }
    129131
     
    134136    image_free(tmp1);
    135137    image_free(tmp2);
    136     image_free(tmp3);
    137138
    138139    return result;
  • pwntcha/trunk/src/scode.c

    r425 r445  
    3131    result = malloc(1024 * sizeof(char));
    3232
    33     tmp1 = filter_dup(img);
     33    tmp1 = image_dup(img);
    3434
    3535    /* Remove border */
  • pwntcha/trunk/src/slashdot.c

    r430 r445  
    1919#include "common.h"
    2020
    21 static struct image *count_objects(struct image *img);
    22 static struct image *rotate(struct image *img);
    23 static struct image *cut_cells(struct image *img);
    24 static struct image *find_glyphs(struct image *img);
     21static void count_objects(struct image *img);
     22static void rotate(struct image *img);
     23static void cut_cells(struct image *img);
     24static void find_glyphs(struct image *img);
    2525
    2626/* Our macros */
     
    3939char *decode_slashdot(struct image *img)
    4040{
    41     struct image *tmp1, *tmp2, *tmp3, *tmp4, *tmp5, *tmp6, *tmp7;
     41    struct image *tmp1, *tmp2;
    4242
    4343    /* Initialise local data */
     
    5151
    5252    /* Clean image a bit */
    53     tmp1 = filter_detect_lines(img);
    54     tmp2 = filter_fill_holes(tmp1);
     53    tmp1 = image_dup(img);
     54    filter_detect_lines(tmp1);
     55    filter_fill_holes(tmp1);
    5556
    5657    /* Detect small objects to guess image orientation */
    57     tmp3 = filter_median(tmp2);
    58     tmp4 = filter_equalize(tmp3, 200);
    59     count_objects(tmp4);
     58    tmp2 = image_dup(tmp1);
     59    filter_median(tmp2);
     60    filter_equalize(tmp2, 200);
     61    count_objects(tmp2);
    6062
    6163    /* Invert rotation and find glyphs */
    62     tmp5 = rotate(tmp2);
    63     tmp6 = filter_median(tmp5);
    64     tmp7 = find_glyphs(tmp6);
     64    rotate(tmp1);
     65    filter_median(tmp1);
     66    find_glyphs(tmp1);
    6567
    6668    /* Clean up our mess */
    6769    image_free(tmp1);
    6870    image_free(tmp2);
    69     image_free(tmp3);
    70     image_free(tmp4);
    71     image_free(tmp5);
    72     image_free(tmp6);
    73     image_free(tmp7);
    7471
    7572    /* aaaaaaa means decoding failed */
     
    8279/* The following functions are local */
    8380
    84 static struct image *count_objects(struct image *img)
    85 {
    86     struct image *dst;
     81static void count_objects(struct image *img)
     82{
     83    struct image *tmp;
    8784    int gotblack = 1;
    8885    int x, y, i;
    8986    int r, g, b;
    9087
    91     dst = image_new(img->width, img->height);
     88    tmp = image_new(img->width, img->height);
    9289
    9390    for(y = 0; y < img->height; y++)
     
    9592        {
    9693            getpixel(img, x, y, &r, &g, &b);
    97             setpixel(dst, x, y, r, g, b);
     94            setpixel(tmp, x, y, r, g, b);
    9895        }
    9996
     
    10198    {
    10299        gotblack = 0;
    103         for(y = 0; y < dst->height; y++)
    104             for(x = 0; x < dst->width; x++)
    105             {
    106                 getpixel(dst, x, y, &r, &g, &b);
     100        for(y = 0; y < tmp->height; y++)
     101            for(x = 0; x < tmp->width; x++)
     102            {
     103                getpixel(tmp, x, y, &r, &g, &b);
    107104                if(r == 0 && g == 0 && b == 0)
    108105                {
    109106                    gotblack = 1;
    110                     filter_flood_fill(dst, x, y, 254 - objects, 0, 0);
     107                    filter_flood_fill(tmp, x, y, 254 - objects, 0, 0);
    111108                    objects++;
    112109                }
     
    118115    for(i = 0; i < objects; i++)
    119116    {
    120         objlist[i].ymin = dst->height;
     117        objlist[i].ymin = tmp->height;
    121118        objlist[i].ymax = 0;
    122119
    123         for(y = 0; y < dst->height; y++)
    124             for(x = 0; x < dst->width; x++)
    125             {
    126                 getpixel(dst, x, y, &r, &g, &b);
     120        for(y = 0; y < tmp->height; y++)
     121            for(x = 0; x < tmp->width; x++)
     122            {
     123                getpixel(tmp, x, y, &r, &g, &b);
    127124                if(r == 255 - i && g == 0 && b == 0)
    128125                {
     
    137134                first = i;
    138135            last = i;
    139             filter_flood_fill(dst, objlist[i].xmin, objlist[i].ymin, 0, 0, 255);
     136            filter_flood_fill(tmp, objlist[i].xmin, objlist[i].ymin, 0, 0, 255);
    140137        }
    141138    }
     
    147144      B.x = (objlist[last].xmin + objlist[last].xmax) / 2;
    148145      B.y = (objlist[last].ymin + objlist[last].ymax) / 2;
    149       cvLine(dst, A, B, 0, 2.0, 0);
     146      cvLine(tmp, A, B, 0, 2.0, 0);
    150147    }
    151148#endif
    152149
    153     return dst;
    154 }
    155 
    156 static struct image *rotate(struct image *img)
    157 {
    158     struct image *dst;
     150    image_swap(img, tmp);
     151    image_free(tmp);
     152}
     153
     154static void rotate(struct image *img)
     155{
     156    struct image *tmp;
    159157    int x, y, xdest, ydest;
    160158    int r, g, b;
     
    171169    }
    172170
    173     dst = image_new(img->width * FACTOR, img->height * FACTOR);
     171    tmp = image_new(img->width * FACTOR, img->height * FACTOR);
    174172
    175173    for(y = 0; y < img->height * FACTOR; y++)
     
    192190            if(r == 255 && g == 0 && b == 255)
    193191                g = 255;
    194             setpixel(dst, x, y, r, g, b);
    195         }
    196 
    197     return dst;
    198 }
    199 
    200 static struct image *cut_cells(struct image *img)
    201 {
    202     struct image *dst;
     192            setpixel(tmp, x, y, r, g, b);
     193        }
     194
     195    image_swap(img, tmp);
     196    image_free(tmp);
     197}
     198
     199static void cut_cells(struct image *img)
     200{
     201    struct image *tmp;
    203202    int x, y;
    204203    int r, g, b;
    205204
    206     dst = image_new(img->width, img->height);
     205    tmp = image_new(img->width, img->height);
    207206
    208207    for(y = 0; y < img->height; y++)
     
    210209        {
    211210            getpixel(img, x, y, &r, &g, &b);
    212             setpixel(dst, x, y, r, g, b);
     211            setpixel(tmp, x, y, r, g, b);
    213212        }
    214213
    215214    for(x = 0; x < img->width; x++)
    216215    {
    217         setpixel(dst, x, 0, 255, 255, 255);
    218         setpixel(dst, x, img->height - 1, 255, 255, 255);
     216        setpixel(tmp, x, 0, 255, 255, 255);
     217        setpixel(tmp, x, img->height - 1, 255, 255, 255);
    219218    }
    220219
     
    222221        for(x = 0; x < 7; x++)
    223222        {
    224             setpixel(dst, x * img->width / 7, y, 255, 255, 255);
    225             setpixel(dst, (x + 1) * img->width / 7 - 1, y, 255, 255, 255);
    226         }
    227 
    228     return dst;
    229 }
    230 
    231 static struct image *find_glyphs(struct image *img)
     223            setpixel(tmp, x * img->width / 7, y, 255, 255, 255);
     224            setpixel(tmp, (x + 1) * img->width / 7 - 1, y, 255, 255, 255);
     225        }
     226
     227    image_swap(img, tmp);
     228    image_free(tmp);
     229}
     230
     231static void find_glyphs(struct image *img)
    232232{
    233233    char all[] = "abcdefgijkmnpqrstvwxyz";
     
    238238    }
    239239    glyphs[22];
    240     struct image *dst;
     240    struct image *tmp;
    241241    int x, y, i = 0;
    242242    int r, g, b;
     
    256256    }
    257257
    258     dst = image_new(img->width, img->height);
     258    tmp = image_new(img->width, img->height);
    259259
    260260    for(y = 0; y < img->height; y++)
     
    262262        {
    263263            getpixel(img, x, y, &r, &g, &b);
    264             setpixel(dst, x, y, 255, g, 255);
     264            setpixel(tmp, x, y, 255, g, 255);
    265265        }
    266266
     
    387387                getpixel(font, xmin + x, ymin + y, &r, &g, &b);
    388388                if(r > 128) continue;
    389                 setpixel(dst, distx + x, disty + y, r, g, b);
     389                setpixel(tmp, distx + x, disty + y, r, g, b);
    390390            }
    391391
     
    394394    }
    395395
    396     return dst;
    397 }
    398 
     396    image_swap(img, tmp);
     397    image_free(tmp);
     398}
     399
  • pwntcha/trunk/src/test.c

    r430 r445  
    2222#define FONTNAME "font_phpbb.png"
    2323
    24 static struct image *find_glyphs(struct image *img);
     24static void find_glyphs(struct image *img);
    2525
    2626/* Global stuff */
     
    3232char *decode_test(struct image *img)
    3333{
    34     struct image *tmp1, *tmp2, *tmp3, *tmp4, *tmp5, *tmp6, *tmp7;
     34    struct image *tmp;
    3535
    3636    /* Initialise local data */
     
    4242    result = malloc(7 * sizeof(char));
    4343
    44     tmp1 = filter_smooth(img);
    45     tmp2 = filter_median(tmp1);
    46     tmp3 = filter_equalize(tmp2, 130);
    47     tmp4 = filter_median(tmp3);
    48     tmp5 = find_glyphs(tmp3);
     44    tmp = image_dup(img);
     45    filter_smooth(tmp);
     46    filter_median(tmp);
     47    filter_equalize(tmp, 130);
     48    filter_median(tmp);
     49    find_glyphs(tmp);
    4950
    50     image_free(tmp1);
    51     image_free(tmp2);
    52     image_free(tmp3);
    53     image_free(tmp4);
    54     image_free(tmp5);
     51    image_free(tmp);
    5552
    5653    return result;
     
    5956/* The following functions are local */
    6057
    61 static struct image *find_glyphs(struct image *img)
     58static void find_glyphs(struct image *img)
    6259{
    6360    char all[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
    64     struct image *dst, *font;
     61    struct image *tmp, *font;
    6562    int x, y, i = 0;
    6663    int r, g, b;
    67     int xmin, xmax, ymin, ymax, incell = 0, count = 0, cur = 0, offset = -1;
     64    int xmin, xmax, ymin, ymax, cur = 0, offset = -1;
    6865    int distmin, distx, disty, distch;
    6966
     
    8077    }
    8178
    82     dst = image_new(img->width, img->height);
     79    tmp = image_new(img->width, img->height);
    8380
    8481    for(x = 0; x < img->width; x++)
     
    8683        {
    8784            getpixel(img, x, y, &r, &g, &b);
    88             setpixel(dst, x, y, 255, g, 255);
     85            setpixel(tmp, x, y, 255, g, 255);
    8986            if(r == 0 && offset == -1)
    9087                offset = x;
     
    150147                getpixel(font, xmin + x, ymin + y, &r, &g, &b);
    151148                if(r > 128) continue;
    152                 setpixel(dst, distx + x, disty + y, r, g, b);
     149                setpixel(tmp, distx + x, disty + y, r, g, b);
    153150            }
    154151
     
    157154    }
    158155
    159     return dst;
     156    image_swap(img, tmp);
     157    image_free(tmp);
    160158}
    161159
  • pwntcha/trunk/src/vbulletin.c

    r430 r445  
    2626    char all[] = "2346789ABCDEFGHJKLMNPRTWXYZ";
    2727    char *result;
    28     struct image *tmp1, *tmp2, *tmp3;
     28    struct image *tmp;
    2929    int limits[6] = { 26, 53, 80, 107, 134, 160 };
    3030    int x, y, r, g, b, i, j;
     
    4747
    4848    /* half the captchas are inverse video; we set them back to normal */
    49     getpixel(img, 0, 0, &r, &g, &b);
     49    tmp = image_dup(img);
     50    getpixel(tmp, 0, 0, &r, &g, &b);
    5051    if(r < 50)
    51         tmp1 = filter_equalize(img, 128);
     52        filter_equalize(tmp, 128);
    5253    else
    53         tmp1 = filter_equalize(img, -128);
     54        filter_equalize(tmp, -128);
    5455
    5556    /* Remove garbage around the cells */
    56     for(x = 0; x < img->width; x++)
     57    for(x = 0; x < tmp->width; x++)
    5758    {
    5859        for(y = 0; y < 15; y++)
    59             setpixel(tmp1, x, y, 255, 255, 255);
    60         for(y = 45; y < img->height; y++)
    61             setpixel(tmp1, x, y, 255, 255, 255);
     60            setpixel(tmp, x, y, 255, 255, 255);
     61        for(y = 45; y < tmp->height; y++)
     62            setpixel(tmp, x, y, 255, 255, 255);
    6263    }
    6364
    64     for(x = 0; x < img->width; x++)
     65    for(x = 0; x < tmp->width; x++)
    6566    {
    6667        for(i = 0; i < 6; i++)
     
    6970        if(i == 6)
    7071            for(y = 15; y < 45; y++)
    71                 setpixel(tmp1, x, y, 255, 255, 255);
     72                setpixel(tmp, x, y, 255, 255, 255);
    7273        else
    7374            x += 11;
    7475    }
    7576
    76     tmp2 = filter_black_stuff(tmp1);
    77     tmp3 = filter_black_stuff(tmp2);
     77    filter_black_stuff(tmp);
     78    filter_black_stuff(tmp);
    7879
    7980    /* Fill letters in gray */
    8081    for(x = 26; x < 172; x++)
    8182    {
    82         getpixel(tmp3, x, 15, &r, &g, &b);
     83        getpixel(tmp, x, 15, &r, &g, &b);
    8384        if(r == 0)
    84             filter_flood_fill(tmp3, x, 15, 127, 0, 255);
     85            filter_flood_fill(tmp, x, 15, 127, 0, 255);
    8586    }
    8687
     
    8990        for(y = 15; y < 45; y++)
    9091        {
    91             getpixel(tmp3, x, y, &r, &g, &b);
     92            getpixel(tmp, x, y, &r, &g, &b);
    9293            if(r == 0)
    93                 filter_flood_fill(tmp3, x, y, 255, 255, 255);
     94                filter_flood_fill(tmp, x, y, 255, 255, 255);
    9495        }
    9596
     
    9798    for(x = 26; x < 172; x++)
    9899    {
    99         getpixel(tmp3, x, 44, &r, &g, &b);
     100        getpixel(tmp, x, 44, &r, &g, &b);
    100101        if(r == 127)
    101             filter_flood_fill(tmp3, x, 44, 0, 0, 0);
     102            filter_flood_fill(tmp, x, 44, 0, 0, 0);
    102103    }
    103104
     
    106107        for(y = 15; y < 45; y++)
    107108        {
    108             getpixel(tmp3, x, y, &r, &g, &b);
     109            getpixel(tmp, x, y, &r, &g, &b);
    109110            if(r == 127)
    110                 filter_flood_fill(tmp3, x, y, 255, 255, 255);
     111                filter_flood_fill(tmp, x, y, 255, 255, 255);
    111112        }
    112113
     
    114115    for(i = 0; i < 6; i++)
    115116    {
    116         struct image *new;
     117        struct image *new = image_dup(tmp);
    117118        int mindist = INT_MAX, min = -1;
    118         new = filter_crop(tmp3, limits[i], 15, limits[i] + 11, 45);
     119        filter_crop(new, limits[i], 15, limits[i] + 11, 45);
    119120        for(j = 0; j < 27; j++)
    120121        {
     
    138139    }
    139140
    140     image_free(tmp1);
    141     image_free(tmp2);
    142     image_free(tmp3);
     141    image_free(tmp);
    143142
    144143    return result;
  • pwntcha/trunk/src/xanga.c

    r444 r445  
    1919#include "common.h"
    2020
    21 static struct image *fill_white_holes(struct image *img);
    22 static struct image *rotate(struct image *img);
    23 static struct image *cut_cells(struct image *img);
    24 static struct image *find_glyphs(struct image *img);
     21static void fill_white_holes(struct image *img);
    2522
    2623/* Our macros */
     
    3936char *decode_xanga(struct image *img)
    4037{
    41     struct image *tmp1, *tmp2, *tmp3, *tmp4, *tmp5, *tmp6, *tmp7;
     38    struct image *tmp;
    4239
    4340    /* Initialise local data */
     
    5047    strcpy(result, "       ");
    5148
    52 image_save(img, "xanga1.bmp");
     49    tmp = image_dup(img);
     50image_save(tmp, "xanga1.bmp");
    5351    /* Clean image a bit */
    54 //    tmp1 = filter_equalize(img, 200);
    55     tmp1 = filter_contrast(img);
    56     //tmp1 = filter_detect_lines(img);
    57 image_save(tmp1, "xanga2.bmp");
    58     tmp2 = fill_white_holes(tmp1);
    59 //    tmp2 = filter_fill_holes(tmp1);
    60 image_save(tmp2, "xanga3.bmp");
    61     //tmp3 = filter_detect_lines(tmp2);
    62 //    tmp3 = filter_median(tmp2);
    63 //image_save(tmp3, "xanga4.bmp");
    64     tmp3 = filter_equalize(tmp2, 128);
    65 image_save(tmp3, "xanga4.bmp");
     52//    filter_equalize(tmp, 200);
     53    filter_contrast(tmp);
     54    //filter_detect_lines(tmp);
     55image_save(tmp, "xanga2.bmp");
     56    fill_white_holes(tmp);
     57//    filter_fill_holes(tmp);
     58image_save(tmp, "xanga3.bmp");
     59    //filter_detect_lines(tmp);
     60//    filter_median(tmp);
     61//image_save(tmp, "xanga4.bmp");
     62    filter_equalize(tmp, 128);
     63image_save(tmp, "xanga4.bmp");
    6664return NULL;
    6765
    6866    /* Detect small objects to guess image orientation */
    69     tmp3 = filter_median(tmp2);
    70     tmp4 = filter_equalize(tmp3, 200);
     67    filter_median(tmp);
     68    filter_equalize(tmp, 200);
    7169
    7270    /* Invert rotation and find glyphs */
    73     tmp5 = rotate(tmp2);
    74     tmp6 = filter_median(tmp5);
     71    rotate(tmp);
     72    filter_median(tmp);
    7573
    7674    /* Clean up our mess */
    77     image_free(tmp1);
    78     image_free(tmp2);
    79     image_free(tmp3);
    80     image_free(tmp4);
    81     image_free(tmp5);
    82     image_free(tmp6);
    83     image_free(tmp7);
     75    image_free(tmp);
    8476
    8577    /* aaaaaaa means decoding failed */
     
    9284/* The following functions are local */
    9385
    94 static struct image *fill_white_holes(struct image *img)
     86static void fill_white_holes(struct image *img)
    9587{
    96     struct image *dst;
     88    struct image *tmp;
    9789    int x, y, i;
    9890    int r, g, b;
    9991
    100     dst = image_new(img->width, img->height);
     92    tmp = image_new(img->width, img->height);
    10193
    10294    for(y = 0; y < img->height; y++)
     
    10496        {
    10597            getpixel(img, x, y, &r, &g, &b);
    106             setpixel(dst, x, y, r, g, b);
     98            setpixel(tmp, x, y, r, g, b);
    10799        }
    108100
     
    124116            if(count > 600)
    125117                continue;
    126             setpixel(dst, x, y, count / 5, count / 5, count / 5);
     118            setpixel(tmp, x, y, count / 5, count / 5, count / 5);
    127119        }
    128120
    129     return dst;
     121    image_swap(tmp, img);
     122    image_free(tmp);
    130123}
    131124
Note: See TracChangeset for help on using the changeset viewer.