Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

M. Cywiak, D. CywiakMulti-Platform Graphics Programming with Kivyhttps://doi.org/10.1007/978-1-4842-7113-1_5

5. Programming Three-Dimensional Polygons

Moisés Cywiak¹ and David Cywiak²

(1)

Leon, Guanajuato, Mexico

(2)

Queretaro, Mexico

In this chapter, we describe how to construct and rotate polygons by using the equations obtained in Chapter 4.

As an example, Figure 5-1 shows a screenshot of the program running on an Android cell phone.

../images/510726_1_En_5_Chapter/510726_1_En_5_Fig1_HTML.jpg — Figure 5-1
Cell phone screenshot with two polygons on the screen

Figure 5-1 shows the program running on an Android cell phone. Two polygons are placed on the screen. Button1 draws the polygons and Button2 clears the screen. The three buttons at the left—Button3, Button5, and Button7—rotate one of the two polygons in the counterclockwise direction, in the x − y, x − z, or y − z planes, respectively. Accordingly, Button4, Button6, and Button8 rotate the polygon in the clockwise direction. One of the polygons is selected each time that Button9 is pressed. The selected polygon number is indicated by a label.

5.1 Polygon Structure

Similar to the two-dimensional case, these three-dimensional polygons require a structure with the properties of the polygon. To describe the contents and use of the structures, we focus on the structure that corresponds to the cube polygon shown in Listing 5-1.

The first entry in the structure corresponds to the number of vertices +1, as in the two-dimensional case. Next, we list the vertices that correspond to the front face of the cube, referring to their corresponding offsets. Then we list the vertices of the back face. The last entries of the structure correspond to the color of the polygon and its center of rotation.

In this example, the center of rotation coincides with the (x,y,z) offsets of the polygon. The polygon structure is given in Listing 5-1. First, let’s define the dimensions of the cube as LX=60, LY=60, and LZ=60. Offsets from the origin for the (x,y,z) directions are defined as OffX=-70, OffY=-40, and OffZ=200, respectively.

#Offsets from the origin. OffZ is measured

#starting from the screen

OffX=-70; OffY=-40; OffZ=200;

#Dimensions of the cube

LX=60; LY=60; LZ=60;

Cube=[

5, #Number of vertexes +1

#Front face

[ LX+OffX, LY+OffY, LZ+OffZ], #Vertex 1

[ LX+OffX, -LY+OffY, LZ+OffZ], #Vertex 2

[-LX+OffX, -LY+OffY, LZ+OffZ], #Vertex 3

[-LX+OffX, LY+OffY, LZ+OffZ], #Vertex 4

[ LX+OffX, LY+OffY, LZ+OffZ], #Vertex 1

#Back face

[ LX+OffX, LY+OffY, -LZ+OffZ], #Vertex 1

[ LX+OffX, -LY+OffY, -LZ+OffZ], #Vertex 2

[-LX+OffX, -LY+OffY, -LZ+OffZ], #Vertex 3

[-LX+OffX, LY+OffY, -LZ+OffZ], #Vertex 4

[ LX+OffX, LY+OffY, -LZ+OffZ], #Vertex 1

#Red, green, blue color .

#Entries must be between 0 and 1. Place= 2*Num+1

[0,0,1],

#Center of rotation. Entry=2*Num+2

[OffX,OffY,OffZ]

];

Listing 5-1

Three-Dimensional Polygon Structure

5.2 Basic Functions

Now that the structure of the polygon has been constructed, we need a function to draw the polygon on the screen. This function is DrawEdges(P,B), as shown in Listing 5-2.

DrawEdges(P,B) receives two parameters. The first parameter points to the structure. The second parameter is a handle to the widgets defined in the kv file.

The edges of the polygon are drawn by calculating the position of each vertex on the screen using Equations (4.11) and (4.12) from Chapter 4. For convenience, they are repeated here:

${X}_p={X}_C+frac{D-{V}_Z}{D-{Z}_P-{V}_Z}left(x-{V}_X ight)+{V}_X$

(5.1)

${Y}_p={Y}_C+frac{D-{V}_Z}{D-{Z}_P-{V}_Z}left(y-{V}_Y ight)+{V}_Y$

