__init__.py

# ##### BEGIN GPL LICENSE BLOCK #####
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

#
#  Main author       : Clemens Barth (Blendphys@root-1.de)
#  Authors           : Clemens Barth, Christine Mottet (Icosahedra), ...
#
#  Homepage(Wiki)    : http://development.root-1.de/Atomic_Blender.php
#
#  Start of project              : 2012-03-25 by Clemens Barth
#  First publication in Blender  : 2012-05-27 by Clemens Barth
#  Last modified                 : 2019-03-19
#
#
#
#  To do:
#  ======
#
#  1. Include other shapes: dodecahedron, ...
#  2. Skin option for parabolic shaped clusters
#  3. Skin option for icosahedron
#  4. Icosahedron: unlimited size ...
#

bl_info = {
    "name": "Atomic Blender - Cluster",
    "description": "Creating nanoparticles/clusters formed by atoms",
    "author": "Clemens Barth",
    "version": (0, 5),
    "blender": (2, 80, 0),
    "location": "Panel: View 3D - Tools (right side)",
    "warning": "",
    "doc_url": "... will be updated asap ...",
    "category": "Add Mesh"}

import os
import io
import bpy
from bpy.types import Operator, Panel
from bpy_extras.io_utils import ImportHelper, ExportHelper
from bpy.props import (StringProperty,
                       BoolProperty,
                       EnumProperty,
                       IntProperty,
                       FloatProperty)

from . import add_mesh_cluster

ATOM_Cluster_PANEL = 0

# -----------------------------------------------------------------------------
#                                                                           GUI


class CLASS_ImportCluster(bpy.types.Operator):
    bl_idname = "mesh.cluster"
    bl_label = "Atom cluster"
    bl_options = {'REGISTER', 'UNDO', 'PRESET'}

    def execute(self, context):

        global ATOM_Cluster_PANEL
        ATOM_Cluster_PANEL = 1

        return {'FINISHED'}


class CLASS_PT_atom_cluster_panel(Panel):
    bl_label       = "Atomic Blender - Cluster"
    bl_space_type  = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Create"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(self, context):
        global ATOM_Cluster_PANEL

        if ATOM_Cluster_PANEL == 0:
            return False

        return True

    def draw(self, context):
        layout = self.layout

        scn = context.scene.atom_cluster

        row = layout.row()
        row.label(text="Cluster properties")
        box = layout.box()
        row = box.row()
        row.prop(scn, "shape")

        if scn.shape in ["parabolid_square","parabolid_ab","parabolid_abc"]:
            row = box.row()
            row.prop(scn, "parabol_diameter")
            row = box.row()
            row.prop(scn, "parabol_height")
        elif scn.shape in ["icosahedron"]:
            row = box.row()
            row.prop(scn, "icosahedron_size")
        else:
            row = box.row()
            row.prop(scn, "size")
            row = box.row()
            row.prop(scn, "skin")

        row = box.row()
        row.prop(scn, "lattice_parameter")
        row = box.row()
        row.prop(scn, "element")
        row = box.row()
        row.prop(scn, "radius_type")
        row = box.row()
        row.prop(scn, "scale_radius")
        row = box.row()
        row.prop(scn, "scale_distances")

        row = layout.row()
        row.label(text="Load cluster")
        box = layout.box()
        row = box.row()
        row.operator("atom_cluster.load")
        row = box.row()
        row.label(text="Number of atoms")
        row = box.row()
        row.prop(scn, "atom_number_total")
        row = box.row()
        row.prop(scn, "atom_number_drawn")


