Kivy-examples 2.3.1.dev0__py3-none-any.whl

kivy/tools/texturecompress.py

@@ -0,0 +1,233 @@
+'''
+Texture compression tool
+========================
+
+This tool is designed to compress images into:
+
+- PVRTC (PowerVR Texture Compression), mostly iOS devices
+- ETC1 (Ericson compression), working on all GLES2/Android devices
+
+Usage
+-----
+
+In order to compress a texture::
+
+    texturecompress.py [--dir <directory>] <format> <image.png>
+
+This will create a `image.tex` file with a json header that contains all the
+image information and the compressed data.
+
+TODO
+----
+
+Support more format, such as:
+
+- S3TC (already supported in Kivy)
+- DXT1 (already supported in Kivy)
+'''
+
+import json
+from struct import pack
+from pprint import pprint
+from subprocess import Popen
+from PIL import Image
+from argparse import ArgumentParser
+from sys import exit
+from os.path import join, exists, dirname, basename
+from os import environ, unlink
+
+
+class Tool(object):
+    def __init__(self, options):
+        super(Tool, self).__init__()
+        self.options = options
+        self.source_fn = options.image
+        self.dest_dir = options.dir or dirname(options.image)
+
+    @property
+    def tex_fn(self):
+        fn = basename(self.source_fn).rsplit('.', 1)[0] + '.tex'
+        return join(self.dest_dir, fn)
+
+    def compress(self):
+        pass
+
+    def nearest_pow2(self, v):
+        # Credits: Sean Anderson
+        v -= 1
+        v |= v >> 1
+        v |= v >> 2
+        v |= v >> 4
+        v |= v >> 8
+        v |= v >> 16
+        return v + 1
+
+    def runcmd(self, cmd):
+        print('Run: {}'.format(' '.join(cmd)))
+        Popen(cmd).communicate()
+
+    def write_tex(self, data, fmt, image_size, texture_size, mipmap=False,
+            formatinfo=None):
+        infos = {
+            'datalen': len(data),
+            'image_size': image_size,
+            'texture_size': texture_size,
+            'mipmap': mipmap,
+            'format': fmt}
+        if formatinfo:
+            infos['formatinfo'] = formatinfo
+        header = json.dumps(infos, indent=0, separators=(',', ':'))
+        header = header.replace('\n', '')
+        with open(self.tex_fn, 'wb') as fd:
+            fd.write('KTEX')
+            fd.write(pack('I', len(header)))
+            fd.write(header)
+            fd.write(data)
+
+        print('Done! Compressed texture written at {}'.format(self.tex_fn))
+        pprint(infos)
+
+    @staticmethod
+    def run():
+        parser = ArgumentParser(
+                description='Convert images to compressed texture')
+        parser.add_argument('--mipmap', type=bool, default=False,
+                help='Auto generate mipmaps')
+        parser.add_argument('--dir', type=str, default=None,
+                help='Output directory to generate the compressed texture')
+        parser.add_argument('format', type=str, choices=['pvrtc', 'etc1'],
+                help='Format of the final texture')
+        parser.add_argument('image', type=str,
+                help='Image filename')
+        args = parser.parse_args()
+
+        if args.format == 'pvrtc':
+            PvrtcTool(args).compress()
+        elif args.format == 'etc1':
+            Etc1Tool(args).compress()
+        else:
+            print('Unknown compression format')
+            exit(1)
+
+
+class Etc1Tool(Tool):
+    def __init__(self, options):
+        super(Etc1Tool, self).__init__(options)
+        self.etc1tool = None
+        self.locate_etc1tool()
+
+    def locate_etc1tool(self):
+        search_directories = [environ.get('ANDROIDSDK', '/')]
+        search_directories += environ.get('PATH', '').split(':')
+        for directory in search_directories:
+            fn = join(directory, 'etc1tool')
+            if not exists(fn):
+                fn = join(directory, 'tools', 'etc1tool')
+                if not exists(fn):
+                    continue
+            print('Found texturetool at {}'.format(directory))
+            self.etc1tool = fn
+            return
+
+        if self.etc1tool is None:
+            print('Error: Unable to locate "etc1tool".\n'
+                  'Make sure that "etc1tool" is available in your PATH.\n'
+                  'Or export the path of your Android SDK to ANDROIDSDK')
+            exit(1)
+
+    def compress(self):
+        # 1. open the source image, and get the dimensions
+        image = Image.open(self.source_fn)
+        w, h = image.size
+        print('Image size is {}x{}'.format(*image.size))
+
+        # 2. search the nearest 2^
+        w2 = self.nearest_pow2(w)
+        h2 = self.nearest_pow2(h)
+        print('Nearest power-of-2 size is {}x{}'.format(w2, h2))
+
+        # 3. invoke etc1tool
+        raw_tex_fn = self.tex_fn + '.raw'
+        cmd = [self.etc1tool, self.source_fn, '--encodeNoHeader', '-o',
+               raw_tex_fn]
+        try:
+            self.runcmd(cmd)
+            with open(raw_tex_fn, 'rb') as fd:
+                data = fd.read()
+        finally:
+            if exists(raw_tex_fn):
+                unlink(raw_tex_fn)
+
+        # 5. write texture info
+        self.write_tex(data, 'etc1_rgb8', (w, h), (w2, h2),
+                        self.options.mipmap)
+
+
+class PvrtcTool(Tool):
+    def __init__(self, options):
+        super(PvrtcTool, self).__init__(options)
+        self.texturetool = None
+        self.locate_texturetool()
+
+    def locate_texturetool(self):
+        search_directories = [
+            ('/Applications/Xcode.app/Contents/Developer/Platforms/'
+             'iPhoneOS.platform/Developer/usr/bin/'),
+            '/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/']
+        search_directories += environ.get('PATH', '').split(':')
+
+        for directory in search_directories:
+            fn = join(directory, 'texturetool')
+            if not exists(fn):
+                continue
+            print('Found texturetool at {}'.format(directory))
+            self.texturetool = fn
+            return
+
+        print('Error: Unable to locate "texturetool".\n'
+              'Please install the iPhone SDK, or the PowerVR SDK.\n'
+              'Then make sure that "texturetool" is available in your PATH.')
+        exit(1)
+
+    def compress(self):
+        # 1. open the source image, and get the dimensions
+        image = Image.open(self.source_fn)
+        w, h = image.size
+        print('Image size is {}x{}'.format(*image.size))
+
+        # 2. search the nearest 2^
+        w2 = self.nearest_pow2(w)
+        h2 = self.nearest_pow2(h)
+        print('Nearest power-of-2 size is {}x{}'.format(w2, h2))
+
+        # 3. for PVR, the image MUST be a square. use the bigger size then
+        s2 = max(w2, h2)
+        print('PVR need a square image, the texture will be {0}x{0}'
+                .format(s2))
+
+        ext = self.source_fn.rsplit('.', 1)[-1]
+        tmpfile = '/tmp/ktexturecompress.{}'.format(ext)
+        image = image.resize((s2, s2))
+        image.save(tmpfile)
+
+        # 4. invoke texture tool
+        raw_tex_fn = self.tex_fn + '.raw'
+        cmd = [self.texturetool]
+        if self.options.mipmap:
+            cmd += ['-m']
+        cmd += ['-e', 'PVRTC', '-o', raw_tex_fn, '-f', 'RAW', tmpfile]
+        try:
+            self.runcmd(cmd)
+            with open(raw_tex_fn, 'rb') as fd:
+                data = fd.read()
+        finally:
+            if exists(raw_tex_fn):
+                unlink(raw_tex_fn)
+
+        # 5. write texture info
+        self.write_tex(data, 'pvrtc_rgba4', (w, h), (s2, s2),
+                       self.options.mipmap)
+
+
+if __name__ == '__main__':
+    Tool.run()