(5.2)

The pseudocode for DrawEdges(P,B) is shown in Listing 5-2.

def DrawEdges(P, B):

Num=P[0]; # Reading number of face edges +1

r,g,b=P[2*Num+1]; # Reading colors

for n in range(1,Num): # Drawing front edges

Factor=(D-VZ)/(D-P[n][2]-VZ);

x1=XC+Factor*(P[n][0]-VX)+VX;

y1=YC+Factor*(P[n][1]-VY)+VY;

Factor=(D-VZ)/(D-P[n+1][2]-VZ);

x2=XC+Factor*(P[n+1][0]-VX)+VX;

y2=YC+Factor*(P[n+1][1]-VY)+VY;

Draw_line_from (x1,y1) to (x2,y2)

using (r,g,b) color.

for n in range(Num+1,2*Num): #Drawing back edges

Factor=(D-VZ)/(D-P[n][2]-VZ);

x1=XC+Factor*(P[n][0]-VX)+VX;

y1=YC+Factor*(P[n][1]-VY)+VY;

Factor=(D-VZ)/(D-P[n+1][2]-VZ);

x2=XC+Factor*(P[n+1][0]-VX)+VX;

y2=YC+Factor*(P[n+1][1]-VY)+VY;

Draw_line_from (x1,y1) to (x2,y2)

using (r,g,b) color.

#Drawing edges between back and front faces

for n in range(1,Num):

Factor=(D-VZ)/(D-P[n][2]-VZ);

x1=XC+Factor*(P[n][0]-VX)+VX;

y1=YC+Factor*(P[n][1]-VY)+VY;

Factor=(D-VZ)/(D-P[Num+n][2]-VZ);

x2=XC+Factor*(P[Num+n][0]-VX)+VX;

y2=YC+Factor*(P[Num+n][1]-VY)+VY;

Draw_line_from (x1,y1) to (x2,y2)

using (r,g,b) color.

Listing 5-2

The Function to Draw Polygon Edges

As you can see in Listing 5-2, the edges are drawn by calculating the coordinates of each vertex in the screen using Equations (5.1) and (5.2). In the first for loop, the edges of the front face are drawn. In the second for loop, the edges of the back face are drawn. Finally, in the last for loop, the edges going from the front to the back face vertices are drawn.

For illustrative purposes, we will only fill one face of the polygons. The FillPolygon(B,P) function , shown in Listing 5-3, receives two parameters. The P parameter gives access to the polygon structure, while the B parameter gives access to the screen widgets. Before we declare the function, we allocate a region of memory of 30 points of intersection with the scan line, as described in Chapter 3 for the two-dimensional case. We do this by using:

Intersect=np.zeros(30);

The corresponding pseudocode for FillPolygon(B,P) is shown in Listing 5-3.

def FillPolygon(P, B):

Num=P[0]; #Reading number of face edges +1

r,g,b=P[2*Num+1]; #Reading colors

#Calculating polygon YMin, Ymax

#for limiting number of line scans

Factor=(D-VZ)/(D-P[Num+1][2]-VZ);

YMin=YC+Factor*(P[Num+1][1]-VY)+VY;

YMax=YMin;

for n in range(Num+1,2*Num):

Factor=(D-VZ)/(D-P[n+1][2]-VZ);

if YMin>YC+Factor*(P[n+1][1]-VY)+VY:

YMin=YC+Factor*(P[n+1][1]-VY)+VY;

if YMax<YC+Factor*(P[n+1][1]-VY)+VY:

YMax=YC+Factor*(P[n+1][1]-VY)+VY;

#We have now (YMin, YMax). We now proceed

#filling lines between Ymin and Ymax

for y in np.arange (YMin, YMax, 2):

Counter=0;

#We search line cuts, segment by segment

for n in range(Num+1, 2*Num):

#We first order the two vertices of each

#segment such that Y1<Y2

Factor1=(D-VZ)/(D-P[n][2]-VZ);

YA=YC+Factor1*(P[n][1]-VY)+VY;

