gimpVbrBrush.py

#!/usr/bin/env
# -*- coding:utf-8 -*-
"""
Pure python implementation of the gimp vbr brush format
"""
import typing
from enum import Enum
import PIL.Image


BRUSH_SHAPES=Enum('BRUSH_SHAPES',start=0,names=(
    "circle","square","diamond"
    ))

class GimpVbrBrush:
    """
    Pure python implementation of the gimp vbr brush format

    See:
        https://gitlab.gnome.org/GNOME/gimp/blob/master/devel-docs/vbr.txt

    Format:
        name:GimpVbrBrush
        description:Gimp brush
        guid:{45129576-6728-4967-8888-6b9082862ca6}
        parentNames:Image
        #mimeTypes:application/jpeg
        filenamePatterns:*.vbr
    """

    MAGIC_NUMBER:typing.Tuple[int,str]=(0,'GIMP-VBR')

    def __init__(self,
        filename:typing.Union[None,str,typing.BinaryIO]=None
        )->None:
        """ """
        self.version:float=1.0
        self.name:str=''
        self.spacing:float=0
        self.radius:float=50
        self.hardness:float=1
        self.aspectRatio:float=1
        self.angle:float=0
        self.brushShape:typing.Optional[BRUSH_SHAPES]=None
        self.spikes:typing.Optional[float]=None
        self.filename:typing.Optional[str]=None
        if filename is not None:
            self.load(filename)

    def load(self,filename:typing.Union[str,typing.BinaryIO])->None:
        """
        load a gimp file

        :param filename:can be a file name or a file-like object
        """
        data:bytes
        if isinstance(filename,str):
            self.filename=filename
            f=open(filename,'rb')
            data=f.read()
            f.close()
        else:
            self.filename=filename.name
            data=filename.read()
        self._decode_(data)

    @property
    def image(self)->PIL.Image.Image:
        """
        this parametric brush converted to a useable PIL image
        """
        raise NotImplementedError() # TODO:

    def _decode_(self,
        data:typing.Union[str,bytes,typing.List[str]],
        index:int=0
        )->None:
        """
        decode a byte buffer

        :param data:data buffer to decode
        :param index:index within the buffer to start at
        """
        if isinstance(data,bytes):
            data=data.decode('utf-8')
        if isinstance(data,str):
            data=[s.strip() for s in data.split('\n')]
        if index!=0:
            data=data[index:]
        if data[0]!="GIMP-VBR":
            raise Exception('File format error.  Magic value mismatch.')
        self.version=float(data[1])
        if self.version==1.0:
            self.name=data[2] # max len 255 bytes
            self.spacing=float(data[3])
            self.radius=float(data[4])
            self.hardness=float(data[5])
            self.aspectRatio=float(data[6])
            self.angle=float(data[7])
        elif self.version==1.5:
            self.name=data[2] # max len 255 bytes
            self.brushShape=BRUSH_SHAPES(data[3])
            self.spacing=float(data[4])
            self.radius=float(data[5])
            self.spikes=float(data[6])
            self.hardness=float(data[7])
            self.aspectRatio=float(data[8])
            self.angle=float(data[9])
        else:
            raise Exception('Unknown version '+str(self.version))

    def toBytes(self)->bytes:
        """
        encode to a raw data stream
        """
        data=[]
        data.append("GIMP-VBR")
        data.append(str(self.version))
        if self.version==1.0:
            data.append(str(self.name))
            data.append(str(self.spacing))
            data.append(str(self.radius))
            data.append(str(self.hardness))
            data.append(str(self.aspectRatio))
            data.append(str(self.angle))
        elif self.version==1.5:
            data.append(str(self.name))
            data.append(str(self.brushShape))
            data.append(str(self.spacing))
            data.append(str(self.radius))
            data.append(str(self.spikes))
            data.append(str(self.hardness))
            data.append(str(self.aspectRatio))
            data.append(str(self.angle))
        return ('\n'.join(data)+'\n').encode('utf-8')

    def save(self,
        toFilename:typing.Union[None,str,typing.BinaryIO]=None,
        toExtension:typing.Optional[str]=None
        )->None:
        """
        save this gimp image to a file
        """
        asImage=False
        f=None
        if toFilename is None:
            if self.filename is None:
                self.filename='Untitled.vbr'
            toFilename=self.filename
        elif isinstance(toFilename,str):
            self.filename=toFilename
        else:
            f=toFilename
            toFilename=toFilename.name
            self.filename=toFilename
        if toExtension is None:
            if toFilename is not None:
                ext=toFilename.rsplit('.',1)
                if len(ext)>1:
                    toExtension=ext[-1]
                else:
                    toExtension=None
        if toExtension is not None and toExtension!='vbr':
            if toExtension=='gpb':
                # TODO: convert between brush types!
                raise NotImplementedError()
            asImage=True
        if asImage:
            self.image.save(toFilename)
        else:
            if f is None:
                f=open(toFilename,'wb')
            f.write(self.toBytes())

    def __repr__(self,indent:str='')->str:
        """
        Get a textual representation of this object
        """
        ret=[]
        if self.filename is not None:
            ret.append('Filename:'+self.filename)
        ret.append('Name:'+str(self.name))
        ret.append('Version:'+str(self.version))
        ret.append('Spacing:'+str(self.spacing))
        ret.append('Radius:'+str(self.radius))
        ret.append('Hardness:'+str(self.hardness))
        ret.append('Aspect ratio:'+str(self.aspectRatio))
        ret.append('Angle:'+str(self.angle))
        ret.append('Brush Shape:'+str(self.brushShape))
        ret.append('Spikes:'+str(self.spikes))
        return ('\n'+indent).join(ret)

    def __eq__(self,other:typing.Any)->bool:
        """
        perform a comparison
        """
        if not isinstance(other,GimpVbrBrush):
            return False
        if other.name!=self.name:
            return False
        if other.version!=self.version:
            return False
        if other.spacing!=self.spacing:
            return False
        if other.radius!=self.radius:
            return False
        if other.hardness!=self.hardness:
            return False
        if other.aspectRatio!=self.aspectRatio:
            return False
        if other.angle!=self.angle:
            return False
        if other.brushShape!=self.brushShape:
            return False
        if other.spikes!=self.spikes:
            return False
        return True


def cmdline(args:typing.Iterable[str])->int:
    """
    Run the command line

    :param args:command line arguments (WITHOUT the filename)
    """
    printhelp=False
    if not args:
        printhelp=True
    else:
        g=None
        for arg in args:
            if arg.startswith('-'):
                kv=[a.strip() for a in arg.split('=',1)]
                if kv[0] in ('-h','--help'):
                    printhelp=True
                elif kv[0]=='--dump':
                    print(g)
                else:
                    print(f'ERR: unknown argument "{arg}"')
            else:
                g=GimpVbrBrush(arg)
    if printhelp:
        print('Usage:')
        print('  gimpVbrBrush.py file.xcf [options]')
        print('Options:')
        print('   -h, --help ............ this help screen')
        print('   --dump ................ dump info about this file')
        print('   --register ............ register this extension')
        return -1
    return 0


if __name__=='__main__':
    import sys
    cmdline(sys.argv[1:])