Anfänger frage wheel of fortune

Fragen zu Tkinter.
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:hi @Alfons Mittelmeyer, nicht schlecht aber nicht das was ich brauche möchte, du hast gerade ein lauf hier dein code mit meinen wünschen :D, vielleicht hast es auch schon so weit.
Musste leider weg und ob ich heute noch dazu komme, weiß ich nicht. Jedenfalls werde ich noch etwas probieren, auch um die Performance festzustellen und zu testen, ob es noch schneller uind besser geht.

Ach, so das Bild kannst du hier hochladen, wäre gut, wenn ich das habe: https://www.pic-upload.de/
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

@Alfons Mittelmeyer nur kein stress, ich bin dankbar für jeden Beispiel für jeden tipp wo ich etwas dabei lerne, bei dem Bild sind wir uns noch nicht einig ob es eins mit 24 Feldern oder mit 12 oder mit 9, ich denke das ist egal wieviele Felder, wichtig ist das ich es nachher selber verstehe und erweitern kann, wenn du aber Bild willst kann ich eins hochladen.

Danke
Gruß ganja
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:@Alfons Mittelmeyer nur kein stress, ich bin dankbar für jeden Beispiel für jeden tipp wo ich etwas dabei lerne, bei dem Bild sind wir uns noch nicht einig ob es eins mit 24 Feldern oder mit 12 oder mit 9, ich denke das ist egal wieviele Felder, wichtig ist das ich es nachher selber verstehe und erweitern kann, wenn du aber Bild willst kann ich eins hochladen.

Danke
Gruß ganja
Wenn Du eh noch nicht weißt, wieviel Felder, dann brauchst Du auch keines hochladen. Die Farbe kannst Du doch besimmen wie Du willst, das bleibt doch Dir überlassen. Ist es das, was Du Dir vorstellst? Das kann man auch mit Leertaste starten:

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
 
try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
 
 
from PIL import Image,ImageTk
from random import random 
class Application(tk.Tk):
    ### so ist mein Bild aufgebaut wo packe ich das hin, um nachher irgend etwas auszuführen wenn Gewinn
    #WHEEL_TEXT = {45 : "GEWINN", 90 : "NICHTS", 135 : "GEWINN", 180 : "NICHTS", 225 : "GEWINN", 270 : "NICHTS", 315 : "GEWINN", 360 : "GEWINN"}
 
    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================
        self.label_pil_img = Image.open('fortune.png')
       
        self.label = tk.Label(self)
        self.label.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.label.pack(expand=1,fill='both')
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
       
        ### hier mit starten mit space taste
        self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
        self.Button.pack()
        self.Button.bind('<space>',self.start_rotate)
        ### nach 5 secunden stoppen von alleine oder eine andere zeit muss ich erst sehen ob 5 zu kurz oder zu lang

        self.load_image()
        self.label['image'] = self.img_dict[0]
        self.load_images()
        

    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.Button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)

    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)


    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10

    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.Button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img_dict[self.angle]
            self.after(self.step,self.img_rotate)
 
    def wheel_stop(self,event=None):
        self.angle_step = 5
       
    ## die grösse möchte ich vom Fenster definieren so wie farbe etc
 
if __name__ == '__main__':
    Application().mainloop()
Die Stopzeit ist jetzt 4,5 bis 5,5 Sekunden. Und zu Beginn gibt es auch nicht mehr die langsame Phase.
Benutzeravatar
kaytec
User
Beiträge: 608
Registriert: Dienstag 13. Februar 2007, 21:57

Hallo,

habe es schon letztes Jahr weiter gemacht, doch es wurde immer komplexer und ich habe mich im Aufbau verbastelt. Hier ist mal was ich habe uns ihr könnt es zerfleddern.

Ganja --> die Anzahl der Teilungen des Vollwinkels und das Hochzählen in der Logik ist auch gleichzeitig die aktuelle Stellung des Rades. Aus dieser
Stellung kannst du den aktuellen Wert ermitteln, den du bei mir in "WHEEL_TEXT" stehen hast. Jeder Teil des Vollwinkels ist ein
"Indexsprung" in der TEXT_LISTE.

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf-8
import random
import Tkinter as tk
from PIL import Image, ImageTk, ImageDraw, ImageFont
import StringIO
import base64 
from functools import partial


ANSWERS = {"SPORTS" : (("NORTH AMERICAN ",
                        "  WATER POLO   ",
                        "   REGIONALS   "),
                       ("   ICE STICK   ", 
                        "    SHOOTING   ")),
           "POLITICS" : (("  RECEP TAYYIP ",
                          "    ERDOGAN    "), 
                         (" ANGELA MERKEL "),
                         ("    WLADIMIR   ", 
                          "WLADIMIROWITSCH", 
                          "     PUTIN     "), 
                         ("HEINRICH LUEBKE")),
           "PROVERBS" : (("    ANY HINZ   ", 
                          "    AND KUNZ   "),
                         ("   NACHTIGAL   ",
                          "    ICK HOER    ",
                          "  DIR TRAPSEN  ")),
           "BANDS": ((("  BACK STREET  ", 
                       "      BOYS     ")), 
                     (("   THE TEENS   ")), 
                     (("MODERN TALKING ")))}
                     
ALPHABET = (("A", "B", "C", "D", "E", "F", "G", "H", "I", "J"), 
            ("K", "L", "M", "N", "O", "P", "Q", "R", "S", "T"),
            ("U", "V", "W", "X", "Y", "Z"))
            
VOWELS = ("A", "E", "I", "O", "U")
             
PLAYERS = [{"name" : "Kaytec", "score" : 0, "status" : "rotate",
            "extra_status" : list()},
           {"name" : "Nina", "score" : 0, "status" : "rotate", 
            "extra_status" : list()},
            {"name" : "Maren", "score" : 0, "status" : "rotate", 
            "extra_status" : list()}, 
            {"name" : "Peter", "score" : 0, "status" : "rotate", 
            "extra_status" : list()}]
            