# The properties (gadgets) in the panel. They all go to scene
# during initialization (see end)
class CLASS_atom_cluster_Properties(bpy.types.PropertyGroup):

    def Callback_radius_type(self, context):
        scn = bpy.context.scene.atom_cluster
        DEF_atom_cluster_radius_type(scn.radius_type,
                                     scn.radius_how,)

    size: FloatProperty(
        name = "Size", default=30.0, min=0.1,
        description = "Size of cluster in Angstroem")
    skin: FloatProperty(
        name = "Skin", default=1.0, min=0.0, max = 1.0,
        description = "Skin of cluster in % of size (skin=1.0: show all atoms, skin=0.1: show only the outer atoms)")
    parabol_diameter: FloatProperty(
        name = "Diameter", default=30.0, min=0.1,
        description = "Top diameter in Angstroem")
    parabol_height: FloatProperty(
        name = "Height", default=30.0, min=0.1,
        description = "Height in Angstroem")
    icosahedron_size: IntProperty(
        name = "Size", default=1, min=1, max=13,
        description = "Size n: 1 (13 atoms), 2 (55 atoms), 3 (147 atoms), 4 (309 atoms), 5 (561 atoms), ..., 13 (8217 atoms)")
    shape: EnumProperty(
        name="",
        description="Choose the shape of the cluster",
        items=(('sphere_square',  "Sphere - square",   "Sphere with square lattice"),
               ('sphere_hex_ab',  "Sphere - hex ab",  "Sphere with hexagonal ab-lattice"),
               ('sphere_hex_abc', "Sphere - hex abc", "Sphere with hexagonal abc-lattice"),
               ('pyramide_square',  "Pyramide - Square",    "Pyramide: square (abc-lattice)"),
               ('pyramide_hex_abc', "Pyramide - Tetraeder", "Pyramide: tetraeder (abcabc-lattice)"),
               ('octahedron',           "Octahedron",           "Octahedron"),
               ('truncated_octahedron', "Truncated octahedron", "Truncated octahedron"),
               ('icosahedron', "Icosahedron", "Icosahedron"),
               ('parabolid_square', "Paraboloid: square",  "Paraboloid with square lattice"),
               ('parabolid_ab',     "Paraboloid: hex ab",  "Paraboloid with ab-lattice"),
               ('parabolid_abc',    "Paraboloid: hex abc", "Paraboloid with abc-lattice")),
               default='sphere_square',)
    lattice_parameter: FloatProperty(
        name = "Lattice", default=4.08, min=1.0,
        description = "Lattice parameter in Angstroem")
    element: StringProperty(name="Element",
        default="Gold", description = "Enter the name of the element")
    radius_type: EnumProperty(
        name="Radius",
        description="Which type of atom radii?",
        items=(('0',"predefined", "Use pre-defined radii"),
               ('1',"atomic", "Use atomic radii"),
               ('2',"van der Waals","Use van der Waals radii")),
               default='0',)
    scale_radius: FloatProperty(
        name = "Scale R", default=1.0, min=0.0,
        description = "Scale radius of atoms")
    scale_distances: FloatProperty(
        name = "Scale d", default=1.0, min=0.0,
        description = "Scale distances")

    atom_number_total: StringProperty(name="Total",
        default="---", description = "Number of all atoms in the cluster")
    atom_number_drawn: StringProperty(name="Drawn",
        default="---", description = "Number of drawn atoms in the cluster")


# The button for reloading the atoms and creating the scene
class CLASS_atom_cluster_load_button(Operator):
    bl_idname = "atom_cluster.load"
    bl_label = "Load"
    bl_description = "Load the cluster"

    def execute(self, context):
        scn    = context.scene.atom_cluster

        add_mesh_cluster.DEF_atom_read_atom_data()
        del add_mesh_cluster.ATOM_CLUSTER_ALL_ATOMS[:]

        if scn.shape in ["parabolid_ab", "parabolid_abc", "parabolid_square"]:
            parameter1 = scn.parabol_height
            parameter2 = scn.parabol_diameter
        elif scn.shape == "pyramide_hex_abc":
            parameter1 = scn.size * 1.6
            parameter2 = scn.skin
        elif scn.shape == "pyramide_square":
            parameter1 = scn.size * 1.4
            parameter2 = scn.skin
        elif scn.shape in ["octahedron", "truncated_octahedron"]:
            parameter1 = scn.size * 1.4
            parameter2 = scn.skin
        elif scn.shape in ["icosahedron"]:
            parameter1 = scn.icosahedron_size
        else:
            parameter1 = scn.size
            parameter2 = scn.skin

        if scn.shape in ["octahedron", "truncated_octahedron", "sphere_square", "pyramide_square", "parabolid_square"]:
            numbers = add_mesh_cluster.create_square_lattice(
                                scn.shape,
                                parameter1,
                                parameter2,
                                (scn.lattice_parameter/2.0))

        if scn.shape in ["sphere_hex_ab", "parabolid_ab"]:
            numbers = add_mesh_cluster.create_hexagonal_abab_lattice(
                                scn.shape,
                                parameter1,
                                parameter2,
                                scn.lattice_parameter)

        if scn.shape in ["sphere_hex_abc", "pyramide_hex_abc", "parabolid_abc"]:
            numbers = add_mesh_cluster.create_hexagonal_abcabc_lattice(
                                scn.shape,
                                parameter1,
                                parameter2,
                                scn.lattice_parameter)

        if scn.shape in ["icosahedron"]:
            numbers = add_mesh_cluster.create_icosahedron(
                                parameter1,
                                scn.lattice_parameter)

        DEF_atom_draw_atoms(scn.element,
                            scn.radius_type,
                            scn.scale_radius,
                            scn.scale_distances,
                            scn.shape)

        scn.atom_number_total = str(numbers[0])
        scn.atom_number_drawn = str(numbers[1])

        return {'FINISHED'}


