Letzte Aktualisierungen Kommentarverlauf ein-/ausschalten | Tastaturkürzel

  • keilajedrik 13:14 am 15. January 2016 Permalink | Antworten  

    Tiles of a PNG image with Python 

    This article shows how to use Python and the great graphics and PDF library MuPDF (fitz = PyMuPDF) to create tiled image out of an arbitrary start picture. PyMuPDF (python binding of fitz / MuPDF) runs on Windows, Linux, etc.

    To create a 3*4 tiled version of this:

    editra.png

    gives you this:

    target-32.png

    Here is the program (runs VERY fast!):

     import fitz
     # read in picture image and create a pixmap of it
     pic = open("example.png", "rb").read()
     pix0 = fitz.Pixmap(pic, len(pic))
    
     # calculate target pixmap dimensions and create it
     tar_width  = pix0.width * 3              # 3 tiles per row
     tar_height = pix0.height * 4             # 4 tiles per column
     tar_irect  = fitz.IRect(0, 0, tar_width, tar_height)
     tar_pix    = fitz.Pixmap(fitz.Colorspace(fitz.CS_RGB), tar_irect)
     tar_pix.clearWith(255)                   # whiten the image area
    
     # now fill target with 3 * 4 tiles of input picture
     for i in list(range(4)):
         pix0.y = i * pix0.height                          # modify input's y coord
         for j in list(range(3)):
             pix0.x = j * pix0.width                       # modify input's x coord
             tar_pix.copyPixmap(pix0, pix0.getIRect())     # copy input to new loc
    
    tar_pix.writePNG("tiled.png")
    
    
    Advertisements
     
  • keilajedrik 12:59 am 15. January 2016 Permalink | Antworten  

    Create a Sierpinski Carpet with Python 

    The Sierpinski carpet is a mathematical set in 2-dimensional space. It is has a few interesting properties. Among them are:

    • it is a compact set contained in a square (usually, the unit square [0,1]x[0,1] is taken for it)
    • it has a Lebesgue measure of zero and its border has an infinite length
    • its number of points is uncountably infinite
    • it is a fractal with a dimension ln(8)/ln(3) (= 1.8928…)
    • it is a relative of the Cantor set and the Menger sponge

    This article shows how to create a nice PNG image of the Sierpinski carpet with a 25 non-comments line Python program in 1 second (6 iteration levels). Because it’s Python and the awesome PDF- and graphics library fitz (= PyMuPDF) runs on many platforms like Windows and Linux, you will probably be able to use it.

    sierpinski

    And this is the output of the program after less than 1 second of run time (4 GHz machine) when a picture width of 729 (= 3**6) is chosen:

    sierpinski.png

    Here is another program version. This one is recursive, which has the following advantages:

    1. It is a lot faster, because no pixel is turned to black more than once. A square side length of 729 pixels only needs about 0.5 seconds on my machine.
    2. Processing time only grows by a factor of 8 (and not 3*3 = 9) when the square side is increased by a factor of 3.This is because „almost nothing“ happens for the middle square – it only gets painted black. The other 8 receive a recursive treatment.
    3. It is a lot more readable … 🙂
    import fitz, time
    def punch(pm, x0, y0, x1, y1):         # pixmap and top-left, bottom-right coords
        if (x1-x0) < 3:                    # granularity below 1 pixel?
            return                         # yes, done  
        step = (x1 - x0) / 3
        # define short names for square corner coordinates
        x00 = x0
        x01 = x00 + step
        x02 = x01 + step
        x03 = x02 + step
        y00 = y0
        y01 = y00 + step
        y02 = y01 + step
        y03 = y02 + step
        # we clear the middle square and invoke us again for the other 8
        punch(pm, x00, y00, x01, y01)      # top left
        punch(pm, x01, y00, x02, y01)      # top middle
        punch(pm, x02, y00, x03, y01)      # top right
        punch(pm, x00, y01, x01, y02)      # middle left
        pm.clearWith(0, fitz.IRect(x01, y01, x02, y02)) # clear center
        punch(pm, x02, y01, x03, y02)      # middle right
        punch(pm, x00, y02, x01, y02)      # bottom left
        punch(pm, x01, y02, x02, y03)      # bottom middle
        punch(pm, x02, y02, x03, y03)      # bottom right
        return
    
    #==============================================================================
    # main program
    #==============================================================================
    d = 729                            # 729 = 3**6, stick to powers of 3 here
    # create a quadratic pixmap with origin (0,0), where width = height = d should
    # be a power of 3
    t0 = time.clock()
    pm = fitz.Pixmap(fitz.Colorspace(fitz.CS_RGB), fitz.IRect(0, 0, d, d))
    # fill image area with "white" and then tint and gamma it
    pm.clearWith(255)
    pm.tintWith(0, 50, 255)            # tint it with some sort of blue
    pm.gammaWith(0.2)                  # turn to a lighter blue
    # now punch holes into it, down to 1 pixel granularity
    punch(pm, 0, 0, d, d)
    t1 = time.clock()
    pm.writePNG("sierpinski.png")
    t2 = time.clock()
    print t1-t0, "sec to create fitz img"
    print t2-t1, "sec to save fitz img"
     
  • keilajedrik 16:30 am 4. October 2014 Permalink | Antworten
    Tags: Excel, Python, XLLoop   

    Beispiele Python und XLLoop 

    XLLoop ist eine Open Source Software, um Excel-Funktionen (User Defined Functions – UDFs) in einer Reihe von Programmiersprachen (Java, Javascript, Ruby, Python, Erlang) bereitstellen zu können. XLLoop kann z.B. von hier https://github.com/poidasmith/xlloop oder hier http://xlloop.sourceforge.net/ herunter geladen werden.

    Mit XLLoop werden die gewünschten Funktionen in einem separaten Programm / Skript abgelegt und als eigener (Server-) Prozess gestartet, laufen also nicht als Teil von Excel. Excel kommuniziert mit dem UDF-Server über ein xll-Add-In, s.u.

    Einige Eigenschaften, bzw. das Verhalten des UDF-Servers können über eine Konfigurationsdatei beeinflusst werden. Davon habe ich noch nichts selbst probiert.

    Dokumentation über die Installation und Benutzung ist entweder schwierig zu finden oder wohl tatsächlich kaum vorhanden. Deshalb hier meine Erfahrungen nach 2 Tagen. Wenn man ein bisschen probiert, ist aber – wie so oft – alles ganz einfach.

    Aber XLLoop ist wirklich sehr einfach zu verwenden. Aus meiner Sicht das beste Werkzeug für alle, die UDFs in ihrer Programmiersprache verfassen wollen, aber kein Interesse daran haben, damit VBA komplett zu ersetzen.

    Wer das will, sollte auf PyXLL (ebenfalls einfach zu benutzen) oder auf ExcelPython zurückgreifen.

    (1) Installation (am Beispiel Excel 2013)

    • Herunterladen der neuesten Version (xll-0.3.2) und entpacken.
    • Erstelle neuen Ordner, Beispiel „xlloop“ an gewünschtem Ort und kopiere „bin\xll-0.3.2.xll“ (im Download) nach „xlloop\PythonAddIn.xll“ (also kopieren und umbenennen).
    • Öffne Excel und gehe zum Menü-Punkt „Add-Ins“, füge den Eintrag für „PythonAddIn“ hinzu (Auffinden mit dem Durchsuchen-Button) und setze das Häkchen.

    B1

    Mehr ist zur Installation im Normalfall nicht zu tun.

    (2) Einen UDF Server erstellen mit Python

    Das folgende Python-Skript „reflect.py“ definiert eine sehr einfache UDF:

    Unveränderte Rückgabe falls ein einzelner Wert eingegeben wurde. Alle solchen Werte werden von XLLoop entweder als „string“ oder als „float“ präsentiert. Alle von einer Funktion zurückgegebenen Einzelwerte müssen ebenfalls einen dieser Typen haben.

    Andernfalls war es ein Excel-Bereich. Dieser wird als Python-Liste präsentiert. Für einen horizontalen Range hat sie die Form [[a, b, c, …]], für einen vertikalen die Form [a, b, c, …].

    Unsere Funktion dreht die Reihenfolge der Listenelemente um und gibt ebenfalls je nach EIngabe eine „horizontale“ oder „vertikale“ Liste zurück.

    In demselben Python-Skript können auf ähnliche Weise beliebige weitere Funktionen definiert werden. Jede UDF benötigt einen „decorator“ wie im Beispiel.

    Benötigte Python Module wie SciPy, NumPy, usw. können problemlos importiert werden.

    B0

    (3) Starten unseres UDF-Servers mit „python reflect.py“ in einem Command-Window.

    (4) Start von Excel und Benutzung der Funktion

    Eingabe einiger Werte in Zellen A3:F3,

    Markieren des Bereichs A4:F4

    Eingabe von =py_test(A3:F3) in Zelle A4

    Strg-Shift-Enter drücken. Es erscheint der Inhalt des Bereichs A3:F3 in umgekehrter Reihenfolge.

    B5

    Auf die Inhalte des Rückgabewertes einer UDF kann mit allen Möglichkeiten von Excel zugegriffen werden: =INDEX(py_test(A3:F3);4) liefert z.B. den Wert „c“.

     
c
Neuen Beitrag erstellen
j
nächster Beitrag/nächster Kommentar
k
vorheriger Beitrag/vorheriger Kommentar
r
Antworten
e
Bearbeiten
o
zeige/verstecke Kommentare
t
Zum Anfang gehen
l
zum Login
h
Zeige/Verberge Hilfe
Shift + ESC
Abbrechen