class Wheel_of_Fortune(object):
    START_INTERVAL = 20
    SLOW_DOWN_STEP = 1
    FONT_SIZE = 50
    CIRCULAR_SEGMENT = 15
    ROTATE_STEP_DEGREES = 7.5
    FULL_ROTATION_STEPS = 360 / ROTATE_STEP_DEGREES
    VOWEL_PRICE = 1000
                         
    WHEEL_TEXT = ("MISS A TURN", "400", "200", "900", "500", "200", 
                  "BANKRUPT", "700", "450", "200", "400", "FREE SPIN", 
                  "750", "400", "200", "600", "400", "150", "1000", 
                  "800", "250", "500 GAMBLES", "300", "200")

    def __init__(self, answers, alphabet, VOWELS, players):
        #self.wheel =  Image.open(StringIO.StringIO(base64.decodestring(
            #WHEEL))).convert("RGBA")
        self.wheel =  Image.open("wheel.gif").convert("RGBA")
        self.font = ImageFont.truetype(
            "ALGER.TTF", 
            self.FONT_SIZE)
        self.full_rotation_steps = self.FULL_ROTATION_STEPS
        self.alphabet = alphabet
        self.vowels = VOWELS
        self.players = players
        self.answers = answers
        category = random.choice(self.answers.keys())
        answer = random.choice(self.answers[category])
        self.attributes = {"images" : list(), "speed" : self.START_INTERVAL,
            "run" : True, "rotate" : False, "player" : self.next_player(True), 
            "answer" : {"category" : category, "answer" : answer },
            "width" : self.wheel.size[0], "height" : self.wheel.size[1], 
            "chosen_letters" : list(), "prize" : 0}
        self.attributes["images"].append([(self.attributes["width"] / 2, 
            self.attributes["height"] / 2),  ImageTk.PhotoImage(self.wheel)])
        random_index = random.choice(range(len(self.WHEEL_TEXT)))
        self.text_img = self.create_text_img(random_index)
        self.new_text_image_size = self.text_img.size[0]
        self.random_degrees = random_index * self.CIRCULAR_SEGMENT
        self.text_rotate_degrees = 0
        self.degrees = 0
        
    def set_positions(self):
        self.attributes["images"] = list()
        self.attributes["images"].append([(self.attributes["width"]/ 2, 
            self.attributes["height"] / 2), 
            ImageTk.PhotoImage(self.wheel.rotate(self.degrees))])
        if self.attributes["player"]["status"] == "rotate":
            if self.attributes["rotate"]:
                self.rotate_wheel()
        else:
            for status in ("BANKRUPT", "FREE SPIN", "500 GAMBLES", 
                    "MISS A TURN"):
                if status == self.attributes["player"]["status"]:
                    if self.attributes["player"]["status"] == "BANKRUPT":
                        self.attributes["player"]["status"] = "rotate"
                        if "FREE SPIN" in self.attributes["player"][
                            "extra_status"]:
                            self.attributes["player"]["extra_status"].remove(
                                "FREE SPIN")
                        else:
                            self.attributes["player"]["score"] = 0
                            self.attributes["player"] = self.next_player()
                    elif self.attributes["player"]["status"] == "FREE SPIN":
                        self.attributes["player"]["extra_status"].append(
                            "FREE SPIN")
                        self.attributes["player"]["status"] = "rotate"
                    elif self.attributes["player"]["status"] == "MISS A TURN":
                        self.attributes["player"]["status"] = "rotate"
                        if "FREE SPIN" in self.attributes["player"][
                                "extra_status"]:
                            self.attributes["player"]["extra_status"].remove(
                                "FREE SPIN")
                        else:
                            self.attributes["player"] = self.next_player()
                    elif self.attributes["player"]["status"]== "500 GAMBLES":
                        self.attributes["player"]["extra_status"].append(
                            "500 GAMBLES")
                        self.attributes["player"]["status"] = "rotate"
        
    def start_wheel(self):
        if self.attributes["rotate"] == False:
            self.attributes["rotate"] = True
            
    def choose_letter(self, chosen_letter):
        if self.attributes["player"]["status"] == "choose_letter":
            old_letters = list()
            for letter in self.attributes["chosen_letters"]:
                old_letters.append(letter)
            if chosen_letter in self.vowels:
                old_score = self.attributes["player"]["score"] 
                new_score = old_score - self.VOWEL_PRICE
                if new_score < 0:
                    chosen_letter = None
                else:
                    self.attributes["player"]["score"] = new_score
            for answer_part in self.attributes["answer"]["answer"]:
                if len(answer_part) > 0:
                    for letter in answer_part:
                        if letter == chosen_letter:
                            if letter not in self.vowels:
                                self.attributes["player"]["score"] \
                                    += self.attributes["prize"]
                            self.attributes["chosen_letters"].append(letter)
                else:
                    if answer_part == chosen_letter:
                        if letter not in self.vowels:
                            self.attributes["player"]["score"] \
                                += self.attributes["prize"]
                        self.attributes["chosen_letters"].append(letter)
            if len(self.attributes["chosen_letters"]) == len(old_letters) \
                and chosen_letter is not None:
                if "FREE SPIN" in self.attributes["player"]["extra_status"]:
                    self.attributes["player"]["extra_status"].remove(
                        "FREE SPIN")
                else:
                    self.attributes["player"]["status"] = "rotate"
                    self.attributes["player"] = self.next_player()
            else:
                if chosen_letter is None:
                    self.attributes["player"]["status"] = "choose_letter"
                else:
                    self.attributes["player"]["status"] = "rotate"

    def rotate_wheel(self):
        if self.degrees != self.random_degrees +\
            self.full_rotation_steps * self.ROTATE_STEP_DEGREES:
            if self.degrees != self.random_degrees:
                self.attributes["speed"] += self.SLOW_DOWN_STEP
            self.degrees += self.ROTATE_STEP_DEGREES
        else:
            if self.text_rotate_degrees != self.ROTATE_STEP_DEGREES \
                * self.text_img.size[0]:
                self.attributes["speed"] = self.START_INTERVAL
                self.attributes["images"].append([(self.attributes["width"] 
                    / 2, self.attributes["height"] / 2), ImageTk.PhotoImage(
                    self.text_img.rotate(self.text_rotate_degrees).resize((
                    self.new_text_image_size, self.new_text_image_size)))])
                self.text_rotate_degrees += self.ROTATE_STEP_DEGREES
                self.new_text_image_size -= 1
            else: 
                if self.WHEEL_TEXT[self.random_degrees / 
                    self.CIRCULAR_SEGMENT] not in ("BANKRUPT", "FREE SPIN", 
                    "500 GAMBLES", "MISS A TURN"):
                    self.attributes["player"]["status"] = "choose_letter"
                    self.attributes["prize"] = int(float(self.WHEEL_TEXT[
                    self.random_degrees / self.CIRCULAR_SEGMENT]))
                    
                else:
                    self.attributes["player"]["status"] = self.WHEEL_TEXT[
                    self.random_degrees / self.CIRCULAR_SEGMENT]
                self.text_rotate_degrees = 0
                random_index = random.choice(range(len(self.WHEEL_TEXT)))
                self.text_img = self.create_text_img(random_index)
                self.new_text_image_size = self.text_img.size[0]
                self.random_degrees = random_index * self.CIRCULAR_SEGMENT
                self.text_rotate_degrees = 0
                self.degrees -= self.FULL_ROTATION_STEPS \
                    * self.ROTATE_STEP_DEGREES * 2
                self.attributes["rotate"] = False
                    
    def create_text_img(self, index):
        text = self.WHEEL_TEXT[index]
        text_img = Image.new("RGBA", (self.font.getsize(text)[0], 
            self.font.getsize(text)[0]))
        draw = ImageDraw.Draw(text_img)
        draw.text((0, self.font.getsize(text)[0] / 2 
            - self.font.getsize(text)[1] / 2 - 5), 
            text, (255, 255, 255), font = self.font)
        return text_img
        
    def next_player(self, first_start = False):
        if first_start:
            random.shuffle(self.players)
        else:
            self.players.reverse()
            last_player = self.players.pop()
            self.players.reverse()
            self.players.append(last_player)
        return self.players[0]


