Výběr pixelu klikem v zoomované oblasti [prohlížeč obrázku] – Python – Fórum – Programujte.com

Dobrý den, požádal jsem chatGPT o vytvoření programu python, kde vyberu obrázek a chci přiblížit vybranou oblast, poté kliknu na pixel a poté získám barvu RGB/HSV. Vytvořilo to všechno dobře, kromě jednoho problému. Nově vytvořené okno Figure 2 nekopíruje obrázek z Figure 1 (původní okno Zoom). Zdá se, že z Figure 1 nelze vybrat barvu, na Figure 1 tak vznikne Figure 2. Ale jak již bylo řečeno, obrázek 2 neobsahuje obrázek z Figure 2. A také pokud tam musí být Figure 2, pak měl by zakrývat Figure 1 a být nahoře, aby se zajistilo, že uživatel nemůže přepnout na Figure 1 náhodou a zmást okna. Může to prosím někdo opravit?

import cv2 # pip install opencv-python-headless
import matplotlib.pyplot as plt # pip install matplotlib
from matplotlib.patches import Rectangle
from tkinter import Tk, Canvas, PhotoImage, filedialog
import configparser
from ttkthemes import ThemedTk

class ImageAnalyzer:
    def __init__(self):
        self.selected_area = (0, 0, 0, 0)
        self.large_image = None
        self.fig = None

    def load_image(self):
        try:
            filename = self.load_filename()
        except KeyError:
            root = ThemedTk(theme="equilux")
            filename = filedialog.askopenfilename()
            self.save_filename(filename)
            root.destroy()

        self.large_image = cv2.imread(filename)
        self.large_image = cv2.cvtColor(self.large_image, cv2.COLOR_BGR2RGB)
        self.fig, ax = plt.subplots()
        ax.imshow(self.large_image)
        ax.set_title('Select an area to zoom in')
        self.cid = self.fig.canvas.mpl_connect('button_press_event', self.select_area)
        plt.show()

    def save_filename(self, filename):
        config = configparser.ConfigParser()
        config['DEFAULT'] = {'filename': filename}
        with open('config.cfg', 'w') as configfile:
            config.write(configfile)

    def load_filename(self):
        config = configparser.ConfigParser()
        config.read('config.cfg')
        return config['DEFAULT']['filename']

    def select_area(self, event):
        self.selected_area = (int(event.xdata), int(event.ydata), 0, 0)
        self.fig.canvas.mpl_disconnect(self.cid)
        fig, ax = plt.subplots()
        ax.imshow(self.large_image[self.selected_area[1]:, self.selected_area[0]:])
        ax.set_title('Click to select pixel')
        self.cid = fig.canvas.mpl_connect('button_press_event', self.pick_color)
        plt.show()

    def pick_color(self, event):
        x, y = int(event.xdata), int(event.ydata)
        pixel_color = cv2.cvtColor(self.large_image[y:y+1, x:x+1], cv2.COLOR_BGR2RGB)[0,0]
        print("RGB:", pixel_color)
        hsl_color = cv2.cvtColor(self.large_image[y:y+1, x:x+1], cv2.COLOR_BGR2HLS)[0,0]
        print("HSL:", hsl_color)

    def run(self):
        self.load_image()

if __name__ == "__main__":
    analyzer = ImageAnalyzer()
    analyzer.run()

Update kodu. Potřeboval bych zjistit jak počkat na to až se otevře okno té zoomované oblasti. Poté co je Figure 2 otevřen a obrázek zoomované oblasti je načtený uvnitř musím spustit do_job()

import cv2 # pip install opencv-python-headless
import matplotlib.pyplot as plt # pip install matplotlib
from matplotlib.patches import Rectangle
from tkinter import Tk, Canvas, PhotoImage, filedialog
import configparser
from ttkthemes import ThemedTk, ThemedStyle

