[PYTHON] Ich habe eine fraktale Dimensionsanalyse mit der Box-Count-Methode in 3 Dimensionen versucht

Einführung

Lassen Sie uns die ** Schönheit ** der Struktur quantitativ bewerten. Ich recherchiere. Als Quantifizierungsmethode wird ** fraktale Dimension ** als ein Index verwendet.

Und um die fraktale Dimension zu finden, verwenden wir eine Methode namens ** Boxzählmethode **. Ich habe kein Beispiel dafür gefunden, wie man damit in 3D umgeht, also habe ich es als Artikel geschrieben.

Was ist die fraktale Dimension?

[Fraktale Dimension](https://ja.wikipedia.org/wiki/%E3%83%95%E3%83%A9%E3%82%AF%E3%82%BF%E3%83%AB%E6% AC% A1% E5% 85% 83) Das sagt Wikipedia. Einfach ausgedrückt können die Dimensionen zwischen der 1. und 2. Dimension sowie zwischen der 2. und 3. Dimension durch ** nicht ganzzahlige Werte ** ausgedrückt werden. Sie können ** Komplexität ** ausdrücken. Damit wird eine quantitative Bewertung von Landschaften und Gemälden durchgeführt.

Fraktale Dimensionsanalyse

Dieses Mal verwenden wir als Beispiel einen * 200 × 200 × 200 * -Würfel. Experimentieren wir als 3D * numpy * -Array, das mit * 1 * initialisiert wurde.

Lesen Sie tatsächlich die * STL * -Datei numpy-stlOrdnen Sie mit. (Details werden in Zukunft geschrieben)

Box-Zählmethode

Ich denke, dieser Artikel ist leicht zu verstehen über die Box-Zählmethode, daher werde ich darauf verlinken. Fraktale Analyse der Oberflächenrauheitskurve

Denken Sie dreidimensional daran.

1. Teilen Sie den Würfel in ein Gitter
2. Zählen Sie, ob das Raster Objekte enthält
3. Sei grid_size die Länge der Gitterseite und n die Anzahl.
4. Zeichnen Sie das Protokoll (grid_size) und das Protokoll (n).
5. Führen Sie eine lineare Regression nach der Methode der kleinsten Quadrate durch
6. Der Regressionskoeffizient sei die fraktale Dimension

Wir werden die Größe dieses Gitters nacheinander ändern.

Eine Funktion, die die in einer Box enthaltenen Elemente zählt

Scannen Sie das 3D-Array in der Reihenfolge x-Richtung → y-Richtung → z-Richtung

• 1 * wird von np.any beurteilt.

3d_fractal.py

def count(arr, x, y, z, b):
    i = j = k = 0
    b_tmp  = b
    b_tmp2 = b
    ct = 0

    j_tmp = b
    k_tmp = b
    while k < z:
        while j < y:
            while i < x:
                if (np.any(arr[i:b, j:j_tmp, k:k_tmp] == 1)):
                    ct += 1
                i += b_tmp
                b += b_tmp
            #Zurückwickeln
            j += b_tmp2
            j_tmp += b_tmp2
            b = b_tmp2
            i = 0
        #Zurückwickeln
        k += b_tmp2
        k_tmp += b_tmp2
        b = b_tmp2
        j = b_tmp2

        i = 0
        j = 0

Hauptfunktion

Wiederholen Sie den Vorgang von count (), bis sich die Gittergröße von * 200 * auf * 1/2 * um 100, 50, ... und * 1 * ändert. Wenn die Rastergröße * 1 * ist, sollte die Anzahl * 200 x 200 x 200 = 80,00,000 * betragen.

3d_fractal.py

def main():

    x = y = z = 200

    graph_x = []
    graph_y = []

    array3d = np.ones((x, y, z))
    ct_1 = np.count_nonzero(array3d == 1)

    grid_size = max(x, y, z)

    while grid_size >= 1:
        n = count(array3d, x, y, z, grid_size)
        graph_x.append(math.log(grid_size))
        graph_y.append(math.log(n))
        print(grid_size, n)
        print (math.log(grid_size), math.log(n))
        grid_size = int(grid_size / 2)

Lineare Regression

Führen Sie eine lineare Regression aus dem gezählten Ergebnis durch. Scikit-Learn-Klasse für die Regressionsverarbeitung Verwenden Sie sklearn.linear_model.LinearRegression.

3d_fractal.py

    graph_x = np.array(graph_x).reshape((len(graph_x), 1)) #Bilden Sie eine Reihe
    graph_y = np.array(graph_y).reshape((len(graph_y), 1))

    model_lr = LinearRegression()

    #Vorausschauende Modellerstellung
    model_lr.fit(graph_x, graph_y)

    plt.xlabel("log(grid_size)")
    plt.ylabel("log(n)")

    plt.plot(graph_x, graph_y, 'o')
    plt.plot(graph_x, model_lr.predict(graph_x), linestyle="solid")

    plt.grid()
    plt.show()

    #Fraktale Dimension=Regressionskoeffizienten
    fractal = model_lr.coef_[0][0] * -1 

    print("Fractal : ", fractal)

Ergebnis

Hier ist das logarithmische Diagramm der Ergebnisse. Gittergröße * log * auf der horizontalen Achse

• Protokoll * der Zählungen auf der vertikalen Achse Der Regressionskoeffizient hierfür ist die fraktale Dimension.

200 1
5.298317366548036 0.0
100 8
4.605170185988092 2.0794415416798357
50 64
3.912023005428146 4.1588830833596715
25 512
3.2188758248682006 6.238324625039508
12 4913
2.4849066497880004 8.499640032168648
6 39304
1.791759469228055 10.579081573848484
3 300763
1.0986122886681098 12.614077858172898
1 8000000
0.0 15.89495209964411
Fractal :  3.004579190748091

Das Ergebnis sieht so aus. Die fraktale Dimension ist * 3.004579190748091 * Es ist also fast ein theoretischer Wert. Bei der Wiederholung von * 200 * gab es einen Fall, in dem es nicht durch * 25/2 = 12 * teilbar war, sodass es eine leichte Abweichung gab.

Zusammenfassung

――Wir konnten die dreidimensionale fraktale Dimensionsanalyse mit der Box-Count-Methode verifizieren.

• Beim nächsten Mal möchte ich eine Methode schreiben, um die fraktale Dimension direkt aus der * STL * -Datei zu berechnen.

Verweise

"Fraktale Analyse der Oberflächenrauheitskurve", Takeo Kono, (2010), Forschungsbulletin des Präfekturinstituts Nagano, Nr. 5, S. P52-P55.