Factor2=(D-VZ)/(D-P[n+1][2]-VZ);

YB=YC+Factor2*(P[n+1][1]-VY)+VY;

if ( YA<YB ):

Y1=YA;

X1=XC+Factor1*(P[n][0]-VX)+VX;

Y2=YB;

X2=XC+Factor2*(P[n+1][0]-VX)+VX;

else:

Y1=YB;

X1=XC+Factor2*(P[n+1][0]-VX)+VX;

Y2=YA;

X2=XC+Factor1*(P[n][0]-VX)+VX;

if (Y1<=y and y<Y2):

if (Y2-Y1)!=0:

M=(X2-X1)/(Y2-Y1);

else:

#if Y1=Y2, the slope becomes

#infinite. Therefore,

#we assign to M a large value

M=1.0e8;

#We store the x value

Intersect[Counter]=(y-Y1)*M+X1;

#And we increment Counter as a

#new value has being stored

Counter=Counter+1;

#Our polygon is a closed figure. We ask If

#an even number of cuts have occurred

if(Counter>1 and Counter %2==0):

#Intersect1 stores ordered pairs of

#x values

Intersect1=np.sort(Intersect[0:Counter]);

#We proceed tracing horizontal lines

#between pairs of intersections

for n in range(0,Counter,2):

XIntersect1=int(Intersect1[n]);

XIntersect2=int(Intersect1[n+1]);

Y=int(y);

Draw line from (XIntersect1,Y) to (Xintersect2,Y)

using (r,g,b) color.

Listing 5-3

Pseudocode for the FillPolygon(B,P) Function

Note that FillPolygon(P,B) is analogous to the two-dimensional case described in Chapter 3. Here, one face of the polygon is filled with horizontal lines beginning from its minimum y-coordinate up to its maximum. The only difference here is that we need to calculate the x and y coordinates according to Equations (5.1) and (5.2) because we have depth dependence.

The rotation of the polygon consists of updating the vertices’ values stored in the structure. For this, we use Equations (4.26) and (4.27) obtained in Chapter 4, replacing θ with −θ. Then, these equations read as follows:

${x}^{prime prime }={X}_C+left(x-{X}_C ight)mathit{cos}left( heta ight)+left(y-{Y}_C ight)mathit{sin}left( heta ight)$

(5.3)

${y}^{prime prime }={Y}_C-left(x-{X}_C ight)mathit{sin}left( heta ight)+left(y-{Y}_C ight)mathit{cos}left( heta ight)$

(5.4)

In Equations (5.3) and (5.4), the plane of rotation is x-y. Analogous equations are used for rotations in the x-z and y-z planes.

To simplify the code for the three planes of rotation, each component in the x, y, and z directions will be referred to as X₁, X₂, and X₃, respectively. Then, for a given plane of rotation, we use a pair of global variables called p and q. They correspond to coordinates Xp and Xq. The appropriate code is given in Listing 5-4.

def Rotate(P, Sense):

global p,q;

if Sense==-1:

Teta=np.pi/180*(-5);

else:

Teta=np.pi/180*(5);

Cos_Teta=np.cos(Teta)

Sin_Teta=np.sin(Teta);

Num=P[0];

#Reading center of rotation

RCp=P[2*Num+2][p]; RCq=P[2*Num+2][q];

for n in range(1,Num+1): #Rotating front face

Xp=(P[n][p]-RCp)*Cos_Teta

+ (P[n][q]-RCq)*Sin_Teta +RCp;

Xq=-(P[n][p]-RCp)*Sin_Teta

+ (P[n][q]-RCq)*Cos_Teta +RCq;

P[n][p]=Xp;

P[n][q]=Xq;

#Rotating Back face

for n in range(Num+1,2*Num+1):

Xp=(P[n][p]-RCp)*Cos_Teta

+ (P[n][q]-RCq)*Sin_Teta +RCp;

Xq=-(P[n][p]-RCp)*Sin_Teta

+ (P[n][q]-RCq)*Cos_Teta +RCq;

P[n][p]=Xp;

P[n][q]=Xq;

Listing 5-4

Function to Rotate Polygon Points