class Wheel_of_Fortune_Gui(object):

    def __init__(self, root):
        self.root = root
        self.letter_buttons = dict()
        self.answer_labels = list()
        self.wheel_of_fortune = Wheel_of_Fortune(ANSWERS, ALPHABET, 
            VOWELS, PLAYERS)
        self.canvas = tk.Canvas(root, width=self.wheel_of_fortune.attributes[
            "width"],height=self.wheel_of_fortune.attributes["height"])
        self.canvas.grid(row=0, column=0, padx=4, pady=4)
        for attributes in self.wheel_of_fortune.attributes["images"]:
            pos, img = attributes
            x, y = pos
            self.canvas.create_image(x, y, image=img)
        control_frame = tk.LabelFrame(root, relief=tk.FLAT)
        control_frame.grid(row=0, column=1)
        self.player_frame = tk.LabelFrame(control_frame,
            text=self.wheel_of_fortune.attributes[
            "player"]["name"],relief=tk.SOLID)
        self.player_frame.grid(row=0, column=0, sticky=tk.W+tk.E+tk.N+tk.S, 
            padx=4, pady=4)
        self.score_label = tk.Label(self.player_frame, 
            text=self.wheel_of_fortune.attributes["player"]["score"])
        self.score_label.pack(side=tk.TOP)
        answers_frame = tk.LabelFrame(control_frame, relief=tk.SOLID,
            text=self.wheel_of_fortune.attributes["answer"]["category"])
            
        def create_label(frame, letter, row, column):
            if letter == " ":
                relief = tk.FLAT
            else:
                relief = tk.SOLID
            label=tk.Label(frame, text="", width=2, relief=relief,
                font="Arial 11")
            label.grid(row=row, column=column, padx=2, pady=4)
            return label
            
        row = 0
        for column, answer_parts in enumerate(self.wheel_of_fortune.attributes[
            "answer"]["answer"]):
            if len(answer_parts) > 1:
                labels = list()
                row += 1
                for column, letter in enumerate(answer_parts):
                    labels.append(create_label(answers_frame, letter, row, 
                        column))
                self.answer_labels.append(labels)
            else:
                self.answer_labels.append(create_label(answers_frame, 
                    answer_parts, row, column))
        answers_frame.grid(row=1, column=0, sticky=tk.W+tk.E+tk.N+tk.S, padx=4, 
            pady=4)
        letter_frame = tk.LabelFrame(control_frame, text="Letters", 
            relief=tk.SOLID)
        for row, letters in enumerate(ALPHABET):
            for column, letter in enumerate(letters):
                button = tk.Button(letter_frame, text=letter, width=1,
                command=partial(self.choose_letter, letter))
                button.grid(row=row, column=column)
                if letter in VOWELS:
                    button.config(fg = "red")
                self.letter_buttons[letter] = button
        letter_frame.grid(row=2, column=0, padx=4, pady=4)
        tk.Button(control_frame, text='ROTATE WHEEL', 
            command=self.wheel_of_fortune.start_wheel).grid(row=3,
            column=0)
        self.after_id = None
            
    def start_wheel(self):
        self.wheel_of_fortune.start_wheel()
        
    def choose_letter(self, letter):
        self.wheel_of_fortune.choose_letter(letter)
        
    def run(self):
        self.wheel_of_fortune.set_positions()
        self.canvas.delete(tk.ALL)
        for attributes in self.wheel_of_fortune.attributes["images"]:
            pos, img = attributes
            x, y = pos
            self.canvas.create_image(x, y, image=img)
        self.score_label.config(text=self.wheel_of_fortune.attributes[
            "player"]["score"])
        self.player_frame.config(text=self.wheel_of_fortune.attributes[
            "player"]["name"])
        for labels, answer_part in zip(self.answer_labels, 
            self.wheel_of_fortune.attributes["answer"]["answer"]):
            if len(answer_part) > 1:
                for letter, label in zip(answer_part, labels):
                    if letter in self.wheel_of_fortune.attributes[
                        "chosen_letters"]:
                        label.config(text=letter, fg="black")
            else:
                if answer_part in self.wheel_of_fortune.attributes[
                    "chosen_letters"]:
                    labels.config(text=answer_part, fg="black")
        for letter in self.wheel_of_fortune.attributes["chosen_letters"]:
            self.letter_buttons[letter].config(state=tk.DISABLED)
        if self.wheel_of_fortune.attributes["run"]:
            self.after_id = self.root.after(self.wheel_of_fortune.attributes[
                "speed"], self.run)
        else:
            self.root.after_cancel(self.after_id)
            self.after_id = None
            
    def release(self):
        self.root.after_cancel(self.after_id)
        self.root.destroy()
            
def main():
    root = tk.Tk()
    root.title('WHEEL OF FORTUNE')
    wheel_of_fortune_gui = Wheel_of_Fortune_Gui(root)
    wheel_of_fortune_gui.run()
    root.protocol("WM_DELETE_WINDOW", wheel_of_fortune_gui.release)
    root.mainloop()
if __name__ == '__main__':
    main()
Gruß Frank
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

Guten Morgen, @ kaytec Vielen Dank ist echt umfangreich geworden Danke.

Guten Morgen @Alfons Mittelmeyer das ist es, ich möchte es jetzt in ein Frame haben, ich versuche ob es klappt.
class Application()

class Gui()

Da ich noch ein paar Labels seitlich anzeigen möchte und die Größe Farbe etc insgesamt möchte ich ändern können

VIelen Dank
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

@Alfons Mittelmeyer könntest du nochmal schauen, so stelle ich es mir vor, ganz oben der Pfeil der zeigt wo es anhält vielleicht kann man das auch mit label anstatt canvas hin bekommen ich weiss es leider nicht,

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
     
try:
	import tkinter as tk
except ImportError:
	import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random