class ImageAnalyzer:
    def __init__(self):
        self.click_1 = (0, 0)
        self.click_2 = (0, 0)
        self.selected_area = (0, 0, 0, 0)
        self.large_image = None
        self.fig = None
        self.zoom_on = False

    def load_image(self):
        try:
            filename = self.load_filename()
        except KeyError:
            root = ThemedTk(theme="black")
            filename = filedialog.askopenfilename()
            self.save_filename(filename)
            root.destroy()

        self.large_image = cv2.imread(filename)
        self.large_image = cv2.cvtColor(self.large_image, cv2.COLOR_BGR2RGB)
        self.fig, ax = plt.subplots()
        tools = self.fig.canvas.toolbar.children
        # přiřazení k tlačítku zoom závisí na identifikátoru - Zoom je checkbutton
        tools['!checkbutton2'].bind('<Button-1>', self.zoom_switch)
        
        ax.invert_yaxis()
        ax.imshow(self.large_image)
        ax.set_title('Select an area to zoom in')
        self.cid_pressed = self.fig.canvas.mpl_connect('button_press_event', self.pressed)
        self.cid_released = self.fig.canvas.mpl_connect('button_release_event', self.released)
        plt.show()

    def save_filename(self, filename):
        config = configparser.ConfigParser()
        config['DEFAULT'] = {'filename': filename}
        with open('config.cfg', 'w') as configfile:
            config.write(configfile)

    def load_filename(self):
        config = configparser.ConfigParser()
        config.read('config.cfg')
        return config['DEFAULT']['filename']

    def zoom_switch(self, event):
        if self.zoom_on == False:
            self.zoom_on = True
        else:
            self.zoom_on = False
    
    def pressed(self, event):
        if not self.zoom_on:
            self.click_1 = (0, 0)
            self.click_2 = (0, 0)
            return 
        self.click_1 = (int(event.xdata), int(event.ydata))
        self.fig.canvas.mpl_disconnect(self.cid_pressed)
    
    def released(self, event):
        if not self.zoom_on:
            return 
        self.click_2 = (int(event.xdata), int(event.ydata))
        self.fig.canvas.mpl_disconnect(self.cid_released)
    
    def do_job(self, event):
        fig, ax = plt.subplots()
        ax.imshow(self.large_image[self.selected_area[1]:, self.selected_area[0]:])
        ax.set_title('Click to select pixel')
        self.cid = fig.canvas.mpl_connect('button_press_event', self.pick_color)
        plt.show()

    def pick_color(self, event):
        x, y = int(event.xdata), int(event.ydata)
        pixel_color = cv2.cvtColor(self.large_image[y:y+1, x:x+1], cv2.COLOR_BGR2RGB)[0,0]
        print("RGB:", pixel_color)
        hsl_color = cv2.cvtColor(self.large_image[y:y+1, x:x+1], cv2.COLOR_BGR2HLS)[0,0]
        print("HSL:", hsl_color)

    def run(self):
        self.load_image()

if __name__ == "__main__":
    analyzer = ImageAnalyzer()
    analyzer.run()

Tak já nevím co s tím ChatGPT píše toto

Chápu, co myslíte. Chcete získat přístup k datům zobrazovaným v přiblížené oblasti, která je vybrána pomocí zoomu, což je část originálního obrázku self.large_image, která je zobrazena v bboxu.

Když používáte matplotlib k provádění zoomu, určitá část originálního obrázku je zobrazena v bboxu. Ačkoli toto zobrazení není přímo přístupné pomocí objektu self.large_image, můžete získat transformované souřadnice této oblasti a poté vypočítat, která část originálního obrázku je zobrazena.

Zde je, jak byste mohl upravit váš kód pro získání barevných informací z pixelu v přiblížené oblasti:

def pick_color(self, event):
    if self.large_image is None:
        print("No image loaded.")
        return
    
    # Získání transformovaných souřadnic kliknutí na obrázek
    x, y = int(event.xdata), int(event.ydata)
    
    # Získání transformovaných souřadnic bboxu
    bbox = self.fig.bbox
    bbox_x0, bbox_y0, bbox_x1, bbox_y1 = bbox.x0, bbox.y0, bbox.x1, bbox.y1
    
    # Vypočtení transformovaných souřadnic kliknutí relativně vůči bboxu
    x_relative = (x - bbox_x0) / (bbox_x1 - bbox_x0)
    y_relative = (y - bbox_y0) / (bbox_y1 - bbox_y0)
    
    # Získání velikosti originálního obrázku
    original_width, original_height, _ = self.large_image.shape
    
    # Vypočtení souřadnic kliknutí v rámci originálního obrázku
    x_original = int(x_relative * original_width)
    y_original = int(y_relative * original_height)
    
    # Získání barevných informací z odpovídajícího pixelu v originálním obrázku
    pixel_color = self.large_image[y_original, x_original]
    print("Pixel color in zoomed area:", pixel_color)

