Changeset 4705


Ignore:
Timestamp:
Nov 7, 2010 6:08:24 PM (4 years ago)
Author:
alxf
Message:
  • Bind dither functions
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/python/caca/dither.py

    r4398 r4705  
    1818
    1919from caca import _lib
     20from caca.canvas import _Canvas
    2021
    2122class _Dither(object):
     
    4142        """ Free a libcaca dither.
    4243        """
    43         _lib.caca_free_font.argtypes = [_Dither]
    44         _lib.caca_free_font.restype = ctypes.c_int
    45 
    46         return _lib.caca_free_font(self)
     44        _lib.caca_free_dither.argtypes = [_Dither]
     45        _lib.caca_free_dither.restype = ctypes.c_int
     46
     47        return _lib.caca_free_dither(self)
    4748
    4849class Dither(_Dither):
     
    6263            amask   -- bitmask for alpha values
    6364        """
    64         pass
    65 
     65        _lib.caca_create_dither.argtypes = [
     66            ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int,
     67            ctypes.c_uint, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint,
     68        ]
     69
     70        self._dither = _lib.caca_create_dither(bpp, width, height, pitch,
     71                                               bmask, gmask, rmask, amask)
     72
     73        if self._dither == 0:
     74            raise DitherError, "Failed to create dither object"
     75
     76    def set_palette(self, red, green, blue, alpha):
     77        """ Set the palette of an 8 bits per pixel bitmap. Values should be
     78        between 0 and 4095 (0xfff).
     79
     80            red     -- array of 256 red values
     81            green   -- array of 256 green values
     82            blue    -- array of 256 blue values
     83            alpha   -- array of 256 alpha values
     84        """
     85        raise DitherError, "Not implemented"
     86
     87    def set_brightness(self, brightness):
     88        """ Set the brightness of the dither object.
     89
     90            brightness  -- brightness value
     91        """
     92        if isinstance(brightness, int):
     93            brightness = float(brightness)
     94
     95        _lib.caca_set_dither_brightness.argtypes = [_Dither, ctypes.c_float]
     96        _lib.caca_set_dither_brightness.restype  = ctypes.c_int
     97
     98        return _lib.caca_set_dither_brightness(self, brightness)
     99
     100    def get_brightness(self):
     101        """ Get the brightness of the dither object.
     102        """
     103        _lib.caca_get_dither_brightness.argtypes = [_Dither]
     104        _lib.caca_get_dither_brightness.restype  = ctypes.c_float
     105
     106        return _lib.caca_get_dither_brightness(self)
     107
     108    def set_gamma(self, gamma):
     109        """ Set the gamma of the dither object. A negative value causes colour
     110        inversion.
     111
     112            gamma -- gamma value
     113        """
     114        if isinstance(gamma, int):
     115            gamma = float(gamma)
     116
     117        _lib.caca_set_dither_gamma.argtypes = [_Dither, ctypes.c_float]
     118        _lib.caca_set_dither_gamma.restype  = ctypes.c_int
     119
     120        return _lib.caca_set_dither_gamma(self, gamma)
     121
     122    def get_gamma(self):
     123        """ Get the gamma of the dither object.
     124        """
     125        _lib.caca_get_dither_gamma.argtypes = [_Dither]
     126        _lib.caca_get_dither_gamma.restype  = ctypes.c_float
     127
     128        return _lib.caca_get_dither_gamma(self)
     129
     130    def set_contrast(self, contrast):
     131        """ Set the contrast of dither.
     132
     133            contrast -- contrast value
     134        """
     135        if isinstance(contrast, int):
     136            contrast = float(contrast)
     137
     138        _lib.caca_set_dither_contrast.argtypes = [_Dither, ctypes.c_float]
     139        _lib.caca_set_dither_contrast.restype  = ctypes.c_int
     140
     141        return _lib.caca_set_dither_contrast(self, contrast)
     142
     143    def get_contrast(self):
     144        """ Get the contrast of the dither object.
     145        """
     146        _lib.caca_get_dither_contrast.argtypes = [_Dither]
     147        _lib.caca_get_dither_contrast.restype  = ctypes.c_float
     148
     149        return _lib.caca_get_dither_contrast(self)
     150
     151    def set_antialias(self, value):
     152        """ Set dither antialiasing.
     153
     154            value -- A string describing the antialiasing method that will
     155                     be used for the dithering.
     156
     157                     + "none": no antialiasing
     158                     + "prefilter" or "default": simple prefilter antialiasing. (default)
     159        """
     160        _lib.caca_set_dither_antialias.argtypes = [_Dither, ctypes.c_char_p]
     161        _lib.caca_set_dither_antialias.restype  = ctypes.c_int
     162
     163        return _lib.caca_set_dither_antialias(self, value)
     164
     165    def get_antialias(self):
     166        """ Return the dither's current antialiasing method.
     167        """
     168        _lib.caca_get_dither_antialias.argtypes = [_Dither]
     169        _lib.caca_get_dither_antialias.restype  = ctypes.c_char_p
     170
     171        return _lib.caca_get_dither_antialias(self)
     172
     173    def get_antialias_list(self):
     174        """ Get available antialiasing methods.
     175        """
     176        lst = []
     177
     178        _lib.caca_get_dither_antialias_list.argtypes = [_Dither]
     179        _lib.caca_get_dither_antialias_list.restype  = ctypes.POINTER(ctypes.c_char_p)
     180
     181        for item in _lib.caca_get_dither_antialias_list(self):
     182            if item is not None and item != "":
     183                lst.append(item)
     184            else:
     185                #memory occurs otherwise
     186                break
     187
     188        return lst
     189
     190    def set_color(self, value):
     191        """ Choose colours used for dithering.
     192
     193            value -- A string describing the colour set that will be
     194                     used for the dithering.
     195
     196                     + "mono": use light gray on a black background
     197                     + "gray": use white and two shades of gray on a black background
     198                     + "8": use the 8 ANSI colours on a black background
     199                     + "16": use the 16 ANSI colours on a black background
     200                     + "fullgray": use black, white and two shades of gray
     201                       for both the characters and the background
     202                     + "full8": use the 8 ANSI colours for both the characters and
     203                       the background
     204                     + "full16" or "default": use the 16 ANSI colours for both the
     205                       characters and the background (default)
     206        """
     207        _lib.caca_set_dither_color.argtypes = [_Dither, ctypes.c_char_p]
     208        _lib.caca_set_dither_color.restype  = ctypes.c_int
     209
     210        return _lib.caca_set_dither_color(self, value)
     211
     212    def get_color(self):
     213        """ Get current colour mode.
     214        """
     215        _lib.caca_get_dither_color.argtypes = [_Dither]
     216        _lib.caca_get_dither_color.restype  = ctypes.c_char_p
     217
     218        return _lib.caca_get_dither_color(self)
     219
     220    def get_color_list(self):
     221        """ Get available colour modes.
     222        """
     223        lst = []
     224
     225        _lib.caca_get_dither_color_list.argtypes = [_Dither]
     226        _lib.caca_get_dither_color_list.restype  = ctypes.POINTER(ctypes.c_char_p)
     227
     228        for item in _lib.caca_get_dither_color_list(self):
     229            if item is not None and item != "":
     230                lst.append(item)
     231            else:
     232                #memory occurs otherwise
     233                break
     234
     235        return lst
     236
     237    def set_charset(self, value):
     238        """ Choose characters used for dithering.
     239
     240            value -- A string describing the characters that need to be
     241                     used for the dithering.
     242
     243                     + "ascii" or "default": use only ASCII characters (default).
     244                     + "shades": use Unicode characters "U+2591 LIGHT SHADE",
     245                       "U+2592 MEDIUM SHADE" and "U+2593 DARK SHADE". These characters are
     246                       also present in the CP437 codepage available on DOS and VGA.
     247                     + "blocks": use Unicode quarter-cell block combinations.
     248                       These characters are only found in the Unicode set.
     249        """
     250        _lib.caca_set_dither_charset.argtypes = [_Dither, ctypes.c_char_p]
     251        _lib.caca_set_dither_charset.restype  = ctypes.c_int
     252
     253        return _lib.caca_set_dither_charset(self, value)
     254
     255    def get_charset(self):
     256        """ Get current character set.
     257        """
     258        _lib.caca_get_dither_charset.argtypes = [_Dither]
     259        _lib.caca_get_dither_charset.restype  = ctypes.c_char_p
     260
     261        return _lib.caca_get_dither_charset(self)
     262
     263    def get_charset_list(self):
     264        """ Get available dither character sets.
     265        """
     266        lst = []
     267
     268        _lib.caca_get_dither_color_list.argtypes = [_Dither]
     269        _lib.caca_get_dither_color_list.restype  = ctypes.POINTER(ctypes.c_char_p)
     270
     271        for item in _lib.caca_get_dither_color_list(self):
     272            if item is not None and item != "":
     273                lst.append(item)
     274            else:
     275                #memory occurs otherwise
     276                break
     277
     278        return lst
     279
     280    def set_algorithm(self, value):
     281        """ Set dithering algorithm.
     282
     283            value -- A string describing the algorithm that needs to be
     284                     used for the dithering.
     285
     286                     + "none": no dithering is used, the nearest matching colour is used.
     287                     + "ordered2": use a 2x2 Bayer matrix for dithering.
     288                     + "ordered4": use a 4x4 Bayer matrix for dithering.
     289                     + "ordered8": use a 8x8 Bayer matrix for dithering.
     290                     + "random": use random dithering.
     291                     + "fstein": use Floyd-Steinberg dithering (default).
     292        """
     293        _lib.caca_set_dither_algorithm.argtypes = [_Dither, ctypes.c_char_p]
     294        _lib.caca_set_dither_algorithm.restype  = ctypes.c_int
     295
     296        return _lib.caca_set_dither_algorithm(self, value)
     297
     298    def get_algorithm(self):
     299        """ Get dithering algorithms.
     300        """
     301        _lib.caca_get_dither_algorithm.argtypes = [_Dither]
     302        _lib.caca_get_dither_algorithm.restype  = ctypes.c_char_p
     303
     304        return _lib.caca_get_dither_algorithm(self)
     305
     306    def get_algorithm_list(self):
     307        """ Get dithering algorithms.
     308        """
     309        lst = []
     310
     311        _lib.caca_get_dither_color_list.argtypes = [_Dither]
     312        _lib.caca_get_dither_color_list.restype  = ctypes.POINTER(ctypes.c_char_p)
     313
     314        for item in _lib.caca_get_dither_color_list(self):
     315            if item is not None and item != "":
     316                lst.append(item)
     317            else:
     318                #memory occurs otherwise
     319                break
     320
     321        return lst
     322
     323    def bitmap(self, canvas, x, y, width, height, pixels):
     324        """ Dither a bitmap on the canvas.
     325
     326            canvas  -- a handle to libcaca canvas
     327            x       -- X coordinate of the upper-left corner of the drawing area
     328            y       -- Y coordinate of the upper-left corner of the drawing area
     329            width   -- width of the drawing area
     330            height  -- height of the drawing area
     331            pixels  -- bitmap's pixels
     332        """
     333        _lib.caca_dither_bitmap.argtypes = [
     334            _Canvas, ctypes.c_int, ctypes.c_int,
     335            ctypes.c_int, ctypes.c_int, _Dither,
     336            ctypes.c_char_p
     337        ]
     338        _lib.caca_dither_bitmap.restype  = ctypes.c_int
     339
     340        return _lib.caca_dither_bitmap(canvas, x, y, width, height, self, pixels)
     341
     342class DitherError(Exception):
     343    pass
     344
Note: See TracChangeset for help on using the changeset viewer.