As indicated in Listing 5-4, RCp and RCq refer to the center of rotation.

The complete code for main.py and File.kv are shown in Listings 5-5 and 5-6, respectively.

from kivy.app import App

from kivy.uix.floatlayout import FloatLayout

from kivy.graphics import Line, Color

from kivy.clock import Clock

import os

import numpy as np

from kivy.lang import Builder

Builder.load_file(

os.path.join(os.path.dirname(os.path.abspath(

__file__)), 'File.kv')

);

#Avoid Form1 of being resizable

from kivy.config import Config

Config.set("graphics","resizable", True)

Config.set('graphics', 'width', '480');

Config.set('graphics', 'height', '680');

#These values are adjusted by the

#function Initialize()

#after Clock.schedule_once has been executed.

#These values are canvas center (XC,YC)

#and width and height (W,H);

XC=0; YC=0; W=0; H=0;

Flag=False;

NUMBER=0;

#============== Polygon structures ===============

#The first entry corresponds to the

#number of vertexes +1.

#Following pair of entries correspond to the list

#of vertexes ordered in clockwise direction.

#The first vertex is repeated in the

#list as the last vertex.

#Following pair of entries correspond to the center

#of rotation in screen coordinates

#The triplet before the end of the structure

#corresponds to polygon colors, red, green, blue.

D=800;

VX=-20; VY=0; VZ=0;

LX=60; LY=60; LZ=60; # Cube dimensions

#Offsets from the origin. OffZ is measured

#starting from the screen

OffX=-70; OffY=-40; OffZ=200;

Cube=[

5, #Number of vertexes +1

#Front face

[ LX+OffX, LY+OffY, LZ+OffZ], #Vertex 1

[ LX+OffX, -LY+OffY, LZ+OffZ], #Vertex 2

[-LX+OffX, -LY+OffY, LZ+OffZ], #Vertex 3

[-LX+OffX, LY+OffY, LZ+OffZ], #Vertex 4

[ LX+OffX, LY+OffY, LZ+OffZ], #Vertex 1

#Back face

[ LX+OffX, LY+OffY, -LZ+OffZ], #Vertex 1

[ LX+OffX, -LY+OffY, -LZ+OffZ], #Vertex 2

[-LX+OffX, -LY+OffY, -LZ+OffZ], #Vertex 3

[-LX+OffX, LY+OffY, -LZ+OffZ], #Vertex 4

[ LX+OffX, LY+OffY, -LZ+OffZ], #Vertex 1

#Red, green, blue color.

#Entries must be between 0 and 1. Place= 2*Num+1

[0,0,1],

#Center of rotation. Entry=2*Num+2

[OffX,OffY,OffZ]

];

L=90; LZ=20; # Pentagon dimensions

#Offsets from the origin. OffZ is measured

#starting from the screen

OffX=90; OffY=80; OffZ=100;

Pentagon=[

6, #Number of vertexes +1

#Front face

#Vertex 1

[ 1*L+OffX, 0*L+OffY, LZ+OffZ],

#Vertex 2

[ 0.309*L+OffX, .95*L+OffY, LZ+OffZ],

#Vertex 3

[ -0.809*L+OffX, 0.58*L+OffY, LZ+OffZ],

#Vertex 4

[ -0.809*L+OffX, -0.58*L+OffY, LZ+OffZ],

#Vertex 5

[ 0.309*L+OffX, -0.95*L+OffY, LZ+OffZ],

#Vertex 1 repeated

[ 1*L+OffX, 0*L+OffY, LZ+OffZ],

#Back face

#Vertex 1

[ 1*L+OffX, 0*L+OffY, -LZ+OffZ],

#Vertex 2

[ 0.309*L+OffX, .95*L+OffY, -LZ+OffZ],

#Vertex 3

[ -0.809*L+OffX, 0.58*L+OffY, -LZ+OffZ],

#Vertex 4

[ -0.809*L+OffX, -0.58*L+OffY, -LZ+OffZ],

#Vertex 5

[ 0.309*L+OffX, -0.95*L+OffY, -LZ+OffZ],

#Vertex 1 repeated

[ 1*L+OffX, 0*L+OffY, -LZ+OffZ],

[1,0,0], #red, green, blue color.

#Center of rotation. Entry=2*Num+2

[OffX,OffY,OffZ]

];