Ale proč bych měl počítat to co už mám zobrazené v tom okně? Takže například posílám zazoomovanou část toho obrázku co vidím po zazoomovaní a k tomu se potřebuju dostat

Připojen obrázek.

Tímto způsobem získáte barvu pixelu v přiblížené oblasti, která je zobrazena v bboxu, a to pomocí transformovaných souřadnic kliknutí na obrázek a vztahů mezi velikostí bboxu a originálním obrázkem.

Všude tam přistupuješ k tomu "large_image". Když v tom zoomu máš jen jeho výřez, tak souřadnice relativní k tomu výřezu musíš přepočítat na "globální" souřádnice v tom large_image.

Asi půjde získat data přímo z toho plotu, nebo si ulož ten výřez co v něm zobrazuješ a ber data z něj.

#4 gna

Sice nevím co jsou globální souřadnice, popřemýšlím...

Já si toho vůbec nevšiml, že v tom obrázku jsou vidět vyříznuté osy. A to je klíč. Tak jsem se zeptal ChatGPT jak získat hranice těch os, a získal jsem správné hodnoty. Takže je to jen o tom přepočtu.

Nejprve

def released(self, event):
        if not self.zoom_on:
            return 
        x_min, x_max = plt.xlim()
        y_min, y_max = plt.ylim()
        self.click_2 = (int(event.xdata), int(event.ydata))
        self.fig.canvas.mpl_disconnect(self.cid_released)

a pak výpočet. Jinak díky že si zareagoval jako jediný. Taky si říkám, oni by měli mít někde nějakou globální proměnnou _zoom nebo tak něco, kde by byl příznak jestli to tlačítko bylo vybrané, když je to v tools.

self.fig, ax = plt.subplots()
tools = self.fig.canvas.toolbar.children
# přiřazení k tlačítku zoom závisí na identifikátoru - Zoom je checkbutton
tools['!checkbutton2'].bind('<Button-1>', self.zoom_switch)

Možná mají i něco jednoduššího než na co jsem přišel já. A dělám to zbytečně bych to tipnul. Jenže v jejich manuálu a příkladech já se v tom nevyznám. Už jsem viděl lepší manuály jako třeba když jsem se učil PHP (tak od roku 2002/2003) tak tam bylo vše skvěle vysvětlené na příkladech.

Mám to skoro hotové akorád převést ty souřadnice kliknutí ze zoomu na celý obrázek (absolutně).

import cv2 # pip install opencv-python-headless
import matplotlib.pyplot as plt # pip install matplotlib - "The pyplot module provides functions for explicitly creating figures that include interactive tools, a toolbar, a tool-tip, and key bindings"
from matplotlib.patches import Rectangle
from tkinter import Tk, Canvas, PhotoImage, filedialog
import configparser
from ttkthemes import ThemedTk, ThemedStyle
import math, time