class Application(object):
	def __init__(self):
		tk.Tk.__init__(self)
                self.label_pil_img = Image.open('fortune.png')
		
		self.label = tk.Label(self,root)
		self.label.bind('<space>',self.start_rotate)
		self.bind('<space>',self.start_rotate)
		self.label.pack(expand=1,fill='both')
		self.angle=0
		self.img_dict = {}
		self.angle_step = 0
		self.load_angle = 0
		self.step = 20
           
		self.Button = tk.Button(self,root, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
		self.Button.pack()
		self.Button.bind('<space>',self.start_rotate)
     
		self.load_image()
		self.label['image'] = self.img_dict[0]
		self.load_images()
	
	def start_rotate(self,event=None):
		if not self.angle_step:
			self.angle_step = 10
			self.angle = self.angle// 10 * 10
			self.img_rotate()
			self.Button['state'] = 'disabled'
			self.after(int(4500+random()*1000),self.wheel_stop)
	
	
	def load_images(self):
		if self.load_angle < 360:
			self.load_image()
			self.after(1,self.load_images)
     
	def load_image(self):
		self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
		self.load_angle += 10
		
	 
	def img_rotate(self):
		self.angle += self.angle_step
		self.angle = self.angle % 360
		if self.angle_step != 10:
			self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img
			if not (self.angle % 15):
				self.angle_step = max(0,self.angle_step-1)
			if self.angle_step:
				self.after(self.step,self.img_rotate)
			else:
				self.Button['state'] = 'normal'
				print(self.angle)
		else:
			if self.angle not in self.img_dict:
				self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img_dict[self.angle]
			self.after(self.step,self.img_rotate)
     
	def wheel_stop(self,event=None):
		self.angle_step = 5


class Application_Gui(tk.Canvas):
	def __init__(self, root):
		tk.Canvas.__init__(self, root, highlightthickness=0)
		canvas_width = 50
		canvas_height =50
		python_green = "black"
		w = tk.Canvas(root,  width=canvas_width, height=canvas_height,highlightthickness=0)
		w.pack()
		points = [0,25,canvas_width,canvas_height/2, 25, canvas_height]
		w.create_polygon(points, outline=python_green, 
			fill='black', width=3)
		
def main():
	root = tk.Tk()
	root.title('WHEEL OF FORTUNE')
	application_gui = Application_Gui(root)
	application_gui.pack()
	root.geometry("1200x815+0+0")
	root.mainloop()
	
if __name__ == '__main__':
	main()
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:ich möchte es jetzt in ein Frame haben, ich versuche ob es klappt.
Besser wäre, das Image in einem Canvas unterzubringen. Da kannst Da dann auch nämlich noch so einen Zeiger unterbringen, der in das Wheel reinragt.

Als fortune.png habe ich jetzt folgende Größe genommen:

Bild

Und das ist mit cavas und Zeiger. Als Zeiger könnte man natürlich auch ein Bild nehmen:

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
 
try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
 
 
from PIL import Image,ImageTk
from random import random
class Application(tk.Tk):
    ### so ist mein Bild aufgebaut wo packe ich das hin, um nachher irgend etwas auszuführen wenn Gewinn
    #WHEEL_TEXT = {45 : "GEWINN", 90 : "NICHTS", 135 : "GEWINN", 180 : "NICHTS", 225 : "GEWINN", 270 : "NICHTS", 315 : "GEWINN", 360 : "GEWINN"}
 
    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================
        self.label_pil_img = Image.open('fortune.png')

        self.canvas = Canvas_1(self,name='#0_canvas')
        self.canvas.pack()
        self.canvas.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
       
        ### hier mit starten mit space taste
        self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
        self.Button.pack()
        self.Button.bind('<space>',self.start_rotate)
        ### nach 5 secunden stoppen von alleine oder eine andere zeit muss ich erst sehen ob 5 zu kurz oder zu lang
 
        self.load_image()
        self.canvas.itemconfig('wheel',image= self.img_dict[0])

        self.load_images()
       
 
    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.Button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)
 
    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)
 
 
    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10
 
    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img)
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.Button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img_dict[self.angle])
            self.after(self.step,self.img_rotate)
 
    def wheel_stop(self,event=None):
        self.angle_step = 5
       
    ## die grösse möchte ich vom Fenster definieren so wie farbe etc

class Canvas_1(tk.Canvas):

    def __init__(self,master,**kwargs):
        tk.Canvas.__init__(self,master,**kwargs)
        self.config(height='550', width='500')
        # widget definitions ===================================
        coords = (252,274)
        item_wheel = self.create_image(*coords)
        self.image_1 = ImageTk.PhotoImage(Image.open('fortune.png'))
        self.itemconfig(item_wheel,image = self.image_1,tags='wheel')

        coords = (188,3,316,125)
        item = self.create_arc(*coords)
        self.itemconfig(item,start = '75.0',extent = '30.0',fill = 'orange',width = '3.0')
 
if __name__ == '__main__':
    Application().mainloop()
Benutzeravatar
wuf
User
Beiträge: 1529
Registriert: Sonntag 8. Juni 2003, 09:50

Hi ganja

Hier noch eine andere Variante zum ausprobieren:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from functools import partial
from random import randint, uniform

try:
    import Tkinter as tk
except ImportError:
    import tkinter as tk

from PIL import Image,ImageTk

APP_TITLE = "The Wheel of Fortune"
APP_XPOS = 100
APP_YPOS = 100
APP_WIDTH = 300
APP_HEIGHT = 200

TEXT_FONT = ('Helvetica', 20, 'bold')
TEXT_FG = 'gray'

NUM_OF_FIELDS = 24
STEP_SIZE = 360 / NUM_OF_FIELDS
MARK_WIDTH = 40
MARK_HEIGHT = MARK_WIDTH
MARK_COLOR = 'gray70'
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT), (0, 0)]


class Application(tk.Frame):

    def __init__(self, master):
        self.master = master
        self.master.protocol("WM_DELETE_WINDOW", self.close)
        tk.Frame.__init__(self, master)
        
        self.wheel_pos = 0
        
        self.cv_mark = tk.Canvas(self, width=50, height=50)
        self.cv_mark.pack(pady=2)
        self.cv_mark.create_polygon(POLYGON_POINTS, fill=MARK_COLOR,
            tag='mark')
            
        self.wheel = tk.Label(self)
        self.wheel.pack(expand=True, fill='both')

        self.start_button = tk.Button(self, relief='flat', font=TEXT_FONT, 
            fg=TEXT_FG, activebackground=self['bg'], text='Push the wheel',
            bd=0, activeforeground='green', command=self.run)
        self.start_button.pack(pady=5)
        
        self.wheel_pil_img = Image.open('wheel_of_fortune.png')
        self.wheel_tk_img = ImageTk.PhotoImage(self.wheel_pil_img)
        self.wheel['image'] = self.wheel_tk_img
        
        self.run_flag = False
        self.seed = 0.0
        
    def run(self):
        if not self.run_flag:
            self.run_flag = True
            self.seed = uniform(0.05, 0.15)
            self.focus_set()
            self.cv_mark.itemconfigure('mark', fill=self['bg'])
            self.start_button['fg'] = 'red'
            self.start_button['activeforeground'] = 'red'
            self.rotate_wheel()

    def rotate_wheel(self, tmcol=5.0, time_step=5):
        tmcol += float(time_step) * self.seed
        time_step = int(tmcol)

        if time_step > 500: 
            self.run_flag = False
            self.cv_mark.itemconfigure('mark', fill=MARK_COLOR)
            self.start_button['fg'] = TEXT_FG
            self.start_button['activeforeground'] = 'green'
            return
            
        self.wheel_tk_img = ImageTk.PhotoImage(self.wheel_pil_img.rotate(
            self.set_wheel_pos()))
        self.wheel['image'] = self.wheel_tk_img
        
        self.after(time_step, self.rotate_wheel, tmcol, time_step)

    def set_wheel_pos(self):
        self.wheel_pos -= STEP_SIZE
        if self.wheel_pos == 360: self.wheel_pos = 0
        return self.wheel_pos
            
    def close(self):
        print("Application-Shutdown")
        self.master.destroy()

        