#---------------------------------------------------

def DrawEdges(P, B):

Num=P[0]; #Reading number of face edges +1

r,g,b=P[2*Num+1]; #Reading colors

for n in range(1,Num): #Drawing front edges

Factor=(D-VZ)/(D-P[n][2]-VZ);

x1=XC+Factor*(P[n][0]-VX)+VX;

y1=YC+Factor*(P[n][1]-VY)+VY;

Factor=(D-VZ)/(D-P[n+1][2]-VZ);

x2=XC+Factor*(P[n+1][0]-VX)+VX;

y2=YC+Factor*(P[n+1][1]-VY)+VY;

B.ids.Screen1.canvas.add( Color(r,g,b) );

B.ids.Screen1.canvas.add( Line(points=

(int(x1),int(y1),int(x2),int(y2)),

width=2) );

for n in range(Num+1,2*Num): #Drawing back edges

Factor=(D-VZ)/(D-P[n][2]-VZ);

x1=XC+Factor*(P[n][0]-VX)+VX;

y1=YC+Factor*(P[n][1]-VY)+VY;

Factor=(D-VZ)/(D-P[n+1][2]-VZ);

x2=XC+Factor*(P[n+1][0]-VX)+VX;

y2=YC+Factor*(P[n+1][1]-VY)+VY;

B.ids.Screen1.canvas.add( Color(r,g,b) );

B.ids.Screen1.canvas.add( Line(points=

(int(x1),int(y1),int(x2),int(y2)),

width=2) );

#Drawing edges between back and front faces

for n in range(1,Num):

Factor=(D-VZ)/(D-P[n][2]-VZ);

x1=XC+Factor*(P[n][0]-VX)+VX;

y1=YC+Factor*(P[n][1]-VY)+VY;

Factor=(D-VZ)/(D-P[Num+n][2]-VZ);

x2=XC+Factor*(P[Num+n][0]-VX)+VX;

y2=YC+Factor*(P[Num+n][1]-VY)+VY;

B.ids.Screen1.canvas.add( Color(r,g,b) );

B.ids.Screen1.canvas.add( Line(points=

(int(x1),int(y1),int(x2),int(y2)),

width=2) );

#---------------------------------------------------

def Rotate(P, Sense):

global p,q;

if Sense==-1:

Teta=np.pi/180*(-5);

else:

Teta=np.pi/180*(5);

Cos_Teta=np.cos(Teta)

Sin_Teta=np.sin(Teta);

Num=P[0];

#Reading center of rotation

RCp=P[2*Num+2][p]; RCq=P[2*Num+2][q];

for n in range(1,Num+1): #Rotating front face

Xp=(P[n][p]-RCp)*Cos_Teta

+ (P[n][q]-RCq)*Sin_Teta +RCp;

Xq=-(P[n][p]-RCp)*Sin_Teta

+ (P[n][q]-RCq)*Cos_Teta +RCq;

P[n][p]=Xp;

P[n][q]=Xq;

#Rotating Back face

for n in range(Num+1,2*Num+1):

Xp=(P[n][p]-RCp)*Cos_Teta

+ (P[n][q]-RCq)*Sin_Teta +RCp;

Xq=-(P[n][p]-RCp)*Sin_Teta

+ (P[n][q]-RCq)*Cos_Teta +RCq;

P[n][p]=Xp;

P[n][q]=Xq;

#---------------------------------------------------

#Function for filling one polygon face, line by line

#Array to store intersection points

Intersect=np.zeros(30);

def FillPolygon(P, B):

Num=P[0]; #Reading number of face edges +1

r,g,b=P[2*Num+1]; #Reading colors

#Calculating polygon YMin, Ymax

#for limiting number of line scans

Factor=(D-VZ)/(D-P[Num+1][2]-VZ);

YMin=YC+Factor*(P[Num+1][1]-VY)+VY;

YMax=YMin;

for n in range(Num+1,2*Num):