class ImageAnalyzer:
    def __init__(self):
        self.click_1 = (0, 0)
        self.click_2 = (0, 0)
        self.selected_area = (0, 0, 0, 0)
        self.dx=0 # rozdíl limitů na ose x: x_max-x_min 
        self.dy=0 # rozdíl limitů na ose y: y_max-y_min
        self.large_image = None
        self.fig = None
        self.zoom_on = False
        self.zoom_finished = False # Označuje že byly získány informace o vybrané části obrazu v Zoomu
        self.origin = None

    def load_image(self):
        try:
            filename = self.load_filename()
        except KeyError:
            root = ThemedTk(theme="black")
            filename = filedialog.askopenfilename()
            self.save_filename(filename)
            root.destroy()

        self.large_image = cv2.imread(filename)
        self.dy, self.dx, _ = self.large_image.shape
        # origin odkazuje na levý horní roh obrazu, resp. vybrané sekce
        self.origin = {'x': 0, 'y': 0}
        self.large_image = cv2.cvtColor(self.large_image, cv2.COLOR_BGR2RGB)
        self.fig, ax = plt.subplots()
        tools = self.fig.canvas.toolbar.children
        # přiřazení k tlačítku zoom závisí na identifikátoru - Zoom je checkbutton
        tools['!checkbutton2'].bind('<Button-1>', self.zoom_switch)
        
        ax.invert_yaxis()
        ax.imshow(self.large_image)
        ax.set_title('Select an area to zoom in')
        self.cid_pressed = self.fig.canvas.mpl_connect('button_press_event', self.pressed)
        self.cid_released = self.fig.canvas.mpl_connect('button_release_event', self.released)
        plt.show()

    def save_filename(self, filename):
        config = configparser.ConfigParser()
        config['DEFAULT'] = {'filename': filename}
        with open('config.cfg', 'w') as configfile:
            config.write(configfile)

    def load_filename(self):
        config = configparser.ConfigParser()
        config.read('config.cfg')
        return config['DEFAULT']['filename']

    def zoom_switch(self, event):
        if self.zoom_on == False:
            self.zoom_on = True
        else:
            self.zoom_on = False
    
    def pressed(self, event):
        if self.zoom_finished:            
            self.xy = (int(event.xdata), int(event.ydata))
            bbox = self.fig.bbox
            x = self.origin['x']-self.xy[0]
            y = self.origin['y']-self.xy[1]
            print("TEST")
            
        else:
            if not self.zoom_on:
                self.click_1 = (0, 0)
                self.click_2 = (0, 0)
                self.zoom_finished = False
                return 
       # self.zoom_finished = False
        # self.click_1 = (int(event.xdata), int(event.ydata))
       # self.fig.canvas.mpl_disconnect(self.cid_pressed)

    def released(self, event):
        if not self.zoom_on:
            return 
        x_min, x_max = plt.xlim()
        y_min, y_max = plt.ylim()
        self.origin = {'x':math.ceil(x_min), 'y': math.ceil(y_min)}
        self.dx=math.ceil(x_max)-self.origin['x']
        self.dy=math.ceil(y_max)-self.origin['y']


        self.zoom_finished = True
        # self.click_1 a self.click_2 je tu jen na okrasu
        # self.click_2 = (int(event.xdata), int(event.ydata))
        # self.fig.canvas.mpl_disconnect(self.cid_released)
    
    def do_job(self, event):
        fig, ax = plt.subplots()
        ax.imshow(self.large_image[self.selected_area[1]:, self.selected_area[0]:])
        ax.set_title('Click to select pixel')
        self.cid = fig.canvas.mpl_connect('button_press_event', self.pick_color)
        plt.show()

    def pick_color(self, event):
        x, y = int(event.xdata), int(event.ydata)
        pixel_color = cv2.cvtColor(self.large_image[y:y+1, x:x+1], cv2.COLOR_BGR2RGB)[0,0]
        print("RGB:", pixel_color)
        hsl_color = cv2.cvtColor(self.large_image[y:y+1, x:x+1], cv2.COLOR_BGR2HLS)[0,0]
        print("HSL:", hsl_color)

    def run(self):
        self.load_image()

if __name__ == "__main__":
    analyzer = ImageAnalyzer()
    analyzer.run()

To není program, to je zmastěný kód. Kdo myslíš, že se tím bude po tobě zabývat? A ty sám, za rok dva nebudeš ani tušit co jsi v tom kódu zmastil. Představ si, kdyby takhle programovali třeba Apollo, tak by nedoletěli z Floridy ani na Zbraslav, natož na Měsíc.

http://www.jplabs.co.uk/cz/programovani.html

Představ si, jak za 15-20 let až budou lidi čipovaný čipem s umělou inteligencí budou "programátoři" jako ty dělat apky pro očipovaný lidi. To budou konce, co ... )

#7 remmidemmi

Nevím proč mě odkazujete na tu stránku, to jste si mě s někým spletl. Já nejsem placený programátor a chci výsledek tady a teď. Proto se nervuju s tím ChatGPT, nehodlám to studovat několik měsíců abych nedosáhl ve výsledku něčeho (tedy výsledek žádný). Tenhle přístup na mě nefunguje. ChatGPT sice ničemu nerozumí a generuje neskutečně tupý kód, ale aspoň jsem někde začal a získal jsem ten prohlížeč obrázků se zoomem. Ano, věřím že je to zmaštěný, protože nikdo neměl čas a ochotu mi s tím pomoci. Tečka.

#6 oxidián
Já jsem ten kód jen narychlo proletěl a moc jsem to nezkoumal. Chytil jsem se tohodle: 

def do_job(self, event):
    fig, ax = plt.subplots()
    ax.imshow(self.large_image[self.selected_area[1]:, self.selected_area[0]:])