def main():
    app_win = tk.Tk()
    app_win.title(APP_TITLE)
    app_win.geometry("+{}+{}".format(APP_XPOS, APP_YPOS))
    app_win.option_add("*highlightThickness", 0)
    app = Application(app_win).pack(fill='both', expand=True, padx=6, pady=6)
    
    app_win.mainloop()
 
 
if __name__ == '__main__':
    main()      
Gruss wuf :wink:
Take it easy Mates!
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

@Alfons Mittelmeyer das vorherige beispiel ist für mich besser, ich muss mit wenigen griffen die größe anpassen können, ich möchte es mal am Laptop laufen lassen und mal am 46" Monitor, mein Beispiel wo ich gepostet habe wäre das richtige, aber ich bekomme es nicht zu laufen. Ich möchte die Fenstergröße beliebig anpassen Farbe auch und dann die Größe vom Bild, auf einem 46" brauche ich wahrscheinlich ein sehr größer Bild. es wäre auch nicht schlecht wenn das Label mit dem Bild in einem frame wäre so das ich z.b den Abstand zwischen button und label nach belieben einstellen kann, ist das möglich ich bin an meine grenzen gestoßen ich bekomme das unten einfach nicht hin.
kann man das hier anpassen das es läuft(dann würde ich selber weiter versuchen, in class Application_Gui muss doch was rein aus class Application):

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
     
try:
	import tkinter as tk
except ImportError:
	import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random

class Application(object):
	def __init__(self):
		tk.Tk.__init__(self)
		#self.label_pil_img = Image.open('Gluecksrad_750.png')
                self.label_pil_img = Image.open('fortune.png')
		
		self.label = tk.Label(self,root)
		self.label.bind('<space>',self.start_rotate)
		self.bind('<space>',self.start_rotate)
		self.label.pack(expand=1,fill='both')
		self.angle=0
		self.img_dict = {}
		self.angle_step = 0
		self.load_angle = 0
		self.step = 20
           
		self.Button = tk.Button(self,root, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
		self.Button.pack()
		self.Button.bind('<space>',self.start_rotate)
     
		self.load_image()
		self.label['image'] = self.img_dict[0]
		self.load_images()
	
	def start_rotate(self,event=None):
		if not self.angle_step:
			self.angle_step = 10
			self.angle = self.angle// 10 * 10
			self.img_rotate()
			self.Button['state'] = 'disabled'
			self.after(int(4500+random()*1000),self.wheel_stop)
	
	
	def load_images(self):
		if self.load_angle < 360:
			self.load_image()
			self.after(1,self.load_images)
     
	def load_image(self):
		self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
		self.load_angle += 10
		
	 
	def img_rotate(self):
		self.angle += self.angle_step
		self.angle = self.angle % 360
		if self.angle_step != 10:
			self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img
			if not (self.angle % 15):
				self.angle_step = max(0,self.angle_step-1)
			if self.angle_step:
				self.after(self.step,self.img_rotate)
			else:
				self.Button['state'] = 'normal'
				print(self.angle)
		else:
			if self.angle not in self.img_dict:
				self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img_dict[self.angle]
			self.after(self.step,self.img_rotate)
     
	def wheel_stop(self,event=None):
		self.angle_step = 5


class Application_Gui(tk.Canvas):
	def __init__(self, root):
		tk.Canvas.__init__(self, root, highlightthickness=0)
		canvas_width = 50
		canvas_height =50
		python_green = "black"
		w = tk.Canvas(root,  width=canvas_width, height=canvas_height,highlightthickness=0)
		w.pack()
		points = [0,25,canvas_width,canvas_height/2, 25, canvas_height]
		w.create_polygon(points, outline=python_green, 
			fill='black', width=3)
		
def main():
	root = tk.Tk()
	root.title('WHEEL OF FORTUNE')
	application_gui = Application_Gui(root)
	application_gui.pack()
	root.geometry("1200x815+0+0")
	root.mainloop()
	
if __name__ == '__main__':
	main()
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:@Alfons Mittelmeyer könntest du nochmal schauen, so stelle ich es mir vor, ganz oben der Pfeil der zeigt wo es anhält vielleicht kann man das auch mit label anstatt canvas hin bekommen ich weiss es leider nicht,
Nein, mit Label geht es nicht, denn Widgets kann man in tkinter nicht durchsichtig machen. Das Image und der Pfeil müssen daher in den selben Canvas.

Du wolltest noch Label anbringen? OK dies zeigt, wie das geht. Nimm einfach ein Grid Layout. Den Pfeil mußt Du selber richtig positionieren. Die x Koordinate sollte für dieses Glücksrad stimmen. Die y Koordinate mußt Du selber anpassen:

Code: Alles auswählen

# -*- coding: utf-8 -*-

try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
from PIL import Image,ImageTk
from random import random


# === general grid table definition =================
def grid_general_rows(container,rows,**kwargs):
    for row in range(rows):
        container.rowconfigure(row,**kwargs)

def grid_general_cols(container,columns,**kwargs):
    for column in range(columns):
        container.columnconfigure(column,**kwargs)


class Application(tk.Tk):

    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # general grid definition ==============================
        grid_general_rows(self,12, minsize = 37, pad = 0, weight = 0)
        grid_general_cols(self,3, minsize = 100, pad = 0, weight = 0)
        # widget definitions ===================================
        self.label1 = tk.Label(self,text='label1')
        self.label1.grid(row=0, sticky='nesw')
        self.label2 = tk.Label(self,text='label2')
        self.label2.grid(row=1, sticky='nesw')
        self.label3 = tk.Label(self,text='label3')
        self.label3.grid(row=2, sticky='nesw')
        self.label4 = tk.Label(self,text='label4')
        self.label4.grid(row=3, sticky='nesw')
        self.label5 = tk.Label(self,text='label5')
        self.label5.grid(row=4, sticky='nesw')
        self.label6 = tk.Label(self,text='label6')
        self.label6.grid(row=5, sticky='nesw')
        self.label7 = tk.Label(self,text='label7')
        self.label7.grid(row=6, sticky='nesw')
        self.label8 = tk.Label(self,text='label8')
        self.label8.grid(row=7, sticky='nesw')
        self.button = tk.Button(self,font='{Helvetica bold} 80', text='START')
        self.button.grid(row=11, columnspan=3, sticky='nesw')
        self.label9 = tk.Label(self,text='label9')
        self.label9.grid(row=10)
        self.label10 = tk.Label(self,text='label10')
        self.label10.grid(row=10, column=2)
        self.Wheel_of_Fortune = tk.Label(self,text='Wheel of Fortune', font='TkDefaultFont 32 {bold }')
        self.Wheel_of_Fortune.grid(row=0, column=1)

        self.canvas = Canvas_1(self)
        self.canvas.grid(row=1, sticky='nesw', column=1, rowspan=10)


        self.label_pil_img = Image.open('fortune.png')
        self.canvas.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
       
        ### hier mit starten mit space taste
        self.button.bind('<space>',self.start_rotate)
        self.button['command']=self.start_rotate
        ### nach 5 secunden stoppen von alleine oder eine andere zeit muss ich erst sehen ob 5 zu kurz oder zu lang
 
        self.load_image()
        self.canvas.itemconfig('wheel',image= self.img_dict[0])

        self.load_images()
       
 
    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)
 
    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)
 
 
    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10
 
    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img)
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img_dict[self.angle])
            self.after(self.step,self.img_rotate)
 
    def wheel_stop(self,event=None):
        self.angle_step = 5
       
    ## die grösse möchte ich vom Fenster definieren so wie farbe etc

