להורדה | 'תופס תמורתו' ממיר ומקטין קבצים קל, מהיר, וחינמי!💥

AVIVI

בס"ד

הדגשה כרגיל- טוב.. מי שלא אוהב תוכנות שנוצרו עם AI נא לדלג לשרשור אחר שכוייח מראש!

תופס תמורתו

כרגיל כל דבר טוב מתחיל כי נמאס מה שהיה עד עכשיו (מי הזיז את ה(ג)בינה שלי?)

בס"ד עלה בדעתי ליצור תוכנה להמרת קבצים ע"י הגבינה המלאכותית
ובמיוחד להקטנת קבצים (שם החל הרעיון... נמאס לי להעלות חמש תמונות למייל במשך שעה רק בגלל שהמצלמה שלי טובה ב"ה...)
תמיד יש לנו את הוידאו ששוקל טון ואת התמונה של הנוף ששוקלת 15 מ"ב ואת השיר שתופס הרבה מקום
לשם כך ולעוד דברים נוספים נועד תופס תמורתו
התוכנה להמרת קבצים בשניות שבע"ה תקל לנו מעט את החיים
התוכנה כרגע ממירה וידאו אודיו ותמונה
פותחים את התוכנה, בוחרים את הקובץ והיפ הופ הקובץ נחתך למחצה שליש ורביע לפי בחירתכם!
הקבצים נשמרים בתקייה חדשה בשם 'קבצים_שהומרו' או בכל שפה אחרת שבחרתם כשפת התוכנה
התוכנה תומכת בפורמטים המצויים
התוכנה תומכת גם בהמרת תמונה ל- pdf ובהמרת וידאו לקובץ gif

הערה חשובה לגבי הוידאו:כרגע לוקח קצת הרבה זמן לתוכנה להמיר קבצי וידאו אולם התוצאה שווה ככל שבדקתי!
המרתי איתה קובץ וידאו במשקל 67 מ"ב ולאחר ההמרה התקבל קובץ במשקל 18.7 מ"ב ללא פגיעה באיכות הנראית לעין!!!
רק ההמרה לקחה לי הרבה מהמעבד אז שימו לב! בגרסה הבאה אשתדל שתהיה יותר הגבלה במעבד בע"ה

התוכנה קצת בוסרית בע"ה אני עובד לשפרה ולשכללה עדכונים יובאו כאן בהמשך

להורדה

TofesTmurato 1v

קוד פתוח למעוניינים

לא לצחוק על הטריק של השפה... אני לא מתכנת!

# -*- coding: utf-8 -*-
import sys
import os
import threading
import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image
import customtkinter as ctk
import imageio.plugins.ffmpeg

# פונקציה לניהול נתיבים עבור PyInstaller (כולל האייקון)
def resource_path(relative_path):
    try:
        # PyInstaller creates a temp folder and stores path in _MEIPASS
        base_path = sys._MEIPASS
    except Exception:
        base_path = os.path.abspath(".")
    return os.path.join(base_path, relative_path)

# ניהול תלויות: MoviePy
try:
    from moviepy.editor import VideoFileClip, AudioFileClip
except Exception:
    print("Missing moviepy. Install with: pip install moviepy")
    sys.exit(1)

# מבני נתונים
MEDIA_TYPES = {
    'Video': ['MP4', 'GIF', 'MOV', 'MKV', 'WEBM', 'AVI'],
    'Audio': ['MP3', 'WAV', 'M4A', 'FLAC', 'AAC'],
    'Image': ['JPG', 'PNG', 'WEBP', 'PDF', 'ICO', 'BMP']
}

EXT_MAP = {}
for mtype, exts in MEDIA_TYPES.items():
    for e in exts:
        EXT_MAP[e.lower()] = mtype

TRANSLATIONS = {
    'he': {
        'title': 'מקצועי ממיר תמורתו תופס',
        'select': 'קבצים בחר',
        'convert': 'הכל המר',
        'quality': 'יעד איכות',
        'original': 'מקור',
        'low': 'נמוכה',
        'med': 'בינונית',
        'high': 'גבוהה',
        'status_idle': '...ממתין',
        'status_proc': 'מעבד {} מתוך {}',
        'done': 'בהצלחה הסתיימה ההמרה דשמייא בסייעתא',
        'folder_name': 'קבצים_שהומרו',
        'lang': ':שפה',
        'dir': 'rtl',
        'type': 'מדיה סוג',
        'fmt': ':פורמט',
        'Video': 'וידאו',
        'Audio': 'אודיו',
        'Image': 'תמונה',
        'files_sel': 'קבצים {} בחרו'
    },
    'en': {
        'title': 'Tofes Tmurato - Converter',
        'select': 'Select Files',
        'convert': 'Convert All',
        'quality': 'Quality:',
        'original': 'Original',
        'low': 'Low',
        'med': 'Med',
        'high': 'High',
        'status_idle': 'Idle...',
        'status_proc': 'Processing: {}/{}',
        'done': 'Finished!',
        'folder_name': 'Converted_Files',
        'lang': 'Language:',
        'dir': 'ltr',
        'type': 'Media Type:',
        'fmt': 'Format:',
        'Video': 'Video',
        'Audio': 'Audio',
        'Image': 'Image',
        'files_sel': '{} files selected'
    },
    'yi': {
        'title': 'קאנווערטער תמורתו תופס',
        'select': 'פיילס אויס קלייב',
        'convert': 'קאנווערטן אן הייב',
        'quality': ':קוואליטעט',
        'original': 'מקור',
        'low': 'נידריג',
        'med': 'מיטל',
        'high': 'הויך',
        'status_idle': '...ווארט',
        'status_proc': 'פון {} ארבעט {}',
        'done': 'בהצלחה געענדיקט דשמייא בסייעתא',
        'folder_name': 'קאנווערטעד_פיילס',
        'lang': ':שפראך',
        'dir': 'rtl',
        'type': 'טיפ מדיע',
        'fmt': ':פאָרמאַט',
        'Video': 'ווידעא',
        'Audio': 'אוידיא',
        'Image': 'בילד',
        'files_sel': 'פיילס {} אויסגעקליבן'
    }
}

class ConverterApp(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.lang = 'he'
        self.file_paths = []
        self.is_processing = False

        # הגדרת אייקון לחלון
        try:
            self.iconbitmap(resource_path("icon.ico"))
        except Exception:
            pass # אם האייקון לא קיים בזמן פיתוח, לא לקרוס

        self.setup_ui()
        self.change_lang('he')

    def fix_text(self, text):
        if self.lang in ['he', 'yi'] or any('\u0590' <= c <= '\u05ff' for c in text):
            if text.endswith(':'):
                text = ':' + text[:-1]
            words = text.split(' ')
            return ' '.join(words[::-1])
        return text

    def setup_ui(self):
        self.geometry("500x700")
        self.title("Tofes Tmurato 1v")
        ctk.set_appearance_mode("dark")

        # כותרת עליונה ובחירת שפה
        self.header = ctk.CTkFrame(self)
        self.header.pack(pady=10, fill="x", padx=20)
        self.lang_menu = ctk.CTkOptionMenu(self.header, values=['he', 'en', 'yi'], command=self.change_lang, width=120)
        self.lang_menu.pack(side="right", padx=10)

        self.lbl_title = ctk.CTkLabel(self, text="", font=("Arial", 28, "bold"))
        self.lbl_title.pack(pady=20)

        self.btn_select = ctk.CTkButton(self, text="", command=self.select_files, height=50, font=("Arial", 16, "bold"))
        self.btn_select.pack(pady=10)

        self.lbl_info = ctk.CTkLabel(self, text="", text_color="gray", font=("Arial", 14))
        self.lbl_info.pack()

        # מסגרת אפשרויות המרה
        self.form_frame = ctk.CTkFrame(self)
        self.form_frame.pack(pady=20, padx=40, fill="both", expand=True)

        self.lbl_type = ctk.CTkLabel(self.form_frame, text="", font=("Arial", 14))
        self.lbl_type.pack(pady=(15,0))
        self.opt_type = ctk.CTkOptionMenu(self.form_frame, values=list(MEDIA_TYPES.keys()), command=self.update_formats, width=200)
        self.opt_type.pack(pady=5)

        self.lbl_fmt = ctk.CTkLabel(self.form_frame, text="", font=("Arial", 14))
        self.lbl_fmt.pack(pady=(15,0))
        self.opt_fmt = ctk.CTkOptionMenu(self.form_frame, values=[], width=200)
        self.opt_fmt.pack(pady=5)

        self.lbl_q = ctk.CTkLabel(self.form_frame, text="", font=("Arial", 14))
        self.lbl_q.pack(pady=(15,0))
        self.seg_quality = ctk.CTkSegmentedButton(self.form_frame, values=["low", "med", "high", "original"])
        self.seg_quality.pack(pady=5, padx=20, fill="x")

        # התקדמות וכפתור ביצוע
        self.progress_bar = ctk.CTkProgressBar(self)
        self.progress_bar.pack(pady=(30,10), padx=50, fill="x")
        self.progress_bar.set(0)

        self.btn_convert = ctk.CTkButton(self, text="", fg_color="#28a745", hover_color="#218838",
                                        command=self.start_conversion, height=60, font=("Arial", 18, "bold"))
        self.btn_convert.pack(pady=30)

    def change_lang(self, v):
        self.lang = v
        t = TRANSLATIONS[v]

        self.lbl_title.configure(text=self.fix_text(t['title']))
        self.btn_select.configure(text=self.fix_text(t['select']))
        self.lbl_type.configure(text=self.fix_text(t['type']))
        self.lbl_fmt.configure(text=self.fix_text(t['fmt']))
        self.lbl_q.configure(text=self.fix_text(t['quality']))
        self.btn_convert.configure(text=self.fix_text(t['convert']))

        qs = ["low", "med", "high", "original"]
        translated_qs = [self.fix_text(t[q]) for q in qs]
        self.seg_quality.configure(values=translated_qs)
        self.seg_quality.set(self.fix_text(t["original"]))

    def select_files(self):
        paths = filedialog.askopenfilenames(parent=self)
        if paths:
            self.file_paths = list(paths)
            self.auto_detect_first()
            self.update_info()

    def auto_detect_first(self):
        ext = os.path.splitext(self.file_paths[0])[1][1:].lower()
        mtype = EXT_MAP.get(ext, 'Video')
        self.opt_type.set(mtype)
        self.update_formats(mtype)

        if ext.upper() in MEDIA_TYPES[mtype]:
            self.opt_fmt.set(ext.upper())

    def update_info(self):
        t = TRANSLATIONS[self.lang]
        count = len(self.file_paths)
        size = sum(os.path.getsize(p) for p in self.file_paths) / (1024 * 1024)
        txt = t['files_sel'].format(count) + f" ({size:.2f} MB)"
        self.lbl_info.configure(text=self.fix_text(txt))

    def update_formats(self, mtype):
        self.opt_fmt.configure(values=MEDIA_TYPES[mtype])
        self.opt_fmt.set(MEDIA_TYPES[mtype][0])

    def start_conversion(self):
        if not self.file_paths or self.is_processing:
            return
        self.is_processing = True
        self.btn_convert.configure(state="disabled")
        self.progress_bar.set(0)
        threading.Thread(target=self.run_process, daemon=True).start()

    def run_process(self):
        t = TRANSLATIONS[self.lang]
        target_ext = self.opt_fmt.get().lower()

        q_val = self.seg_quality.get()
        quality = "original"
        for k in ["low", "med", "high", "original"]:
            if q_val == self.fix_text(t[k]):
                quality = k

        out_dir = os.path.join(os.path.dirname(self.file_paths[0]), t['folder_name'])
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)

        for i, path in enumerate(self.file_paths):
            self.convert_logic(path, target_ext, out_dir, quality)
            self.after(0, lambda idx=i: self.progress_bar.set((idx + 1) / len(self.file_paths)))

        self.is_processing = False
        self.after(0, lambda: self.btn_convert.configure(state="normal"))
        self.after(0, lambda: messagebox.showinfo("V", self.fix_text(t['done'])))

    def convert_logic(self, in_p, ext, out_d, qual):
        name = os.path.splitext(os.path.basename(in_p))[0]
        out_p = os.path.join(out_d, f"{name}.{ext}")

        try:
            mtype = self.opt_type.get()

            if mtype == 'Image':
                with Image.open(in_p) as img:
                    if ext == 'pdf':
                        img.convert("RGB").save(out_p, "PDF")
                    else:
                        q = 30 if qual == "low" else 70 if qual == "med" else 90
                        if qual == "original": q = 95
                        img.save(out_p, optimize=True, quality=q)

            elif mtype == 'Video':
                clip = VideoFileClip(in_p)
                if ext == 'gif':
                    clip.resize(width=480).write_gif(out_p, fps=12, logger=None)
                else:
                    crf = "30" if qual == "low" else "24" if qual == "med" else "18"
                    clip.write_videofile(out_p, codec="libx264", audio_codec="aac",
                                         ffmpeg_params=["-crf", crf], logger=None)
                clip.close()

            elif mtype == 'Audio':
                clip = AudioFileClip(in_p)
                br = "64k" if qual == "low" else "128k" if qual == "med" else "320k"
                clip.write_audiofile(out_p, bitrate=br, logger=None)
                clip.close()
        except Exception as e:
            print(f"Error converting {in_p}: {e}")

if __name__ == "__main__":
    app = ConverterApp()
    app.mainloop()

צילום מסך

נ.ב. שימו לב לפני הורדת התוכנה אם אתם שולחים תמונות להדפסה וכו' נא לא להשתמש בתוכנה בד"כ זה מוריד באיכות שלשיתוף תמונות במסך הביתי זה לא פוגע אבל בהדפסה זה פוגע לפעמים

וכמובן כמו תמיד אם יש לכם הערות לשיפור ושידרוג או שיש לכם ידע בתכנות ואתם רוצים לשפר אשמח לשמוע

אה.. ואל תשכחו את התוכנה השנייה שממש נמצאת כאן וממש עוזרת
https://mitmachim.top/topic/94724/להורדה-תוכנה-קטנה-לשליטה-בתוכנות-מסך-מלא-וסגירה-בכח/6

מיני האקר

@AVIVI
כמה זמן לוקח לזה להקטין תמונה, נגיד?

AVIVI

@מיני-האקר פחות משנייה
ללא הגזמה

שרגא תכנות

@AVIVI חסום להורדה בנטפרי, תודה

יאיר י.

@שרגא-תכנות @avivi
שאבין, מה זה שונה מפורמט פקטורי החינמי?
והאם יש בזה דברים יותר מיוחדים משם?

AVIVI

@שרגא-תכנות נשלח פנייה תודה על העדכון!

AVIVI

@יאיר-י.
בראש ובראשונה רציתי לפתור את זה https://mitmachim.top/topic/75871/מדריך-לכל-המעוניין-התכתבות-בינה-מלאכותית-בנוגע-לפשעי-אווסט-כדאי-לקרוא
שזה כולל את פורמט פקטורי
ועוד ועוד חפש בפורום
דבר שני התוכנה פשוטה יותר מהירה יותר
אה... וגם ביידיש

jc324118983

האם הוא עושה את זה בצורה חכמה או סתם מקטין את התמונה?

AVIVI

@jc324118983 למה אתה מתכוין צורה חכמה?

jc324118983

@AVIVI יש שתי אופציות להקטין קובץ תמונה לדוגמה יש אופציה פשוט להוריד את כמות הפיקסלים (להקטין את התמונה) ויש בצורה חכמה שאני לא מבין איך זה עובד אבל מוריד משמעותי מבלי לפגוע באיכות

AVIVI

@jc324118983 לדעתי זה 'בצורה חכמה' או איך שתקרא לזה
הקטנתי קובץ של 6.8 מ"ב ל 334 ק"ב וכמעט שלא ראיתי הבדל
אין לי כרגע תמונה אם תרצה תעלה לכאן ואחזיר לך אותה לאחר המרה

CSS 0

@יאיר-י.

זה כבר נהיה מעצבן, מישהו מעלה תוכנה ומייד השאלה הראשונה זה - "מה זה שונה מ..." התשובה היא פשוטה, לא שונה בכלום, לא רוצה אל תשתמש!

@jc324118983 כתב בלהורדה | 'תופס תמורתו' ממיר ומקטין קבצים קל, מהיר, וחינמי!:

יש בצורה חכמה שאני לא מבין איך זה עובד

@AVIVI כתב בלהורדה | 'תופס תמורתו' ממיר ומקטין קבצים קל, מהיר, וחינמי!:

לדעתי זה 'בצורה חכמה'

על מנת שזה יהיה בצורה חכמה לרוב צריך שיהיה מנוע AI שיסתכל על התמונה ולא ימחק סתם פיקסלים אלא ימחק את הפיקסלים בצורה שווה לכל פריט ככה שהוא לא סתם מקטין את הפיקסלים אלא מקטין את הדברים בתמונה ומאליו את הגודל והפיקסלים
התוכנה הזו ככל הנראה לא עובדת בצורה שלא מורידה איכות,

מה שבטוח, בטוח - התוכנה עצמה איכותית ביותר

ארי

@CSS-0 לא קשור לAI זה קיים עוד לפניו
תראה לדוגמה
Squoosh — מנובמבר 2018
TinyPNG — מ2013/2014
Caesium — מ2010/2015

CSS 0

@ארי כתב בלהורדה | 'תופס תמורתו' ממיר ומקטין קבצים קל, מהיר, וחינמי!:

א קשור לAI זה קיים עוד לפניו

אתה מדבר על AI של צ'אט, AI של הגדלת הקטנת תמונות, זיהוי פנים, זיהוי דיבור וכ"ו היו לפני

Deep Blue של IBM ניצח את Garry Kasparov בשחמט ב־1997...