Factor=(D-VZ)/(D-P[n+1][2]-VZ);

if YMin>YC+Factor*(P[n+1][1]-VY)+VY:

YMin=YC+Factor*(P[n+1][1]-VY)+VY;

if YMax<YC+Factor*(P[n+1][1]-VY)+VY:

YMax=YC+Factor*(P[n+1][1]-VY)+VY;

#We have now (YMin, YMax). We now proceed

#filling lines between Ymin and Ymax

for y in np.arange (YMin, YMax, 2):

Counter=0;

#We search line cuts, segment by segment

for n in range(Num+1, 2*Num):

#We first order the two vertices of each

#segment such that Y1<Y2

Factor1=(D-VZ)/(D-P[n][2]-VZ);

YA=YC+Factor1*(P[n][1]-VY)+VY;

Factor2=(D-VZ)/(D-P[n+1][2]-VZ);

YB=YC+Factor2*(P[n+1][1]-VY)+VY;

if ( YA<YB ):

Y1=YA;

X1=XC+Factor1*(P[n][0]-VX)+VX;

Y2=YB;

X2=XC+Factor2*(P[n+1][0]-VX)+VX;

else:

Y1=YB;

X1=XC+Factor2*(P[n+1][0]-VX)+VX;

Y2=YA;

X2=XC+Factor1*(P[n][0]-VX)+VX;

if (Y1<=y and y<Y2):

if (Y2-Y1)!=0:

M=(X2-X1)/(Y2-Y1);

else:

#if Y1=Y2, the slope becomes

#infinite. Therefore,

#we assign to M a large value

M=1.0e8;

#We store the x value

Intersect[Counter]=(y-Y1)*M+X1;

#And we increment Counter as a

#new value has being stored

Counter=Counter+1;

#Our polygon is a closed figure. We ask If

#an even number of cuts have occurred

if(Counter>1 and Counter %2==0):

#Intersect1 stores ordered pairs of

#x values

Intersect1=np.sort(Intersect[0:Counter]);

#We proceed tracing horizontal lines

#between pairs of intersections

for n in range(0,Counter,2):

XIntersect1=int(Intersect1[n]);

XIntersect2=int(Intersect1[n+1]);

Y=int(y)

#Picking the color and drawing the

#horizontal line between x pairs

B.ids.Screen1.canvas.add(

Color(r,g,b) );

B.ids.Screen1.canvas.add( Line(

points=(XIntersect1,Y,

XIntersect2,Y), width=1.0) );

#---------------------------------------------------

class Form1(FloatLayout):

def __init__(Handle, **kwargs):

super(Form1, Handle).__init__(**kwargs);

Event1=Clock.schedule_once(

Handle.Initialize);

Event2=Clock.schedule_interval(

Handle.Temporal,0.1);

def Initialize(B, *args):

global W,H, XC,YC;

W,H=B.ids.Screen1.size;

XI,YI=B.ids.Screen1.pos

XC=XI+int (W/2);

YC=YI+int(H/2);

def Temporal(B, *args):

global Flag, NUMBER, p, q;

if (Flag==True):

if (B.ids.Button3.state=="down"):

Sense=-1; p=0; q=1;

if(B.ids.Button5.state=="down"):

Sense=-1; p=0;q=2;

if(B.ids.Button7.state=="down"):

Sense=-1; p=1;q=2;

if(B.ids.Button4.state=="down"):

Sense=1; p=0;q=1;

if(B.ids.Button6.state=="down"):

Sense=1;p=0;q=2;

if(B.ids.Button8.state=="down"):

Sense=1;p=1;q=2;

B.ids.Screen1.canvas.clear();

if(NUMBER==0):

Rotate(Cube, Sense);

if (NUMBER==1):

Rotate(Pentagon, Sense);

DrawEdges(Cube,B);

FillPolygon(Cube,B);

DrawEdges(Pentagon,B);

FillPolygon(Pentagon,B);

def Button1_Click(B):

B.ids.Screen1.canvas.clear();

DrawEdges(Cube, B);

FillPolygon(Cube,B);

DrawEdges(Pentagon, B);

FillPolygon(Pentagon,B)