class Canvas_1(tk.Canvas):

    def __init__(self,master,**kwargs):
        tk.Canvas.__init__(self,master,**kwargs)
        self.config(height='550', width='500')
        # widget definitions ===================================
        coords = (252,274)
        item_wheel = self.create_image(*coords)
        self.image_1 = ImageTk.PhotoImage(Image.open('fortune.png'))
        self.itemconfig(item_wheel,image = self.image_1,tags='wheel')

        canvas_width = 50
        canvas_height =25
        python_green = "black"
        x = 225
        y = 25

        points = [x,y,x+canvas_width,y, x+canvas_width/2, y+canvas_height]
        self.create_polygon(points, outline=python_green,
            fill='black', width=3)


        #coords = (188,3,316,125)
        #item = self.create_arc(*coords)
        #self.itemconfig(item,start = '75.0',extent = '30.0',fill = 'orange',width = '3.0')

if __name__ == '__main__':
    Application().mainloop()
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

@Alfons Mittelmeyer Vielen Vielen Dank für die ganzen Beispiele , bin jetzt verwirrt :( , der Pfeil soll nicht in das Bild rein , es soll einfach oben sein als erstes, ich nehme dein Beispiel das ist am nächsten meine Vorstellung da muß ich dann versuchen oben den Pfeil hinzubekommen und die Größe vom Fenster ändern und bg da mein Bild eckig ist und das vielleicht in ein Frame packen, da sind jetzt viele Beispiele,
Vielen Dank du hast dir wirklich mühe gegeben, aber das Beispiel mit Anpassungen ist für mich gut, Größe Farbe Frame

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
     
try:
	import tkinter as tk
except ImportError:
	import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random
class Application(tk.Tk):
	
	def __init__(self,**kwargs):
		tk.Tk.__init__(self,**kwargs)
		# widget definitions ===================================
		
		self.label_pil_img = Image.open('Gluecksrad_750.png')
		
		self.label = tk.Label(self)
		self.label.bind('<space>',self.start_rotate)
		self.bind('<space>',self.start_rotate)
		self.label.pack(expand=1,fill='both')
		self.angle=0
		self.img_dict = {}
		self.angle_step = 0
		self.load_angle = 0
		self.step = 20
           
		self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
		self.Button.pack()
		self.Button.bind('<space>',self.start_rotate)
     
		self.load_image()
		self.label['image'] = self.img_dict[0]
		self.load_images()
           
     
	def start_rotate(self,event=None):
		if not self.angle_step:
			self.angle_step = 10
			self.angle = self.angle// 10 * 10
			self.img_rotate()
			self.Button['state'] = 'disabled'
			self.after(int(4500+random()*1000),self.wheel_stop)
     
	def load_images(self):
		if self.load_angle < 360:
			self.load_image()
			self.after(1,self.load_images)
     
     
	def load_image(self):
		self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
		self.load_angle += 10
     
	def img_rotate(self):
		self.angle += self.angle_step
		self.angle = self.angle % 360
		if self.angle_step != 10:
			self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img
			if not (self.angle % 15):
				self.angle_step = max(0,self.angle_step-1)
			if self.angle_step:
				self.after(self.step,self.img_rotate)
			else:
				self.Button['state'] = 'normal'
				print(self.angle)
		else:
			if self.angle not in self.img_dict:
				self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img_dict[self.angle]
			self.after(self.step,self.img_rotate)
     
	def wheel_stop(self,event=None):
		self.angle_step = 5
     
if __name__ == '__main__':
	Application().mainloop()
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:@Alfons Mittelmeyer Vielen Vielen Dank für die ganzen Beispiele , bin jetzt verwirrt :( , der Pfeil soll nicht in das Bild rein , es soll einfach oben sein als erstes, ich nehme dein Beispiel das ist am nächsten meine Vorstellung da muß ich dann versuchen oben den Pfeil hinzubekommen und die Größe vom Fenster ändern und bg da mein Bild eckig ist und das vielleicht in ein Frame packen.
Also, wenn der Pfeil nicht in das Bild reinragen soll, dann brauchst Du auch nicht beides in einem Canvas haben. Dann kannst Du auch einen Label für das sich drehende Rad nehmen. Und wenn Du den Pfeil nicht zeichnest, sondern auch ein Image dafür hast, dann geht auch dafür ein Label. Dann sollte man natürlich das Rad und den Pfeil zusammen in einem Frame haben, weil Rad und Pfeil ja irgendwie vom Sinn her zusammengehören und man bei einer späteren Umstellung nicht aufpassen muss, dass ja auch wirklich der Pfeil wieder üder dem Rad ist.

Also lass Deinen canvas mit dem Pfeil wie er ist und positioniere das einfach über dem Bild. Und das kannst Du auch in einen Label tun.
Ich hatte zuerst gedacht, der Pfeil sollte reinragen, hatte ich eben falsch gedacht.

Wenn Du das in einen Canvas mit dem Pfeil und einen Label für das Image trennst ist das auch besser. Denn wenn Du etwa ein Bild von anderer Größe nimmst, dann paßt sich die Canvasposition an und der Pfeil ist auch dann in der Mitte.
Benutzeravatar
wuf
User
Beiträge: 1529
Registriert: Sonntag 8. Juni 2003, 09:50

Hi ganja

Hier dein Skript mit Marke:

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*

# viewtopic.php?p=313393#p313393
     
try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random

MARK_WIDTH = 50
MARK_HEIGHT = MARK_WIDTH
MARK_COLOR = 'gray70'
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT), (0, 0)]       