def DEF_atom_draw_atoms(prop_element,
                        prop_radius_type,
                        prop_scale_radius,
                        prop_scale_distances,
                        coll_name):

    FLAG = False
    # Get the details about the atom (Name, radius, color, etc.).
    for element in add_mesh_cluster.ATOM_CLUSTER_ELEMENTS:
        if prop_element in element.name:
            number = element.number
            name = element.name
            color = element.color
            radii = element.radii
            FLAG = True
            break

    # If no element could be found, use gold. This may happen if the user does
    # not correctly wrote the name of the atom.
    if not FLAG:
        number = 79
        name = "Gold"
        color = (1.0,  0.81,  0.13, 1.0)
        radii = [1.34]

    # First, we create a collection for the atoms, which includes the
    # representative ball and the mesh.
    coll_atom_name = "Cluster (" + coll_name + ")_" + name.lower()
    # Create the new collection and ...
    coll_atom = bpy.data.collections.new(coll_atom_name)
    # ... link it to the collection, which contains all parts of the
    # element (ball and mesh).
    bpy.data.collections.new(coll_atom_name)
    bpy.context.scene.collection.children.link(coll_atom)

    # Create the material.
    material = bpy.data.materials.new(name)
    material.name = name
    material.diffuse_color = color

    atom_vertices = []
    for atom in add_mesh_cluster.ATOM_CLUSTER_ALL_ATOMS:
        atom_vertices.append( atom.location * prop_scale_distances )

    # Build the mesh
    atom_mesh = bpy.data.meshes.new("Mesh_"+name)
    atom_mesh.from_pydata(atom_vertices, [], [])
    atom_mesh.update()
    new_atom_mesh = bpy.data.objects.new(name+ "_mesh", atom_mesh)

    # Link active object to the new collection
    coll_atom.objects.link(new_atom_mesh)

    bpy.ops.surface.primitive_nurbs_surface_sphere_add(
                            align='WORLD', enter_editmode=False,
                            location=(0,0,0), rotation=(0.0, 0.0, 0.0))

    ball = bpy.context.view_layer.objects.active
    ball.name = name + "_ball"
    # Hide this ball because its appearance has no meaning. It is just the
    # representative ball. The ball is visible at the vertices of the mesh.
    # Rememmber, this is a dupliverts construct!
    ball.hide_set(True)

    # Scale the radius.
    ball.scale  = (radii[int(prop_radius_type)]*prop_scale_radius,) * 3

    ball.active_material = material
    ball.parent = new_atom_mesh
    new_atom_mesh.instance_type = 'VERTS'

    # Note the collection where the ball was placed into.
    coll_all = ball.users_collection
    if len(coll_all) > 0:
        coll_past = coll_all[0]
    else:
        coll_past = bpy.context.scene.collection

    # Put the atom into the new collection 'atom' and ...
    coll_atom.objects.link(ball)
    # ... unlink the atom from the other collection.
    coll_past.objects.unlink(ball)

    # ------------------------------------------------------------------------
    # SELECT ALL LOADED OBJECTS
    bpy.ops.object.select_all(action='DESELECT')
    new_atom_mesh.select_set(True)
    bpy.context.view_layer.objects.active = new_atom_mesh

    return True


# The entry into the menu 'file -> import'
def DEF_menu_func(self, context):
    self.layout.operator(CLASS_ImportCluster.bl_idname, icon='PLUGIN')


classes = (CLASS_ImportCluster,
           CLASS_PT_atom_cluster_panel,
           CLASS_atom_cluster_Properties,
           CLASS_atom_cluster_load_button)


def register():
    for cls in classes:
        bpy.utils.register_class(cls)

    bpy.types.Scene.atom_cluster = bpy.props.PointerProperty(type=
                                                  CLASS_atom_cluster_Properties)
    bpy.types.VIEW3D_MT_mesh_add.append(DEF_menu_func)


def unregister():
    bpy.types.VIEW3D_MT_mesh_add.remove(DEF_menu_func)

    del bpy.types.Scene.atom_cluster

    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)

if __name__ == "__main__":

    register()