def pick_color(self, event):
    x, y = int(event.xdata), int(event.ydata)
    pixel_color = cv2.cvtColor(self.large_image[y:y+1, x:x+1], cv2.COLOR_BGR2RGB)[0,0]

A v tom se mi zdá, že by bylo ptřeba ty souřadnice přepočítat, nebo si uložit ten výřez:

def do_job(self, event):
    fig, ax = plt.subplots()
    self.zoomed_image = self.large_image[self.selected_area[1]:, self.selected_area[0]:]
    ax.imshow(self.zoomed_image)

def pick_color(self, event):
    x, y = int(event.xdata), int(event.ydata)
    pixel_color = cv2.cvtColor(self.zoomed_image[y:y+1, x:x+1], cv2.COLOR_BGR2RGB)[0,0]

Ale teď koukám, že se to nikde nevolá a je to jen nějaký pozůstatek nabo halucinace ChatGPT.

Když používáš interní zoom toho matplotu, tak nemusíš řešit jestli je to zazoomované a přepočítavat souřadnice. Xdata a Ydata při tom kliknutí budou absolutní souřadnice.

Vykašlal jsem se na to. Teda ne na tuto aplikaci. Ale na to řešení. Dělám to přes screenshot. Ono to asi jinak nejde.

import pyautogui
'''
pyautogui je třeba k provedení screenshotu.
Pro získání barvy pod kurzorem myší se
nastaví x, y pak se musí odsunout kurzor.
Posun jsem provedl o 1 px protože předpokládám
že kurzor má tvar šipky.
x, y = pyautogui.position()
pyautogui.moveRel(0, 1)
'''

# Když je canvas self.large_image přiblížený pomocí zoomu,
    # a kliknu na místo v obrázku, spouští se self.update_color_patch()
    # ale chci přidat funkci na nastavení barev na tom
    # colorbar self.colorbar.set_clim(min_value, max_value)
    # takže když kliknu na učitou barvu, bude se zobrazovat
    # odstín (hue) té modré barvy. Takže mi stačí rozsah pro ten daný odstín.
    def pressed(self, event):
        if self.zoom_finished:
            x, y = pyautogui.position()
            pyautogui.moveRel(0, 1)
            self.selected_color = pyautogui.pixel(x, y)
            pyautogui.moveRel(0, -1)
            print(self.selected_color)
            self.update_color_patch()

Do obrázku self.large_image který je zobrazený v appce jsem přidal patch, který zobrazuje vybranou barvu.

Ale zkouším ještě jiné řešení viz nové vlákno. Jedná se mi o to, že si vytvořím colorbar tónu (hue) vedle obrázku a když na to kliknu, měl by se zobrazit určitý rozsah té barvy . Ale není to tak lehké, nemohu přijít na to jak se to má nakonfigurovat aby tam byl ten správný gradient.

    def pressed(self, event):
        if self.zoom_finished:
            x, y = pyautogui.position()
            pyautogui.moveRel(0, 1)
            self.selected_color = pyautogui.pixel(x, y)
            pyautogui.moveRel(0, -1)
            print(self.selected_color)
            self.update_color_patch()

            # Aktualizace rozsahu barev colorbaru na základě vybrané barvy

            if self.selected_color:
                r, g, b = self.selected_color[0], self.selected_color[1], self.selected_color[2]
                # Převod RGB na HSL (odstín, sytost, jas)
                h, _, _ = colorsys.rgb_to_hsv(r / 255, g / 255, b / 255)

                # Vypočítání minimálního a maximálního odstínu pro colorbar
                min_hue = max(round((h * 360) - 30), 0)  # Minimální odstín, zaokrouhlený nahoru na 0
                max_hue = min(round((h * 360) + 30), 360)  # Maximální odstín, zaokrouhlený dolů na 360

                # Nastavení požadovaných značek (ticks)
                major_ticks = np.arange(min_hue, max_hue + 1, 30)  # Hlavní značky každých 30 stupňů
                minor_ticks = np.arange(min_hue, max_hue + 1, 10)  # Menší značky každých 10 stupňů
                major_tick_labels = [str(tick) for tick in major_ticks]  # Konverze čísel na řetězce
                self.colorbar.set_ticks(major_ticks)  # Nastavení hlavních značek
                self.colorbar.set_ticks(minor_ticks, minor=True)  # Nastavení menších značek
                self.colorbar.set_ticklabels(major_tick_labels)  # Nastavení popisků k hlavním značkám
                self.fig.canvas.draw_idle()

