There won’t be any Kivy crash course videos for the next couple of weeks, as I won’t have the time or tools to make them. I haven’t stopped making them though, they’ll resume afterwards.
No Kivy crash course videos for a few weeks
There won’t be any Kivy crash course videos for the next couple of weeks, as I won’t have the time or tools to make them. I haven’t stopped making them though, they’ll resume afterwards.
No Kivy crash course videos for a few weeks
There won’t be any Kivy crash course videos for the next couple of weeks, as I won’t have the time or tools to make them. I haven’t stopped making them though, they’ll resume afterwards.
Using tex_coords in kivy for fun and profit
Your gpu is an awesome thing, it can do all kind of calculations, very fast. For example, instead of telling it exactly how you want each pixels to be, you can throw textures and vertices at it, and have it correctly deduce how this things will have to look.
To do this, though, you must tell it what part of the texture will be stuck to
each vertice. This is usually denoted using texture coordinates.
Texture coordinates, like usual coordinates, indicate the place of something.
Instead of noting them x and y, they are often called u and v, which
allows to clearly note what parts of an equation relate to each.
While kivy offers you high level canvas instructions, it gives you a pretty good access to lower level features, and you can actually manipulate the texture coordinates of your Rectangle instructions. This allow for cheap zooming, repeat-scrolling, and other image manipulations, since your gpu is doing all the actual work.
tex_coords = u, v, u + w, v, u + w, v + h, u, v + h
which is better understood as:
tex_coords = [
u, v,
u + w, v,
u + w, v + h,
u, v + h
]
considering a default tex_coords value, where u and v = 0, and w and h = 1 (all values are relatives, so usually between 0 and 1).
u, v + h-------u + w, v + h
| |
u, v-----------u + w, v
which means the 4 angles of your texture, will be on the 4 angles of your rectangle, how dull!
One way to play with different values, is to create a little app showing you the effect of deformations.
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.widget import Widget
from kivy.properties import ObjectProperty, ListProperty
from kivy.core.image import Image as CoreImage
kv = '''
#:import chain itertools.chain
RootWidget:
canvas:
Color:
rgba: 1, 1, 1, 1
Rectangle:
pos: root.pos
size: root.size
texture: app.texture
# here is our usage of the calculated texture coordinates
# we devide by 100 because we took the input with a 100x100
# rectangle as default value
tex_coords: [x / 100. for x in chain(*root.points)]
PushMatrix
# translate the rectangle to make it easier to play with
Translate:
xy: root.width / 2, root.height / 2
Color:
rgba: 1, 0, 0, .5
Line:
points: chain(*root.points + root.points[:1])
width: 2
PopMatrix
'''
def dist(point, pos):
return ((point[0] - pos[0]) ** 2 + (point[1] - pos[1]) ** 2)
# ** .5 # who cares about square root here? it doesn't change the order
class RootWidget(Widget):
# the default values, a 100x100 square, displayed around the middle of the screen
points = ListProperty([[0, 0], [100, 0], [100, 100], [0, 100]])
def on_touch_down(self, touch, *args):
# compensate the translation done in canvas
pos = touch.pos[0] - self.width / 2, touch.pos[1] - self.height / 2
touch.ud['point'] = min(
range(4), key=lambda x: dist(self.points[x], pos))
def on_touch_move(self, touch, *args):
# compensate the translation done in canvas
pos = touch.pos[0] - self.width / 2, touch.pos[1] - self.height / 2
# update the point
self.points[touch.ud['point']] = pos
class TexCoordsApp(App):
texture = ObjectProperty(None)
def build(self):
self.root = Builder.load_string(kv)
self.texture = CoreImage.load(
'GrassGreenTexture0002.jpg').texture
self.texture.wrap = 'repeat'
return self.root
if __name__ == '__main__':
TexCoordsApp().run()
The texture have been scrapped on the web and is not very interesting, but you can find it here.
Of course, this is much more a learning device (helful because these transformation are not quite straighforward for our brains) than a practical application, but a lot more can be done.
Here is, for example, a little infinite scroll app uting this concept.
edit: Ben Rousch kindly created apks out of the two examples, if you want to try them on android: TexCoordsExample ScrollExample
Using tex_coords in kivy for fun and profit
Your gpu is an awesome thing, it can do all kind of calculations, very fast. For example, instead of telling it exactly how you want each pixels to be, you can throw textures and vertices at it, and have it correctly deduce how this things will have to look.
To do this, though, you must tell it what part of the texture will be stuck to
each vertice. This is usually denoted using texture coordinates.
Texture coordinates, like usual coordinates, indicate the place of something.
Instead of noting them x and y, they are often called u and v, which
allows to clearly note what parts of an equation relate to each.
While kivy offers you high level canvas instructions, it gives you a pretty good access to lower level features, and you can actually manipulate the texture coordinates of your Rectangle instructions. This allow for cheap zooming, repeat-scrolling, and other image manipulations, since your gpu is doing all the actual work.
tex_coords = u, v, u + w, v, u + w, v + h, u, v + h
which is better understood as:
tex_coords = [
u, v,
u + w, v,
u + w, v + h,
u, v + h
]
considering a default tex_coords value, where u and v = 0, and w and h = 1 (all values are relatives, so usually between 0 and 1).
u, v + h-------u + w, v + h
| |
u, v-----------u + w, v
which means the 4 angles of your texture, will be on the 4 angles of your rectangle, how dull!
One way to play with different values, is to create a little app showing you the effect of deformations.
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.widget import Widget
from kivy.properties import ObjectProperty, ListProperty
from kivy.core.image import Image as CoreImage
kv = '''
#:import chain itertools.chain
RootWidget:
canvas:
Color:
rgba: 1, 1, 1, 1
Rectangle:
pos: root.pos
size: root.size
texture: app.texture
# here is our usage of the calculated texture coordinates
# we devide by 100 because we took the input with a 100x100
# rectangle as default value
tex_coords: [x / 100. for x in chain(*root.points)]
PushMatrix
# translate the rectangle to make it easier to play with
Translate:
xy: root.width / 2, root.height / 2
Color:
rgba: 1, 0, 0, .5
Line:
points: chain(*root.points + root.points[:1])
width: 2
PopMatrix
'''
def dist(point, pos):
return ((point[0] - pos[0]) ** 2 + (point[1] - pos[1]) ** 2)
# ** .5 # who cares about square root here? it doesn't change the order
class RootWidget(Widget):
# the default values, a 100x100 square, displayed around the middle of the screen
points = ListProperty([[0, 0], [100, 0], [100, 100], [0, 100]])
def on_touch_down(self, touch, *args):
# compensate the translation done in canvas
pos = touch.pos[0] - self.width / 2, touch.pos[1] - self.height / 2
touch.ud['point'] = min(
range(4), key=lambda x: dist(self.points[x], pos))
def on_touch_move(self, touch, *args):
# compensate the translation done in canvas
pos = touch.pos[0] - self.width / 2, touch.pos[1] - self.height / 2
# update the point
self.points[touch.ud['point']] = pos
class TexCoordsApp(App):
texture = ObjectProperty(None)
def build(self):
self.root = Builder.load_string(kv)
self.texture = CoreImage.load(
'GrassGreenTexture0002.jpg').texture
self.texture.wrap = 'repeat'
return self.root
if __name__ == '__main__':
TexCoordsApp().run()
The texture have been scrapped on the web and is not very interesting, but you can find it here.
Of course, this is much more a learning device (helful because these transformation are not quite straighforward for our brains) than a practical application, but a lot more can be done.
Here is, for example, a little infinite scroll app uting this concept.
edit: Ben Rousch kindly created apks out of the two examples, if you want to try them on android: TexCoordsExample ScrollExample
Magnet: a widget to easily make your interface more lively
Kivy has a very nice Animation class, that allows you to move move widgets
around (or other things), by updating any numeric property to a target value,
just by setting a time and a transition function. Still, when you are building
a complex interface, it can still be a bit cumbersome to manually trigger
animations for all the elements, and to keep track of them.
After being frustrated about this issue for some time, i tried my luck some time ago, at doing a nicer, “90% use cases” interface, and the Magnet garden widget was born.
Its usage is simple, you simply use it to wrap your target widget, and give it rules about how to transition when the magnet is moved. As the magnet is moved or resized by the usual kivy logic, instead of making the wrapped widget immediately follow such constraints, it’ll create and keep track of animations to achieve a smooth transition to the new values for you.
As any garden “flower”, to install it, you need to install and use the garden project.
python setup.py install
(either in a virtualenv or system-wide)
then do:
garden install magnet
you can now import it a kivy application:
from kivy.garden.magnet import Magnet
Magnet: a widget to easily make your interface more lively
Kivy has a very nice Animation class, that allows you to move move widgets
around (or other things), by updating any numeric property to a target value,
just by setting a time and a transition function. Still, when you are building
a complex interface, it can still be a bit cumbersome to manually trigger
animations for all the elements, and to keep track of them.
After being frustrated about this issue for some time, i tried my luck some time ago, at doing a nicer, “90% use cases” interface, and the Magnet garden widget was born.
Its usage is simple, you simply use it to wrap your target widget, and give it rules about how to transition when the magnet is moved. As the magnet is moved or resized by the usual kivy logic, instead of making the wrapped widget immediately follow such constraints, it’ll create and keep track of animations to achieve a smooth transition to the new values for you.
As any garden “flower”, to install it, you need to install and use the garden project.
python setup.py install
(either in a virtualenv or system-wide)
then do:
garden install magnet
you can now import it a kivy application:
from kivy.garden.magnet import Magnet