[PYTHON] J'ai essayé l'analyse de dimension fractale par la méthode de comptage de boîtes en 3 dimensions

introduction

Evaluons quantitativement la ** beauté ** de la structure. Je fais des recherches. En tant que méthode de quantification, la ** dimension fractale ** est utilisée comme un indice.

Et, pour trouver la dimension fractale, nous utilisons une méthode appelée ** méthode de comptage de boîtes **. Je n'ai pas trouvé d'exemple de gestion de cela en 3D, alors je l'ai écrit sous forme d'article.

Quelle est la dimension fractale?

[Dimension fractale](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) C'est ce que dit Wikipedia. Pour faire simple, les dimensions entre la 1ère et la 2ème dimension et entre la 2ème et la 3ème dimension peuvent être exprimées par des ** valeurs non entières **. Vous pouvez exprimer la ** complexité **. Une évaluation quantitative des paysages et des peintures est effectuée à partir de cela.

Analyse des dimensions fractales

Cette fois, à titre d'exemple, nous utiliserons un cube * 200 × 200 × 200 *. Expérimentons comme un tableau 3D * numpy * initialisé avec * 1 *.

Lire réellement le fichier * STL * numpy-stlOrganisez en utilisant. (Les détails seront écrits dans le futur)

Méthode de comptage des boîtes

Je pense que cet article est facile à comprendre sur la méthode de comptage des boîtes, je vais donc y faire un lien. Analyse fractale de la courbe de rugosité de surface

Pensez à cela en trois dimensions.

1. Divisez le cube en une grille
2. Comptez si la grille contient des objets
3. Soit grid_size la longueur du côté de la grille et n le nombre.
4. Tracer le journal (grid_size) et le journal (n)
5. Effectuer une régression linéaire par la méthode des moindres carrés
6. Soit le coefficient de régression la dimension fractale

Nous modifierons la taille de cette grille une par une.

Une fonction qui compte les éléments contenus dans une boîte

Balayez le réseau 3D dans l'ordre direction x → direction y → direction z

• 1 * est jugé par np.any.

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
            #Enrouler
            j += b_tmp2
            j_tmp += b_tmp2
            b = b_tmp2
            i = 0
        #Enrouler
        k += b_tmp2
        k_tmp += b_tmp2
        b = b_tmp2
        j = b_tmp2

        i = 0
        j = 0

fonction principale

Répétez le processus de count () jusqu'à ce que la taille du réseau passe de * 200 * à * 1/2 * par 100, 50, ... et * 1 *. Lorsque la taille de la grille est * 1 *, le nombre doit être * 200 x 200 x 200 = 80,00 000 *.

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)

Régression linéaire

Effectuez une régression linéaire à partir du résultat compté. Classe Scikit-learn pour le traitement de la régression Utilisez sklearn.linear_model.LinearRegression.

3d_fractal.py

    graph_x = np.array(graph_x).reshape((len(graph_x), 1)) #Faire une rangée
    graph_y = np.array(graph_y).reshape((len(graph_y), 1))

    model_lr = LinearRegression()

    #Création de modèles prédictifs
    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()

    #Dimension fractale=Coefficient de régression
    fractal = model_lr.coef_[0][0] * -1 

    print("Fractal : ", fractal)

résultat

Voici le graphique logarithmique des résultats. Taille du treillis * log * sur l'axe horizontal

• Journal * des comptes sur l'axe vertical Le coefficient de régression de ceci est la dimension fractale.

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

Le résultat ressemble à ceci. La dimension fractale est * 3.004579190748091 * C'est donc presque une valeur théorique. Lors de la répétition de * 200 *, il y avait un cas où il n'était pas divisible par * 25/2 = 12 *, donc il y avait un léger écart.

Résumé

«Nous avons pu vérifier l'analyse de dimension fractale tridimensionnelle par la méthode du comptage de boîtes. -La prochaine fois, j'aimerais écrire une méthode pour calculer la dimension fractale directement à partir du fichier * STL *.

Les références

«Analyse fractale de la courbe de rugosité de surface», Takeo Kono, (2010), Bulletin de recherche de l'Institut de technologie de la préfecture de Nagano, n ° 5, p. P52-P55.