Je dost možné že to ten ChatGPT hodně kur... strká tam numpy, ale asi to jinak nejde. Chce mě přesvědčit že má existovat nějaká metoda .set_clim aby se nastavil ten gradient. Ale není tam.

 z load_image volám...

self.mapped_image = self.ax.imshow(self.large_image)

Na tom matplotu je pěkné, že poskytuje to zoomování a nemusíš to řešit sám. Ale nevím s čím zápasíš. Máš souřadnice, máš data a můžeš si s tím dělat co chceš :)

import cv2
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
import tkinter as tk


def main():
    root = tk.Tk()

    filename = tk.filedialog.askopenfilename(
        filetypes=(
            ("Images", (".bmp", ".jpg", ".png")),
            ("All files", "*.*"),
        )
    )
    if not filename:
        return
    image = cv2.cvtColor(cv2.imread(filename), cv2.COLOR_BGR2RGB)

    fig, ax = plt.subplots()
    ax.imshow(image)

    fig_canvas = FigureCanvasTkAgg(fig, root)
    fig_canvas.get_tk_widget().pack(expand=True, fill=tk.BOTH)
    fig_toolbar = NavigationToolbar2Tk(fig_canvas, root, pack_toolbar=False)
    fig_toolbar.pack(fill=tk.X)

    pixel_canvas = tk.Canvas(root, width=100, height=50, background="white")
    pixel_canvas.pack()
    pixel_label = tk.Label(root, text="RGB: ---\nHLS: ---")
    pixel_label.pack()
    doit_button = tk.Button(root, text="do stuff")
    doit_button.pack()

    def pick_color(event):
        if event.button != 1 or event.xdata is None:
            return
        x, y = int(event.xdata), int(event.ydata)
        rgb = image[y, x]
        hls = cv2.cvtColor(image[y : y + 1, x : x + 1], cv2.COLOR_RGB2HLS)[0, 0]
        hex_rgb = "#%02X%02X%02X" % tuple(rgb)
        hex_hls = "#%02X%02X%02X" % tuple(hls)
        pixel_canvas.config(background=hex_rgb)
        pixel_label.config(text=f"RGB: {hex_rgb}\nHLS: {hex_hls}")

    def do_stuff():
        print("hello")

    fig_canvas.mpl_connect("button_press_event", pick_color)
    fig_canvas.mpl_connect("motion_notify_event", pick_color)
    doit_button.config(command=do_stuff)

    root.mainloop()


if __name__ == "__main__":
    main()

Připojen obrázek.

Dík tak to jsem netušil že něco takového je možné, tak to se na to musím pořádně podívat.

PS: čím si udělal ten animovaný gif, je na to nějaký soft (např. na linuxu?)

s tím TKinterem ještě neumím, je to pro mě úplná novinka.

Vyjádřím to správně když řeknu že dojde k propojení instance matlab figure s instaní tk canvas?

Se ptám protože si dělám poznámky z toho tvého kódu, abych to správně chápal.

No a ten TK inter a matlablib existuje i pro Delphi? Nevíš? Kdybych to chtěl přepsat do Delphi, tak by mě pak zajímalo zda by to šlo.

Nevím jak přesně je to implementované, ale v principu je to tak. Mimo vlastního okna, matplotlib ještě umožňuje ten plot vložit jako widget do vlastní aplikace a podporuje běžně používané toolkity, tady Tkinter.

Tkinter je GUI toolkit, labely, tlačítka a tak, to v Delphi nemusíš řešit externě. Matplotlib pro Delphi není. Ale Python samotný je snadno embedovatelný a to asi dělají tady: https://blogs.embarcadero.com/how-to-make-powerful-data-visualizations-with-matplotlib/#How_do_I_build_a_Delphi_GUI_for_the_Matplotlib_library

A ten gif jsem udělal jako nahrávku obrazovky/okna do klasického videa a pak až dodatečně zkonvertoval do gifu ffmpegem.

Na tvorbu animovaných GIF existují hejna různých programů, mimo jiné též sharewarů. Stačí požádat strejdu Gůgla.

Problém je jinde a to

1.problém je v chápání co to je ChatGPT.

na webu se praví: ChatGPT is an AI-powered language model developed by OpenAI, capable of generating human-like text based on context and past conversations.