kivy/uix/__init__.py

@@ -0,0 +1,56 @@
+'''
+Widgets
+=======
+
+Widgets are elements of a graphical user interface that form part of the
+`User Experience <http://en.wikipedia.org/wiki/User_experience>`_.
+The `kivy.uix` module contains classes for creating and managing Widgets.
+Please refer to the :doc:`api-kivy.uix.widget` documentation for further
+information.
+
+Kivy widgets can be categorized as follows:
+
+- **UX widgets**: Classical user interface widgets, ready to be assembled to
+  create more complex widgets.
+
+    :doc:`api-kivy.uix.label`, :doc:`api-kivy.uix.button`,
+    :doc:`api-kivy.uix.checkbox`,
+    :doc:`api-kivy.uix.image`, :doc:`api-kivy.uix.slider`,
+    :doc:`api-kivy.uix.progressbar`, :doc:`api-kivy.uix.textinput`,
+    :doc:`api-kivy.uix.togglebutton`, :doc:`api-kivy.uix.switch`,
+    :doc:`api-kivy.uix.video`
+
+- **Layouts**: A layout widget does no rendering but just acts as a trigger
+  that arranges its children in a specific way. Read more on
+  :doc:`Layouts here <api-kivy.uix.layout>`.
+
+    :doc:`api-kivy.uix.anchorlayout`, :doc:`api-kivy.uix.boxlayout`,
+    :doc:`api-kivy.uix.floatlayout`,
+    :doc:`api-kivy.uix.gridlayout`, :doc:`api-kivy.uix.pagelayout`,
+    :doc:`api-kivy.uix.relativelayout`, :doc:`api-kivy.uix.scatterlayout`,
+    :doc:`api-kivy.uix.stacklayout`
+
+- **Complex UX widgets**: Non-atomic widgets that are the result of
+  combining multiple classic widgets.
+  We call them complex because their assembly and usage are not as
+  generic as the classical widgets.
+
+    :doc:`api-kivy.uix.bubble`, :doc:`api-kivy.uix.dropdown`,
+    :doc:`api-kivy.uix.filechooser`, :doc:`api-kivy.uix.popup`,
+    :doc:`api-kivy.uix.spinner`,
+    :doc:`api-kivy.uix.recycleview`,
+    :doc:`api-kivy.uix.tabbedpanel`, :doc:`api-kivy.uix.videoplayer`,
+    :doc:`api-kivy.uix.vkeyboard`,
+
+- **Behaviors widgets**: These widgets do no rendering but act on the
+  graphics instructions or interaction (touch) behavior of their children.
+
+    :doc:`api-kivy.uix.scatter`, :doc:`api-kivy.uix.stencilview`
+
+- **Screen manager**: Manages screens and transitions when switching
+  from one to another.
+
+    :doc:`api-kivy.uix.screenmanager`
+
+----
+'''