class Application(tk.Tk):
   
    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================

        self.cv_mark = tk.Canvas(self, width=MARK_WIDTH, height=MARK_HEIGHT)
        self.cv_mark.pack(pady=2)
        self.cv_mark.create_polygon(POLYGON_POINTS, fill=MARK_COLOR,
            tag='mark')
 
        self.label_pil_img = Image.open('wheel_of_fortune.png')
       
        self.label = tk.Label(self)
        self.label.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.label.pack(expand=1,fill='both')
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
           
        self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
        self.Button.pack()
        self.Button.bind('<space>',self.start_rotate)
     
        self.load_image()
        self.label['image'] = self.img_dict[0]
        self.load_images()
           
     
    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.Button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)
     
    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)
     
     
    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10
     
    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.Button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img_dict[self.angle]
            self.after(self.step,self.img_rotate)
     
    def wheel_stop(self,event=None):
        self.angle_step = 5
     
if __name__ == '__main__':
    Application().mainloop()

Gruss wuf :wink:
Take it easy Mates!
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

wuf hat geschrieben:Hi ganja

Hier dein Skript mit Marke:
Hi wuf, das sind ja keine Linien, sondern ist ein Polygon. Da ist dann aber Dein letzter Punkt zuviel:

statt:
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT), (0, 0)]

ist es:
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT)]

Naja, sehen tut man das natürlich nicht
Zuletzt geändert von Alfons Mittelmeyer am Donnerstag 10. August 2017, 13:28, insgesamt 1-mal geändert.
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

hallo @wuf Danke ich habe es auch hinbekommen aber nicht so wie du, als nächstes versuche ich es in frame zu packen und meine funktion stop_check mit den wickeln passt noch nicht ganz bei einem Bild mit 8 teilen

Danke

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
     
try:
	import tkinter as tk
except ImportError:
	import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random
class Application(tk.Tk):
	
	def __init__(self,**kwargs):
		tk.Tk.__init__(self,**kwargs)
		# widget definitions ===================================
		self.configure(background = 'grey')
		
		canvas_width = 50
		canvas_height =50
		python_green = "black"
		w = tk.Canvas(self,bg="grey", width=canvas_width, height=canvas_height,highlightthickness=0)
		w.pack()
		points = [0,25,canvas_width,canvas_height/2, 25, canvas_height]
		w.create_polygon(points, outline=python_green, 
			fill='black', width=3)
		
		self.label_pil_img = Image.open('Gluecksrad_750_2.png')
		
		self.label = tk.Label(self, bg='grey')
		self.label.bind('<space>',self.start_rotate)
		self.bind('<space>',self.start_rotate)
		self.label.pack(expand=1,fill='both')
		self.angle=0
		self.img_dict = {}
		self.angle_step = 0
		self.load_angle = 0
		self.step = 20
           
		self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
		self.Button.pack()
		self.Button.bind('<space>',self.start_rotate)
     
		self.load_image()
		self.label['image'] = self.img_dict[0]
		self.load_images()
           
     
	def start_rotate(self,event=None):
		if not self.angle_step:
			self.angle_step = 10
			self.angle = self.angle// 10 * 10
			self.img_rotate()
			self.Button['state'] = 'disabled'
			self.after(int(4500+random()*1000),self.wheel_stop)
     
	def load_images(self):
		if self.load_angle < 360:
			self.load_image()
			self.after(1,self.load_images)
     
     
	def load_image(self):
		self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
		self.load_angle += 10
     
	def img_rotate(self):
		self.angle += self.angle_step
		self.angle = self.angle % 360
		if self.angle_step != 10:
			self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img
			if not (self.angle % 15):
				self.angle_step = max(0,self.angle_step-1)
			if self.angle_step:
				self.after(self.step,self.img_rotate)
			else:
				self.Button['state'] = 'normal'
				print(self.angle)
				self.stop_check()
		else:
			if self.angle not in self.img_dict:
				self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img_dict[self.angle]
			self.after(self.step,self.img_rotate)
     
	def wheel_stop(self,event=None):
		self.angle_step = 5
	
	def stop_check(self):
		if  0 <= self.angle <= 45:
			print ("ja")
		elif  135 <= self.angle <= 180:
			print ("gewonnen ja")
		elif  225 <= self.angle <= 270:
			print ("gewonnen ja")
		elif  315 <= self.angle <= 360:
			print ("gewonnen ja")
		else:
			print ("jetzt nicht")
		
     
if __name__ == '__main__':
	Application().mainloop()
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:hallo @wuf Danke ich habe es auch hinbekommen aber nicht so wie du, als nächstes versuche ich es in frame zu packen und meine funktion stop_check mit den wickeln passt noch nicht ganz bei einem Bild mit 8 teilen

Code: Alles auswählen

	def stop_check(self):
		if  0 <= self.angle <= 45:
			print ("ja")
		elif  135 <= self.angle <= 180:
			print ("gewonnen ja")
		elif  225 <= self.angle <= 270:
			print ("gewonnen ja")
		elif  315 <= self.angle <= 360:
			print ("gewonnen ja")
		else:
			print ("jetzt nicht")
		
     
if __name__ == '__main__':
	Application().mainloop()
Du meinst wohl mit den Winkeln. Das paßt wirklich nicht. Mein Programm liefert 15 er Schritte drei davon gehören bei Dir dann zusammen.

if 0 <= self.angle <= 45

Das wären ja 5 Teile, oder sind bei Dir die Abschnitte unterschiedlich groß?

345,0,15 wäre ein zusammengehöriger Abschnitt, wenn die Abschnitte gleich groß wären.
Zuletzt geändert von Alfons Mittelmeyer am Donnerstag 10. August 2017, 13:44, insgesamt 1-mal geändert.
Benutzeravatar
wuf
User
Beiträge: 1529
Registriert: Sonntag 8. Juni 2003, 09:50

Alfons hat geschrieben:Hi wuf, das sind ja keine Linien, sondern ist ein Polygon. Da ist dann aber Dein letzter Punkt zuviel:

statt:
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT), (0, 0)]

ist es:
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT)]