Což je volovina. Předně by se mělo nejprve definovat co to je AI. Už jsem to tu psal v jiném vlákně. Dokud se bude termínem AI označovat kdejaká pitomost, třeba čínské AI-hodinky, které měří puls a vlhkost pokožky a hlási přednastavenými frázemi, že nositel hodinek se má právě teď napít, nebo si ihned vzít prášek na snížení tlaku anebo okamžitě dojít vymočit, pak s takovýmito AI nápady se nikam nedostanete. ChatGPT samozřejmě s AI nemá nic společnýho. ChatGPT je více či méně odfláknutě napsaný software.

2.problém je v přístupu k práci tzv. "programátorů", kteří si pletou programování s kódováním. Dokud tomu tak bude, že rádoby "programátoři" neprogramují, nýbrž mastí do počítače kódy z hlavy a říkají tomu "programování", tak se k cíli nedostanete. 

Někdo umí programovat a někdo jen kecat. Zatím jediný kdo mi s kodem pomohl byl gnu. Netvrdím, že jsem programátor, ale že s pythonem pracuju asi tak tři týdny jako komzument. To že používám IDE na ladění neznamená, že jsem programátor.

PS: Zatím není třeba aby se do diskuse zapojovali další kecalové, mě to co mám stačí na to abych se mohl učit a zkoušet... Kódu mám až až.

#17 oxidián
stále si pleteš základní pojmy a proto máš špatné výsledky. Nejsi programátor, jsi kodér. Kóduješ něco z hlavy, protože nemáš program. Takže jsi takový amatérský mastič kódů. Mastěním kódů z hlavy z tebe nikdy programátor nebude. Nejde o jazyk, který k mastění kódů používáš. Jde o to, že nemáš ten program. Nejdříve si udělej program a pak ten program přepiš pomocí nějakého jazyka do kódů.

Jak jsem psal úvodem, kdyby v NASA místo programování Apolla zmastili kódy z hlavy, tak by jim Apollo doletělo ne na Měsíc, ale nejvýše tak na Zbraslav :)

Představ si situaci za 20 let, to není tak dlouho. Budeš mít implantován čip, třeba v zadku nebo v kebuli. Nějaký tvůj potomek, taky "programátor" bude mět udělat aplikaci, aby jsi lépe myslel. Ten "programátor" zmastí z hlavy nějaký kódy té aplikace a bezdrátově ti upgraduje tvůj čip v zadku nebo v kebuli. Pak zjistí, že nejenže lépe nemyslíš, ale že děláš nežádoucí činnosti. Jak se ti to bude líbit? Asi moc ne, že jo?

Zrovna dneska jsem měl řízení s "programátorem" z FIO banky. Ráno jsem zjistil, že nechodí potvrzující smsky po té, co se přihlásím přes username a password. Napsal jsem do FIO banky.Tam mi chytrolín odpověděl, že mám restartovat mobil, vyblokovat aplikace nebo se spojit s mým mobilkovým operátorem. Rady na prd. Pak se ukázalo, že na vině je mastič kódů ve FIO bance, který "vylepšoval" přihlašování do internetového bankovnictví mastěním kódů z hlavy. Výsledkem jeho "programátorského vylepšování" bylo, že některým uživatelům přestaly docházet potvrzující smsky. Vymastil to správně až po 8 hodinách opakovaných oprav. Kdyby byl opravdický programátor, napsal by si nejprve program a teprve potom by ten program přenesl do kódů. Ale jsme v Česku, a kdejaký mastič kódů se cítí být tím nejsuprovějším programátorem na světě.

#11 gna
Kde sehnat nápovědu pro:

FigureCanvasTkAgg, NavigationToolbar2Tk
 

Posíláš tam nějaké argumenty a chtěl bych vidět přehled těch argumentů, co vše se tam dá použít.

fig_canvas.get_tk_widget().pack(expand=True, fill=tk.BOTH)
fig_toolbar = NavigationToolbar2Tk(fig_canvas, root, pack_toolbar=False)

jinak teď nechápu, mám na zkoušku zjednodušenou aplikaci bez tkinter a čistě v tom matlab po
plt.show()
se aplikace uzavře... S tím tk ne, tam se dá ta smyčka, ale proč se ukončuje matlablib, resp. jak to udělat aby se neukončil?

Ono to bez toho tk nejde???

#18 remmidemmi
promiń, ale mě tvoje zážitky z práce nezajimají, jdi se vozit po někom jiném...