def Button2_Click(B):

B.ids.Screen1.canvas.clear();

def Button3_Click(B):

global Flag;

Flag=True;

def Button3_Release(B):

global Flag ;

Flag=False;

def Button4_Click(B):

global Flag;

Flag=True;

def Button4_Release(B):

global Flag;

Flag=False;

def Button5_Click(B):

global Flag;

Flag=True;

def Button5_Release(B):

global Flag;

Flag=False;

def Button6_Click(B):

global Flag;

Flag=True;

def Button6_Release(B):

global Flag;

Flag=False;

def Button7_Click(B):

global Flag;

Flag=True;

def Button7_Release(B):

global Flag;

Flag=False;

def Button8_Click(B):

global Flag;

Flag=True;

def Button8_Release(B):

global Flag;

Flag=False;

def Button9_Click(B):

global NUMBER;

NUMBER=(NUMBER+1)%2;

B.ids.Label1.text=str(NUMBER);

# This is the Start Up code.

class StartUp (App):

def build (BU):

BU.title="Form1"

return Form1();

if __name__ =="__main__":

StartUp().run();

Listing 5-5

The main.py Code Listing

#:set W 440

#:set H 440

<Form1>:

id : Form1

StencilView:

id: Screen1

size_hint: None,None

pos_hint: {"x":0.04, "y":0.34}

size: W,H

canvas.before:

Color:

rgba: 0.9, 0.9, 0, 1

RoundedRectangle:

pos: self.pos

size: self.size

Button:

id: Button1

on_press: Form1.Button1_Click()

text: "Button1"

size_hint: None,None

pos_hint: {"x": 0.2, "y":0.03}

size: 100,30

Button:

id: Button2

on_press: Form1.Button2_Click()

text: "Button2"

size_hint: None,None

pos_hint: {"x": 0.63, "y":0.03}

size: 100,30

Button:

id: Button3

on_press: Form1.Button3_Click()

on_release: Form1.Button3_Release()

text: "Button3"

size_hint: None,None

pos_hint: {"x": 0.05, "y":0.12}

size: 100,30

always_release: True

Button:

id: Button4

on_press: Form1.Button4_Click()

on_release: Form1.Button4_Release()

text: "Button4"

size_hint: None,None

pos_hint: {"x": 0.73, "y":0.12}

size: 100,30

Button:

id: Button5

on_press: Form1.Button5_Click()

on_release: Form1.Button5_Release()

text: "Button5"

size_hint: None,None

pos_hint: {"x": 0.05, "y":0.20}

size: 100,30

Button:

id: Button6

on_press: Form1.Button6_Click()

on_release: Form1.Button6_Release()

text: "Button6"

size_hint: None,None

pos_hint: {"x": 0.73, "y":0.20}

size: 100,30

Button:

id: Button7

on_press: Form1.Button7_Click()

on_release: Form1.Button7_Release()

text: "Button7"

size_hint: None,None

pos_hint: {"x": 0.05, "y":0.28}

size: 100,30

Button:

id: Button8

on_press: Form1.Button8_Click()

on_release: Form1.Button8_Release()

text: "Button8"

size_hint: None,None

pos_hint: {"x": 0.73, "y":0.28}

size: 100,30

Button:

id: Button9

on_press: Form1.Button9_Click()

text: "Button9"

size_hint: None,None

pos_hint: {"x": 0.38, "y":0.12}

size: 100,30

Label:

id: Label1

text: "0"

font_size: 30

color: 1,1,0,1

size_hint: None,None

pos_hint: {"x": 0.38, "y":0.20}

size: 100,30

Listing 5-6

The File.kv Code Listing

5.3 Summary

In this chapter, we introduced the required structures and functions to construct and rotate three-dimensional polygons. We described how to map them on the computer's screen using the equations obtained in Chapter 4.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for 5. Programming Three-Dimensional Polygons

Create new playlist

Sign In

Sign Up

5. Programming Three-Dimensional Polygons

5.1 Polygon Structure

5.2 Basic Functions

5.3 Summary

Table of Contents for
5. Programming Three-Dimensional Polygons