Naja, sehen tut man das natürlich nicht
Danke für deinen Hinweis. Tcl hatte scheinbar keine Mühe damit :wink:

Hi ganja

Hier dein Skript mit Frame:

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
     
try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random

APP_TITLE = "Wheel of Fortune"
APP_XPOS = 100
APP_YPOS = 100

MARK_WIDTH = 50
MARK_HEIGHT = MARK_WIDTH
MARK_COLOR = 'gray70'
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT)]       


class Application(tk.Frame):
      
    def __init__(self, parent, **kwargs):
        self.parent = parent
        
        tk.Frame.__init__(self, parent ,**kwargs)
        # widget definitions ===================================

        self.cv_mark = tk.Canvas(self, width=MARK_WIDTH, height=MARK_HEIGHT)
        self.cv_mark.pack(pady=2)
        self.cv_mark.create_polygon(POLYGON_POINTS, fill=MARK_COLOR,
            tag='mark')
 
        self.label_pil_img = Image.open('wheel_of_fortune.png')
       
        self.label = tk.Label(self)
        self.label.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.label.pack(expand=1,fill='both')
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
           
        self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
        self.Button.pack()
        self.Button.bind('<space>',self.start_rotate)
     
        self.load_image()
        self.label['image'] = self.img_dict[0]
        self.load_images()
           
     
    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.Button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)
     
    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)
     
     
    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10
     
    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.Button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img_dict[self.angle]
            self.after(self.step,self.img_rotate)
     
    def wheel_stop(self,event=None):
        self.angle_step = 5


def main():
    app_win = tk.Tk()
    app_win.title(APP_TITLE)
    app_win.geometry("+{}+{}".format(APP_XPOS, APP_YPOS))
    app_win.option_add("*highlightThickness", 0)
    app = Application(app_win).pack(fill='both', expand=True, padx=6, pady=6)
    
    app_win.mainloop()
 
 
if __name__ == '__main__':
    main()      
Gruss wuf :wink:
Take it easy Mates!
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

wuf hat geschrieben:Danke für deinen Hinweis. Tcl hatte scheinbar keine Mühe damit :wink:
Naja, ein Viereck, bei dem die letzte Seite die Länge 0 hat ist optisch ja auch ein Dreieck.
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

hi, toll super gemacht,@Alfons Mittelmeyer hier das Bild(wird noch schön gemacht, jetzt nur zum testen), das mit den abschnitten ist noch nicht ganz klar

"@Alfons Mittelmeyer Du meinst wohl mit den Winkeln. Das paßt wirklich nicht. Mein Programm liefert 15 er Schritte drei davon gehören bei Dir dann zusammen.
if 0 <= self.angle <= 45
Das wären ja 5 Teile, oder sind bei Dir die Abschnitte unterschiedlich groß?
345,0,15 wäre ein zusammengehöriger Abschnitt, wenn die Abschnitte gleich groß wären."

Bild
Benutzeravatar
wuf
User
Beiträge: 1529
Registriert: Sonntag 8. Juni 2003, 09:50

Hi ganja

Bei mir ergibt 8 mal 45 Grad 360 Grad. Hier das Skript für ein 8 x 45 Grad Rad:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from functools import partial
from random import randint, uniform

try:
    import Tkinter as tk
except ImportError:
    import tkinter as tk

from PIL import Image,ImageTk

APP_TITLE = "The Wheel of Fortune"
APP_XPOS = 100
APP_YPOS = 100
APP_WIDTH = 300
APP_HEIGHT = 200

TEXT_FONT = ('Helvetica', 20, 'bold')
TEXT_FG = 'gray'

IMG_WHEEL_OF_FORTUNE = 'wheel_of_fortune_02.png'
NUM_OF_FIELDS = 8
STEP_SIZE = 360 / NUM_OF_FIELDS
MARK_WIDTH = 40
MARK_HEIGHT = MARK_WIDTH
MARK_COLOR = 'gray70'
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT), (0, 0)]


class Application(tk.Frame):

    def __init__(self, master):
        self.master = master
        self.master.protocol("WM_DELETE_WINDOW", self.close)
        tk.Frame.__init__(self, master)
        
        self.wheel_pos = 0
        
        self.cv_mark = tk.Canvas(self, width=50, height=50)
        self.cv_mark.pack(pady=2)
        self.cv_mark.create_polygon(POLYGON_POINTS, fill=MARK_COLOR,
            tag='mark')
            
        self.wheel = tk.Label(self)
        self.wheel.pack(expand=True, fill='both')

        self.start_button = tk.Button(self, relief='flat', font=TEXT_FONT, 
            fg=TEXT_FG, activebackground=self['bg'], text='Push the wheel',
            bd=0, activeforeground='green', command=self.run)
        self.start_button.pack(pady=5)
        
        self.wheel_pil_img = Image.open(IMG_WHEEL_OF_FORTUNE)
        self.wheel_tk_img = ImageTk.PhotoImage(self.wheel_pil_img)
        self.wheel['image'] = self.wheel_tk_img
        
        self.run_flag = False
        self.seed = 0.0
        
    def run(self):
        if not self.run_flag:
            self.run_flag = True
            self.seed = uniform(0.05, 0.15)
            self.focus_set()
            self.cv_mark.itemconfigure('mark', fill=self['bg'])
            self.start_button['fg'] = 'red'
            self.start_button['activeforeground'] = 'red'
            self.rotate_wheel()

    def rotate_wheel(self, tmcol=5.0, time_step=5):
        tmcol += float(time_step) * self.seed
        time_step = int(tmcol)

        if time_step > 500: 
            self.run_flag = False
            self.cv_mark.itemconfigure('mark', fill=MARK_COLOR)
            self.start_button['fg'] = TEXT_FG
            self.start_button['activeforeground'] = 'green'
            return
            
        self.wheel_tk_img = ImageTk.PhotoImage(self.wheel_pil_img.rotate(
            self.set_wheel_pos()))
        self.wheel['image'] = self.wheel_tk_img
        
        self.after(time_step, self.rotate_wheel, tmcol, time_step)

    def set_wheel_pos(self):
        self.wheel_pos -= STEP_SIZE
        if self.wheel_pos == 360: self.wheel_pos = 0
        return self.wheel_pos
            
    def close(self):
        print("Application-Shutdown")
        self.master.destroy()

        
def main():
    app_win = tk.Tk()
    app_win.title(APP_TITLE)
    app_win.geometry("+{}+{}".format(APP_XPOS, APP_YPOS))
    app_win.option_add("*highlightThickness", 0)
    app = Application(app_win).pack(fill='both', expand=True, padx=6, pady=6)
    
    app_win.mainloop()
 
 
if __name__ == '__main__':
    main()      
Gruss wuf :wink:
Take it easy Mates!
Antworten