Blender2.8でAuto Mirrorアドオンを使って軸中央に頂点の無いモデルを左右対称にする

本日は Blender2.8 のビルドインアドオンの調査枠です。
Blender2.8でAuto Mirrorアドオンを使って軸中央に頂点の無いモデルを左右対称にする手順を記事にします。

Auto Mirror アドオン

オブジェクトをミラーするための機能が実装されたアドオンです。
ミラー加工の自動化のほか、複数選択でのミラーやワールド軸でのミラー設定などが行えます。
bookyakuno.com

アドオンの有効化

Auto Mirror アドオンは Blender に含まれているため、アドオンを有効化するだけで利用可能です。
Blender を起動し、メニューから 編集 -> プリファレンス を開きます。

Blenderプリファレンスダイアログが開くので[アドオン]タブを開きます。
[Auto Mirror]を検索します。

一覧にアドオンが表示されるので、チェックを入れて有効化します。
これでアドオンのインストールは完了です。

アドオンを有効化すると[3Dビュー]のサイドバーに[編集]->[Auto Mirror]パネルが追加されます。

オブジェクトをミラーする

Auto Mirror アドオンを使ってオブジェクトをミラーしてみます。
以下のような軸中央に頂点の無いモデルを用意しました。

ミラーするオブジェクトを選択し、サイドバーの[編集]->[Auto Mirror]を開きます。
XYZ の軸方向を指定して[AutoMirror]を実行します。

これでオブジェクトがミラーされます。

ワイヤーフレームで確認すると、中央部分に頂点が作成された上でミラーが設定されていることが分かります。

最新バージョンの取得

ビルドインのアドオンはバージョン 2.5.2 のものになっています。
2020/06/30現在、最新バージョン 2.9.2 が公開されています。
Auto Mirror アドオンの最新バージョンは以下で購入できます。
gumroad.com

最新バージョンで追加されている機能については以下のページが参考になります。
bookyakuno.com

Blender2.8で利用可能なpythonスクリプトを作る その４５（カーブオブジェクトの長さ）

本日は Blender の技術調査枠です。
Blender2.8で利用可能なpythonスクリプトを作ります。

カーブオブジェクトの長さ

カーブオブジェクトの長さを計算します。
複製したカーブオブジェクトをメッシュオブジェクトに変換して計算を行います。
メッシュオブジェクトは自動で削除されます。
・get_length_curve.py

# bpyインポート
import bpy

# 指定カーブオブジェクトの長さを取得する
def get_length_curve(arg_objectname="Default") -> float:
    """カーブオブジェクトの長さを計算する

    Args:
        arg_objectname (str, optional): 指定オブジェクト名. Defaults to "Default".

    Returns:
        float: カーブオブジェクトの長さ
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
        
    # オブジェクトがカーブであるか確認する
    if selectob.type != 'CURVE':
        # 指定オブジェクトがカーブでない場合は処理しない
        return False
    
    # 全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)
    
    # 指定オブジェクトを選択状態に変更する
    selectob.select_set(True)

    # オブジェクトを複製する
    bpy.ops.object.duplicate_move()

    # 複製オブジェクトを取得する
    duplicatob = bpy.context.scene.objects[-1]
    
    # 指定オブジェクトを選択状態に変更する
    selectob.select_set(False)

    # 指定オブジェクトを選択状態に変更する
    duplicatob.select_set(True)

    # カーブオブジェクトをメッシュオブジェクトに変換する
    bpy.ops.object.convert(target='MESH')

    # メッシュ情報を再取得する
    mesh = duplicatob.data

    # 辺情報を取得する
    edges = mesh.edges.values()

    # 頂点情報を取得する
    vertices = mesh.vertices.values()

    # 辺の長さの変数を初期化する
    curve_lenght = 0.0

    for edge in edges:
        # 辺の開始と終端の頂点を取得する
        vert_start, vert_end = edge.vertices

        # 辺の長さを計算する
        edge_length = (vertices[vert_start].co - vertices[vert_end].co).length

        # カーブ全体の長さに辺の長さを加算する
        curve_lenght = curve_lenght + edge_length

    # 複製オブジェクトを削除する
    bpy.data.objects.remove(duplicatob)

    return curve_lenght

# 関数の実行例
length = get_length_curve(arg_objectname="BezierCurve")
print("Curve_Length : " + str(length))

アドオンバージョン

上記スクリプトをアドオン化してみました。
追加されるパネルのオブジェクトリストからカーブオブジェクトを選択し、実行ボタンをクリックします。
すると、数値欄に対象カーブオブジェクトの長さが表示されます。
・Addon_get_length_curve.py

# bl_infoでプラグインに関する情報の定義を行う
bl_info = {
    "name": "HoloMon Curve Check Addon",             # プラグイン名
    "author": "HoloMon",                             # 制作者名
    "version": (1, 0),                               # バージョン
    "blender": (2, 80, 0),                           # 動作可能なBlenderバージョン
    "support": "TESTING",                            # サポートレベル
    "category": "3D View",                           # カテゴリ名
    "location": "View3D > Sidebar > HoloMon",        # ロケーション
    "description": "Addon Curve Check",              # 説明文
    "location": "",                                  # 機能の位置付け
    "warning": "",                                   # 注意点やバグ情報
    "doc_url": "",                                   # ドキュメントURL
}

# 利用するタイプやメソッドのインポート
import bpy
from bpy.types import Operator, Panel, PropertyGroup
from bpy.props import PointerProperty, FloatProperty

# 継承するクラスの命名規則は以下の通り
# [A-Z][A-Z0-9_]*_(継承クラスごとの識別子)_[A-Za-z0-9_]+
# クラスごとの識別子は以下の通り
#   bpy.types.Operator  OT
#   bpy.types.Panel     PT
#   bpy.types.Header    HT
#   bpy.types.MENU      MT
#   bpy.types.UIList    UL

# Panelクラスの作成
# 参考URL:https://docs.blender.org/api/current/bpy.types.Panel.html
class HOLOMON_PT_addon_curve_check(Panel):
    # パネルのラベル名を定義する
    # パネルを折りたたむパネルヘッダーに表示される
    bl_label = "Curve Check Addon Panel"
    # クラスのIDを定義する
    # 命名規則は CATEGORY_PT_name
    bl_idname = "HOLOMON_PT_addon_curve_check"
    # パネルを使用する領域を定義する
    # 利用可能な識別子は以下の通り
    #   EMPTY：無し
    #   VIEW_3D：3Dビューポート
    #   IMAGE_EDITOR：UV/画像エディター
    #   NODE_EDITOR：ノードエディター
    #   SEQUENCE_EDITOR：ビデオシーケンサー
    #   CLIP_EDITOR：ムービークリップエディター
    #   DOPESHEET_EDITOR：ドープシート
    #   GRAPH_EDITOR：グラフエディター
    #   NLA_EDITOR：非線形アニメーション
    #   TEXT_EDITOR：テキストエディター
    #   CONSOLE：Pythonコンソール
    #   INFO：情報、操作のログ、警告、エラーメッセージ
    #   TOPBAR：トップバー
    #   STATUSBAR：ステータスバー
    #   OUTLINER：アウトライナ
    #   PROPERTIES：プロパティ
    #   FILE_BROWSER：ファイルブラウザ
    #   PREFERENCES：設定
    bl_space_type = 'VIEW_3D'
    # パネルが使用される領域を定義する
    # 利用可能な識別子は以下の通り
    # ['WINDOW'、 'HEADER'、 'CHANNELS'、 'TEMPORARY'、 'UI'、
    #  'TOOLS'、 'TOOL_PROPS'、 'PREVIEW'、 'HUD'、 'NAVIGATION_BAR'、
    #  'EXECUTE'、 'FOOTER'の列挙型、 'TOOL_HEADER']
    bl_region_type = 'UI'
    # パネルタイプのオプションを定義する
    # DEFAULT_CLOSED：作成時にパネルを開くか折りたたむ必要があるかを定義する。
    # HIDE_HEADER：ヘッダーを非表示するかを定義する。Falseに設定するとパネルにはヘッダーが表示される。
    # デフォルトは {'DEFAULT_CLOSED'}
    bl_options = {'DEFAULT_CLOSED'}
    # パネルの表示順番を定義する
    # 小さい番号のパネルは、大きい番号のパネルの前にデフォルトで順序付けられる
    # デフォルトは 0
    bl_order = 0
    # パネルのカテゴリ名称を定義する
    # 3Dビューポートの場合、サイドバーの名称になる
    # デフォルトは名称無し
    bl_category = "HoloMon"
 
    # 描画の定義
    def draw(self, context):
        # Operatorをボタンとして配置する
        draw_layout = self.layout
        # 要素行を作成する
        select_row = draw_layout.row()
        # オブジェクト選択用のカスタムプロパティを配置する
        select_row.prop(context.scene.holomon_curvecheck, "prop_objectslect", text='')
        # 要素行を作成する
        length_row = draw_layout.row()
        # カーブオブジェクトの長さ表示用のカスタムプロパティを配置する
        length_row.prop(context.scene.holomon_curvecheck, "prop_curvelength")
        # 操作を無効化しておく
        length_row.enabled = False
        # 要素行を作成する
        button_row = draw_layout.row()
        # オブジェクト指定のサイズ縮小を実行するボタンを配置する
        button_row.operator("holomon.curvecheck")

# Operatorクラスの作成
# 参考URL:https://docs.blender.org/api/current/bpy.types.Operator.html
class HOLOMON_OT_addon_curve_check(Operator):
    # クラスのIDを定義する
    # (Blender内部で参照する際のIDに利用)
    bl_idname = "holomon.curvecheck"
    # クラスのラベルを定義する
    # (デフォルトのテキスト表示などに利用)
    bl_label = "CURVE CHECK"
    # クラスの説明文
    # (マウスオーバー時に表示)
    dl_description = "Curve Check Addon Description"
    # クラスの属性
    # 以下の属性を設定できる
    #   REGISTER      : Operatorを情報ウィンドウに表示し、やり直しツールバーパネルをサポートする
    #   UNDO          : 元に戻すイベントをプッシュする（Operatorのやり直しに必要）
    #   UNDO_GROUPED  : Operatorの繰り返しインスタンスに対して単一の取り消しイベントをプッシュする
    #   BLOCKING      : 他の操作がマウスポインタ―を使用できないようにブロックする
    #   MACRO         : Operatorがマクロであるかどうかを確認するために使用する
    #   GRAB_CURSOR   : 継続的な操作が有効な場合にオペレーターがマウスポインターの動きを参照して、操作を有効にする
    #   GRAB_CURSOR_X : マウスポインターのX軸の動きのみを参照する
    #   GRAB_CURSOR_Y : マウスポインターのY軸の動きのみを参照する
    #   PRESET        : Operator設定を含むプリセットボタンを表示する
    #   INTERNAL      : 検索結果からOperatorを削除する
    # 参考URL:https://docs.blender.org/api/current/bpy.types.Operator.html#bpy.types.Operator.bl_options
    bl_options = {'REGISTER', 'UNDO'}


    # Operator実行時の処理
    def execute(self, context):
        # カスタムプロパティから指定中のオブジェクトを取得する
        target_obj = context.scene.holomon_curvecheck.prop_objectslect

        # 指定中のオブジェクトを確認する
        if target_obj == None:
            # オブジェクトが指定されていない場合はエラーメッセージを表示する
            self.report({'ERROR'}, "No objects selected.")
            return {'CANCELLED'}

        # 指定のカーブオブジェクトの長さを取得する
        length = get_length_curve(arg_selectobj=target_obj)

        # カスタムプロパティにカーブの長さを設定する
        context.scene.holomon_curvecheck.prop_curvelength = length

        return {'FINISHED'}

# PropertyGroupクラスの作成
# 参考URL:https://docs.blender.org/api/current/bpy.types.PropertyGroup.html
class HOLOMON_addon_curve_check_properties(PropertyGroup):
    # オブジェクト選択時のチェック関数を定義する
    def prop_object_select_poll(self, context, ):
        # カーブオブジェクトのみ選択可能
        if(context and context.type in ('CURVE', )):
            return True
        return False

    # シーン上のパネルに表示するオブジェクト選択用のカスタムプロパティを定義する
    prop_objectslect: PointerProperty(
        name = "Select Object",         # プロパティ名
        type = bpy.types.Object,        # タイプ
        description = "",               # 説明文
        poll = prop_object_select_poll, # チェック関数
    )

    # シーン上のパネルに表示するオブジェクト選択用のカスタムプロパティを定義する
    prop_curvelength: FloatProperty(
        name = "Curve Length",         # プロパティ名
        description = "",               # 説明文
    )


# 登録に関する処理
# 登録対象のクラス名
regist_classes = (
    HOLOMON_PT_addon_curve_check,
    HOLOMON_OT_addon_curve_check,
    HOLOMON_addon_curve_check_properties,
)

# 作成クラスと定義の登録メソッド
def register():
    # カスタムクラスを登録する
    for regist_cls in regist_classes:
        bpy.utils.register_class(regist_cls)
    # シーン情報にカスタムプロパティを登録する
    bpy.types.Scene.holomon_curvecheck = PointerProperty(type=HOLOMON_addon_curve_check_properties)

# 作成クラスと定義の登録解除メソッド
def unregister():
    # シーン情報のカスタムプロパティを削除する
    del bpy.types.Scene.holomon_curvecheck
    # カスタムクラスを解除する
    for regist_cls in regist_classes:
        bpy.utils.unregister_class(regist_cls)


# 指定カーブオブジェクトの長さを取得する
def get_length_curve(arg_selectobj: bpy.types.Object) -> float:
    """カーブオブジェクトの長さを計算する

    Args:
        arg_selectobj (bpy.types.Object): 指定オブジェクト

    Returns:
        float: カーブオブジェクトの長さ
    """

    # 指定オブジェクトが存在するか確認する
    if arg_selectobj == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
        
    # オブジェクトがカーブであるか確認する
    if arg_selectobj.type != 'CURVE':
        # 指定オブジェクトがカーブでない場合は処理しない
        return False
    
    # 全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)
    
    # 指定オブジェクトを選択状態に変更する
    arg_selectobj.select_set(True)

    # オブジェクトを複製する
    bpy.ops.object.duplicate_move()

    # 複製オブジェクトを取得する
    duplicatob = bpy.context.scene.objects[-1]
    
    # 指定オブジェクトを選択状態に変更する
    arg_selectobj.select_set(False)

    # 指定オブジェクトを選択状態に変更する
    duplicatob.select_set(True)

    # カーブオブジェクトをメッシュオブジェクトに変換する
    bpy.ops.object.convert(target='MESH')

    # メッシュ情報を再取得する
    mesh = duplicatob.data

    # 辺情報を取得する
    edges = mesh.edges.values()

    # 頂点情報を取得する
    vertices = mesh.vertices.values()

    # 辺の長さの変数を初期化する
    curve_lenght = 0.0

    for edge in edges:
        # 辺の開始と終端の頂点を取得する
        vert_start, vert_end = edge.vertices

        # 辺の長さを計算する
        edge_length = (vertices[vert_start].co - vertices[vert_end].co).length

        # カーブ全体の長さに辺の長さを加算する
        curve_lenght = curve_lenght + edge_length

    # 複製オブジェクトを削除する
    bpy.data.objects.remove(duplicatob)

    return curve_lenght


# 実行時の処理
if __name__ == "__main__":
    # 作成クラスと定義を登録する
    register()

Bevel Curve Toolsアドオンを使ってBlenderで髪の毛オブジェクトを作る その５（UVマップの調整）

本日は Blender の小ネタ枠です。
Bevel Curve Tools アドオンを使ってBlenderで髪の毛オブジェクトを作る手順を記事にします。

前回記事の続きです。
bluebirdofoz.hatenablog.com

UVマップの調整

毛並の方向を揃える

この状態で改めてUVマップを確認すると左右でUVマップの上下が反転していることが分かります。
毛並みの方向を揃えたいのでメッシュ上下の両端位置はUVマップ上の同じ位置に固定します。

[編集モード]で上下両端のUVマップの頂点を選択します。
頂点を固定したい位置に移動させ、[UV]->[ピン止め]で位置を固定します。

この状態で改めてUV展開を実行します。
すると同じ方向に毛並みが流れる形でUVマップを作成できました。

メッシュサイズとの比率を合わせる

UVマップの方向を揃えることができましたが、自動で展開したため、マップのサイズが各オブジェクトで最大になっています。
このため、小さいオブジェクトではテクスチャの解像度が高く、大きいオブジェクトでは低くなってしまいます。

[UVエディター]上で頂点を全選択して[拡大縮小]を実行し、サイズをオブジェクトとのサイズ比に合わせます。

処理の自動化

上記の作業を全てのメッシュに実施します。
こちらの作業もスクリプト化しました。

毛並の方向を揃える処理

以下の記事の python スクリプトの関数を全てのオブジェクトに対して処理を行います。
bluebirdofoz.hatenablog.com

実行スクリプト例（クリックで展開）

# bpyインポート
import bpy
# メッシュ操作のため
import bmesh

# 選択中の頂点のUVマップの頂点を指定の位置に移動する
def move_UVmap_selected(arg_objectname="Default", arg_uvname="UVMap", arg_uvpos=[0.0, 0.0]) -> bool:
    """選択中の頂点のUVマップの頂点をピン止めする

    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})
        arg_uvname {str} -- 指定UVマップ名 (default: {"UVMap"})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False

    # 指定オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 元々の操作モードを記録する
    befmode = bpy.context.active_object.mode

    # 編集モードに移行する
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)

    # Bメッシュデータを取得する
    # Bメッシュアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMesh)
    bmeshdata = bmesh.from_edit_mesh(selectob.data)

    # UVレイヤーの参照を取得する
    # レイヤーアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMLayerAccessLoop)
    targetuvlayer = bmeshdata.loops.layers.uv.get(arg_uvname)

    # 指定UVマップが存在するか確認する
    if targetuvlayer == None:
        # 指定UVマップが存在しない場合は処理しない
        return False

    # メッシュの面の参照からUVマップの頂点を編集する
    # 面の参照を取得する
    # 面アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMFace)
    for face in bmeshdata.faces:
        # 要素の参照を取得する
        # 要素アクセスのマニュアル
        # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMElemSeq)
        for loop in face.loops:
            # 頂点が選択中か否か判定する
            if loop.vert.select == True:
                # UVレイヤーの参照を取得する
                loop_uv = loop[targetuvlayer]

                # 頂点のUV情報を取得して座標を設定する
                # UV情報アクセスのマニュアル
                # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMLoopUV)
                loop_uv.uv = arg_uvpos

    # メッシュ情報を更新する
    bmesh.update_edit_mesh(selectob.data)

    # 変更前のモードに移行する
    bpy.ops.object.mode_set(mode=befmode)

    return True

# 選択中の頂点のUVマップの頂点をピン止めする
def pin_UVmap_selected(arg_objectname="Default", arg_uvname="UVMap") -> bool:
    """選択中の頂点のUVマップの頂点をピン止めする

    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})
        arg_uvname {str} -- 指定UVマップ名 (default: {"UVMap"})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False

    # 指定オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 元々の操作モードを記録する
    befmode = bpy.context.active_object.mode

    # 編集モードに移行する
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)

    # Bメッシュデータを取得する
    # Bメッシュアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMesh)
    bmeshdata = bmesh.from_edit_mesh(selectob.data)

    # UVレイヤーの参照を取得する
    # レイヤーアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMLayerAccessLoop)
    targetuvlayer = bmeshdata.loops.layers.uv.get(arg_uvname)

    # 指定UVマップが存在するか確認する
    if targetuvlayer == None:
        # 指定UVマップが存在しない場合は処理しない
        return False

    # メッシュの面の参照からUVマップの頂点を編集する
    # 面の参照を取得する
    # 面アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMFace)
    for face in bmeshdata.faces:
        # 要素の参照を取得する
        # 要素アクセスのマニュアル
        # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMElemSeq)
        for loop in face.loops:
            # 頂点が選択中か否か判定する
            if loop.vert.select == True:
                # UVレイヤーの参照を取得する
                loop_uv = loop[targetuvlayer]

                # 頂点のUV情報を取得してピンを設定する
                # UV情報アクセスのマニュアル
                # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMLoopUV)
                loop_uv.pin_uv = True

    # メッシュ情報を更新する
    bmesh.update_edit_mesh(selectob.data)

    # 変更前のモードに移行する
    bpy.ops.object.mode_set(mode=befmode)

    return True

# Y軸座標が最大または最小の座標の頂点を選択する
def select_vert_Ytip(arg_objectname="Default", arg_uvname="UVMap", arg_max=False, arg_selectmargin=0.01) -> bool:
    """Y軸座標が最大または最小の座標の頂点を選択する

    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})
        arg_uvname {str} -- 指定UVマップ名 (default: {"UVMap"})
        arg_max {bool} -- 最大値の端か否か (default: {True})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False

    # 指定オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 元々の操作モードを記録する
    befmode = bpy.context.active_object.mode

    # 編集モードに移行する
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)

    # Bメッシュデータを取得する
    # Bメッシュアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMesh)
    bmeshdata = bmesh.from_edit_mesh(selectob.data)

    # 選択モードを頂点選択モードにする
    bmeshdata.select_mode = {'VERT'}

    # 頂点を走査する
    # 頂点アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMVert)
    for vert in bmeshdata.verts:
        # 全ての頂点は一旦選択状態を解除する
        vert.select = False

    # Y座標の比較用変数を初期化
    Ytip_pos = 0.0
    Ytip_checked = False
    
    # 頂点を走査する
    # 頂点アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMVert)
    for vert in bmeshdata.verts:
        # 1つ目の座標は基準として取得する
        if Ytip_checked == False:
            # 座標の値とインデックスを取得する
            Ytip_pos = vert.co[1]
            Ytip_checked = True
        else:
            # Y軸座標が最大または最小の座標かチェックする
            if (vert.co[1] > Ytip_pos) == arg_max:
                # 座標の値とインデックスを取得する
                Ytip_pos = vert.co[1]

    # インデックス参照のため、テーブルを初期化する
    bmeshdata.verts.ensure_lookup_table()

    # 再び頂点を走査する
    for vert in bmeshdata.verts:
        # Y軸座標が最大または最小の座標を選択する
        if arg_max:
            if (vert.co[1] > (Ytip_pos - arg_selectmargin)):
                vert.select = True
        else:
            if ((Ytip_pos + arg_selectmargin) > vert.co[1]):
                vert.select = True

    # 辺または面の選択状態を更新する
    bmeshdata.select_flush_mode()

    # 変更前のモードに移行する
    bpy.ops.object.mode_set(mode=befmode)

    return True

# UV展開を実行する(デフォルト設定)
def project_UVmap_mesh(arg_objectname="Default") -> bool:
    """UV展開を実行する(デフォルト設定)

    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False
    
    # 不要なオブジェクトを選択しないように
    # 全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)

    # 指定のオブジェクトのみを選択状態にする
    selectob.select_set(True)

    # 対象オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 元々の操作モードを記録する
    befmode = bpy.context.active_object.mode

    # 編集モードに移行する
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)
   
    # 頂点を全選択した状態とする
    bpy.ops.mesh.select_all(action='SELECT')

    # デフォルト設定のUV展開を実行する
    bpy.ops.uv.unwrap()

    # オブジェクトモードに移行する
    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
   
    # 変更前のモードに移行する
    bpy.ops.object.mode_set(mode=befmode)

    return


# 全データオブジェクトのUVマップを展開する
for item in bpy.data.objects:
    # メッシュのUVマップを展開する
    project_UVmap_mesh(arg_objectname=item.name)

    # メッシュ上のY軸下端の頂点を選択する
    select_vert_Ytip(arg_objectname=item.name, arg_uvname="UVMap", arg_max=False)

    # 対応するUVメッシュの頂点座標を移動する
    move_UVmap_selected(arg_objectname=item.name, arg_uvname="UVMap", arg_uvpos=[0.5, 0.0])

    # 対応するUVメッシュの頂点座標をピン止めする
    pin_UVmap_selected(arg_objectname=item.name, arg_uvname="UVMap")

    # メッシュ上のY軸上端の頂点を選択する
    select_vert_Ytip(arg_objectname=item.name, arg_uvname="UVMap", arg_max=True)

    # 対応するUVメッシュの頂点座標を移動する
    move_UVmap_selected(arg_objectname=item.name, arg_uvname="UVMap", arg_uvpos=[0.5, 1.0])

    # 対応するUVメッシュの頂点座標をピン止めする
    pin_UVmap_selected(arg_objectname=item.name, arg_uvname="UVMap")

    # メッシュのUVマップを再展開する
    project_UVmap_mesh(arg_objectname=item.name)

毛並の方向を揃える処理

以下の記事の python スクリプトの関数を全てのオブジェクトに対して処理を行います。
bluebirdofoz.hatenablog.com

実行スクリプト例（クリックで展開）

# bpyインポート
import bpy
# メッシュ操作のため
import bmesh
# numpyインポート(ベクトルの長さ計算のため)
import numpy as np

# オブジェクトのバウンドボックスから指定軸の対角線の長さを計算する
def get_object_diagonal(arg_objectname="Default", arg_x=True, arg_Y=True, arg_Z=True) -> float:
    """オブジェクトのバウンドボックスから対角線の長さを計算する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})
        arg_x {bool} -- X軸の指定 (default: {True})
        arg_Y {bool} -- Y軸の指定 (default: {True})
        arg_Z {bool} -- Z軸の指定 (default: {True})

    Returns:
        float -- 対角線の長さ
    """
    
    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return 0.0

    # X軸の寸法の取得
    dimension_x = 0.0
    if arg_x:
        dimension_x = selectob.dimensions[0]
    
    # Y軸の寸法の取得
    dimension_y = 0.0
    if arg_Y:
        dimension_y = selectob.dimensions[1]

    # Z軸の寸法の取得
    dimension_z = 0.0
    if arg_Z:
        dimension_z = selectob.dimensions[2]
    
    # 対角線の配列を取得する
    dimension = np.array([dimension_x, dimension_y, dimension_z])

    # 対角線の長さを取得する
    diagonal = np.linalg.norm(dimension)

    return diagonal

# UVマップを指定値で拡大縮小する
def change_UVmap_scale(arg_objectname="Default", arg_uvname="UVMap", arg_scale=1.0) -> bool:
    """UVマップを指定値で拡大縮小する

    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})
        arg_uvname {str} -- 指定UVマップ名 (default: {"UVMap"})
        arg_scale {float} -- 拡大縮小倍率 (default: {1.0})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False

    # 指定オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 元々の操作モードを記録する
    befmode = bpy.context.active_object.mode

    # 編集モードに移行する
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)

    # Bメッシュデータを取得する
    # Bメッシュアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMesh)
    bmeshdata = bmesh.from_edit_mesh(selectob.data)

    # UVレイヤーの参照を取得する
    # レイヤーアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMLayerAccessLoop)
    targetuvlayer = bmeshdata.loops.layers.uv.get(arg_uvname)

    # 指定UVマップが存在するか確認する
    if targetuvlayer == None:
        # 指定UVマップが存在しない場合は処理しない
        return False

    # メッシュの面の参照からUVマップの頂点を編集する
    # 面の参照を取得する
    # 面アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMFace)
    for face in bmeshdata.faces:
        # 要素の参照を取得する
        # 要素アクセスのマニュアル
        # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMElemSeq)
        for loop in face.loops:
            # UVレイヤーの参照を取得する
            loop_uv = loop[targetuvlayer]

            # 頂点のUV情報を取得して座標を拡大縮小する
            # UV情報アクセスのマニュアル
            # (https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMLoopUV)
            loop_uv.uv[0] *= arg_scale
            loop_uv.uv[1] *= arg_scale

            # 中心位置を調整する
            if arg_scale > 1.0:
                loop_uv.uv[0] -= ((arg_scale - 1.0) / 2.0)
                loop_uv.uv[1] -= ((arg_scale - 1.0) / 2.0)
            else:
                loop_uv.uv[0] += ((1.0 - arg_scale) / 2.0)
                loop_uv.uv[1] += ((1.0 - arg_scale) / 2.0)

    # メッシュ情報を更新する
    bmesh.update_edit_mesh(selectob.data)

    # 変更前のモードに移行する
    bpy.ops.object.mode_set(mode=befmode)

    return True


# 最大サイズのオブジェクト長を取得する
max_size = 0.0
for item in bpy.data.objects:
    get_size = get_object_diagonal(arg_objectname=item.name, arg_x=True, arg_Y=True, arg_Z=True)
    if get_size > max_size:
        max_size = get_size

# 最大サイズのオブジェクトとの比率に合わせてUVマップのサイズを調整する
for item in bpy.data.objects:
    get_size = get_object_diagonal(arg_objectname=item.name, arg_x=True, arg_Y=True, arg_Z=True)
    change_size = get_size / max_size
    change_UVmap_scale(arg_objectname=item.name, arg_uvname="UVMap", arg_scale=change_size)

これでBevel Curve Tools アドオンを使って作ったオブジェクトを元に、毛皮オブジェクトを作成することができました。

Bevel Curve Toolsアドオンを使ってBlenderで髪の毛オブジェクトを作る その４（テクスチャの反映）

本日は Blender の小ネタ枠です。
Bevel Curve Tools アドオンを使ってBlenderで髪の毛オブジェクトを作る手順を記事にします。

前回記事の続きです。
bluebirdofoz.hatenablog.com

テクスチャの反映

今回は髪の毛オブジェクトにテクスチャを反映して、より髪の毛っぽい見た目にしていきます。
毛並の方向を揃えるため、個々のオブジェクト毎にテクスチャの反映を行っていきます。

UVマップを展開してマテリアルを設定する

既にメッシュを上下で分離しているのでそのままUV展開を行います。
[編集モード]に切り替えて、全ての面を選択した状態で[UV]->[展開]を実行し、UVマップを展開します。

次にマテリアルを設定します。
[マテリアル]タブを開き、[新規]ボタンでマテリアルを作成します。

マテリアルが生成されたらテクスチャを設定します。
[ベースカラー]のプルダウンを開き、[画像テクスチャ]を選択します。

[開く]ボタンでファイル選択ダイアログを開き、反映するテクスチャを選択します。

これでテクスチャが反映できました。
テクスチャを反映した状態の見た目は[3Dビューのシェーディング]を[マテリアルプレビュー]に変更することで確認できます。

別オブジェクトのマテリアルを設定する

別オブジェクトもテクスチャを反映していきます。
2つ目以降のオブジェクトは先ほど作成したマテリアルを選択して反映します。

処理の自動化

上記の作業を全てのメッシュに実施します。
こちらの作業もスクリプト化しました。
以下の記事の python スクリプトを元にマテリアルの作成と全オブジェクトへのマテリアル反映を行いました。
bluebirdofoz.hatenablog.com

実行スクリプト例（クリックで展開）

# bpyインポート
import bpy
# パス操作のため
import os

# 指定オブジェクトに指定テクスチャを設定したプリンシプルBSDFマテリアルを作成する
def new_bsdfmaterial_texture(arg_materialname="TextureMaterial", arg_texturepath="") -> bool:
    """指定テクスチャを設定したプリンシプルBSDFマテリアルを作成する

    Args:
        arg_materialname (str, optional): 作成マテリアル名. Defaults to "TextureMaterial".
        arg_texturepath (str, optional): 参照テクスチャパス. Defaults to "".

    Returns:
        bool: 実行正否
    """

    # テクスチャパスを確認する
    if arg_texturepath == "":
        # テクスチャパスが未設定の場合は処理しない
        return False

    # テクスチャの存在確認を行う
    if os.path.isfile(arg_texturepath) != True:
        # 指定テクスチャが存在しない場合は処理しない
        return False

    # 指定名のマテリアルを取得する
    check_mat = bpy.data.materials.get(arg_materialname)

    # 指定名のマテリアルが存在するか確認する
    if check_mat != None:
        # 指定名のマテリアルが既に存在する場合は処理しない
        return False

    # 新規マテリアルを作成する
    newmaterial = bpy.data.materials.new(arg_materialname)

    # ノードを使用する
    newmaterial.use_nodes = True

    # 処理対象のマテリアルを取得する
    target_mat = newmaterial

    # ターゲットマテリアルのノード参照を取得
    mat_nodes = target_mat.node_tree.nodes

    # マテリアル内の全ノードを走査する
    for delete_node in mat_nodes:
        # 一旦デフォルトのノードを全て削除する
        mat_nodes.remove(delete_node)
    
    # テクスチャノードの追加
    texture_node = mat_nodes.new(type="ShaderNodeTexImage")

    # テクスチャノードをアクティブにする
    mat_nodes.active = texture_node

    # 指定画像を読み込む
    loadimage = bpy.data.images.load(filepath=arg_texturepath)

    # テクスチャノードに新規画像を設定する
    texture_node.image = loadimage

    # ノードリンクの取得
    mat_link = target_mat.node_tree.links

    # プリンシプルBSDFノードを追加する
    bsdf_node = mat_nodes.new(type="ShaderNodeBsdfPrincipled")

    # 出力ノードを追加する
    output_node = mat_nodes.new(type="ShaderNodeOutputMaterial")

    # テクスチャノードのカラーとプリンシプルBSDFノードのベースカラーを接続する
    mat_link.new(texture_node.outputs[0], bsdf_node.inputs[0])
    
    # 放射ノードの放射と出力ノードのサーフェスを接続する
    mat_link.new(bsdf_node.outputs[0], output_node.inputs[0])

    return True

# 指定オブジェクトの全マテリアルを削除する
def delete_material_all(arg_objectname="Default") -> bool:
    """指定オブジェクトに新規マテリアルを作成する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})

    Returns:
        Bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # 指定オブジェクトがメッシュオブジェクトか確認する
    if selectob.type != 'MESH':
        # メッシュオブジェクトでない場合は処理しない
        return False

    # オブジェクトをアクティブにする
    bpy.context.view_layer.objects.active = selectob

    # マテリアルスロットを走査する
    for material_slot in selectob.material_slots:

        # マテリアルスロットをアクティブにする
        selectob.active_material = material_slot.material

        # マテリアルスロットを削除する
        bpy.ops.object.material_slot_remove()
    
    return True

# 指定オブジェクトに指定名のマテリアルを追加する
def add_material_target(arg_objectname="Default",
      arg_materialname="NewMaterial", arg_usenode=True) -> bool:
    """指定オブジェクトに新規マテリアルを作成する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})
        arg_materialname {str} -- 追加マテリアル名 (default: {"NewMaterial"})
        arg_usenode {bool} -- ノード利用の有無 (default: {True})

    Returns:
        Bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # 指定オブジェクトがメッシュオブジェクトか確認する
    if selectob.type != 'MESH':
        # メッシュオブジェクトでない場合は処理しない
        return False

    # オブジェクトをアクティブにする
    bpy.context.view_layer.objects.active = selectob

    # 指定名のマテリアルを取得する
    add_mat = bpy.data.materials.get(arg_materialname)

    # 指定名のマテリアルが存在するか確認する
    if add_mat == None:
        # 指定名のマテリアルが存在しない場合は新規マテリアルを作成する
        add_mat = bpy.data.materials.new(arg_materialname)

        # ノードの利用指定を確認する
        if arg_usenode == True:
            # ノードを使用する
            add_mat.use_nodes = True

    # 指定名のマテリアルスロットを取得する
    check_matslot = selectob.material_slots.get(arg_materialname)

    # 指定マテリアルが存在するか確認する
    if check_matslot != None:
        # 指定名のマテリアルスロットが既に存在する場合は処理しない
        return False

    # マテリアルスロットを追加する
    bpy.ops.object.material_slot_add()

    # 追加したマテリアルスロットに指定名のマテリアルを設定する
    selectob.active_material = add_mat

    return True


# 現在のblendファイルが存在するディレクトリパスを取得する
# 未保存のプロジェクト上で実行すると、空文字が返る
def get_blend_dirpath() -> str:
    """現在のblendが存在するディレクトリパスを取得する
    未保存のプロジェクト上で実行すると、空文字が返る

    Returns:
        str: blendディレクトリパス
    """

    # blendファイルのパスを取得
    filepath = bpy.data.filepath

    # 空文字が返った場合は処理せず終了する
    if filepath == "":
        return ""

    # ディレクトリパスを取得する
    dirpath = os.path.dirname(filepath)

    return dirpath

# UV展開を実行する(デフォルト設定)
def project_UVmap_mesh(arg_objectname="Default") -> bool:
    """UV展開を実行する(デフォルト設定)

    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False
    
    # 不要なオブジェクトを選択しないように
    # 全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)

    # 指定のオブジェクトのみを選択状態にする
    selectob.select_set(True)

    # 対象オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 元々の操作モードを記録する
    befmode = bpy.context.active_object.mode

    # 編集モードに移行する
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)
   
    # 頂点を全選択した状態とする
    bpy.ops.mesh.select_all(action='SELECT')

    # デフォルト設定のUV展開を実行する
    bpy.ops.uv.unwrap()

    # オブジェクトモードに移行する
    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
   
    # 変更前のモードに移行する
    bpy.ops.object.mode_set(mode=befmode)

    return

# マテリアル名を設定する
materialname = "TextureMaterial"
# テクスチャパスを作成する
texturepath = get_blend_dirpath() + "\\Texture\\Fur_Texture_1024.png"
# 作成マテリアルにプリンシプルBSDFノードを追加して画像ノードをカラーとして接続する
new_result = new_bsdfmaterial_texture(arg_materialname=materialname, arg_texturepath=texturepath)

# 全オブジェクトのUVマップを展開してマテリアルを設定する
for item in bpy.data.objects:
    project_UVmap_mesh(arg_objectname=item.name)
    delete_material_all(arg_objectname=item.name)
    add_material_target(arg_objectname=item.name, arg_materialname=materialname)

次はUVマップの調整を行います。
bluebirdofoz.hatenablog.com

Bevel Curve Toolsアドオンを使ってBlenderで髪の毛オブジェクトを作る その３（辺分離によるスムースシェードの修正）

本日は Blender の小ネタ枠です。
Bevel Curve Tools アドオンを使ってBlenderで髪の毛オブジェクトを作る手順を記事にします。

前回記事の続きです。
bluebirdofoz.hatenablog.com

陰影を修正する

スムーズシェードの影響を確認する

改めてオブジェクトを確認すると、淵の部分の陰影がおかしくなっている事に気付きます。
これは頂点数を削減したところにスムーズシェードを利用しているため、淵近くの法線が大きく歪んでいることが原因です。

試しにスムーズシェードを無効化してみると、淵の部分のほとんどは本来、影が落ちないことが分かります。
シェードはオブジェクト毎に[オブジェクト]のプルダウンから[フラットシェード]または[スムースシェード]を選択できます。

この縁の部分についてスムーズシェードを無効化します。
スムーズシェードは辺の分離を行うことにより、無効化できます。

シャープを設定する

スムーズシェードを無効化したい辺にシャープを設定していきます。
[編集モード]で辺を選択します。

辺を選択した状態で [辺] -> [シャープをマーク] を設定します。
（画像差し込み_87）

これで縁の部分にシャープが設定されました。

辺分離モディファイアを設定する

[オブジェクトモード]に戻ります。
アウトライナーウィンドウから対象のオブジェクトを選択して[モディファイア]タブを開きます。

[モディファイアーを追加]プルダウンを開き、[辺分離]モディファイアを選択します。

[辺分離]モディファイアが追加されたら、辺分離の対象で[シャープな辺]にチェックを入れます。
これで縁の部分にスムーズシェードがかからなくなり、綺麗な陰影になります。

最後に[辺分離]モディファイアを[適用]します。

処理の自動化

上記の作業を全てのメッシュに実施します。
こちらの作業もスクリプト化しました。
以下の記事の python スクリプトの関数を全てのオブジェクトに対して処理を行います。
bluebirdofoz.hatenablog.com

実行スクリプト例（クリックで展開）

# bpyインポート
import bpy
# メッシュ操作のため
import bmesh

# Z軸の法線方向が上向きの面と下向きの面の境界の辺にシーム/シャープ/クリース/ベベルを設定する
def mark_edges_Znormal(arg_objectname="Default",
  arg_seam=False, arg_sharp=False, arg_crease=False, arg_bevel=False) -> bool:
    """Z軸の法線方向が上向きの面と下向きの面の境界の辺にシーム/シャープ/クリース/ベベルを設定する

    Keyword Arguments:
        arg_objectname {str} -- [description] (default: {"Default"})
        arg_seam {bool} -- シームの設定有無 (default: {False})
        arg_sharp {bool} -- シャープの設定有無 (default: {False})
        arg_crease {bool} -- クリースの設定有無 (default: {False})
        arg_bevel {bool} -- ベベルの設定有無 (default: {False})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False

    # 不要なオブジェクトを選択しないように
    # 全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)

    # 指定のオブジェクトのみを選択状態にする
    selectob.select_set(True)

    # 対象オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 編集モードに移行する
    # モード切替のマニュアル
    # (https://docs.blender.org/api/current/bpy.ops.object.html#bpy.ops.object.mode_set)
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)
    
    # メッシュデータを取得する
    # メッシュアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMesh)
    meshdata = bmesh.from_edit_mesh(selectob.data)

    # 選択モードを面選択モードにする
    meshdata.select_mode = {'FACE'}
    
    # 一度選択を全てクリアする
    bpy.ops.mesh.select_all(action='DESELECT')
    
    # 辺または面の選択状態を更新する
    meshdata.select_flush_mode()
    
    # 辺または面を操作する場合はテーブルを更新する
    meshdata.verts.ensure_lookup_table()

    # 辺を走査する
    # 面アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMFace)
    for face in meshdata.faces:
        # 指定の数の面を選択する
        if face.normal[2] > 0.0:
            # 面を選択状態にする
            face.select_set(True)
        else:
            # 面を非選択状態にする
            face.select_set(False)

    # メッシュデータを取得する
    # メッシュアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMesh)
    meshdata = bmesh.from_edit_mesh(selectob.data)

    # 選択モードを面選択モードにする
    meshdata.select_mode = {'EDGE'}
    
    # 辺または面の選択状態を更新する
    meshdata.select_flush_mode()

    # 辺または面を操作する場合はテーブルを更新する
    meshdata.verts.ensure_lookup_table()

    # 辺を走査する
    # 辺アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMEdge)
    for edge in meshdata.edges:
        # 辺に接続された面を取得する
        faces = edge.link_faces
        # 接続された面が2つであることを確認する
        if len(faces) == 2:
            # 選択数をチェックする
            selectcount = 0

            # 各面を走査する
            for face in faces:
                if face.select == True:
                    # 選択状態の面をカウントする
                    selectcount += 1
            
            # 選択状態の面の数を確認する
            if selectcount == 1:
                # 1つ(片方)のみ選択状態であれば辺を選択状態にする
                edge.select_set(True)
            else:
                # 辺を非選択状態にする
                edge.select_set(False)
        else:
            # 辺を非選択状態にする
            edge.select_set(False)

    # 辺または面の選択状態を更新する
    meshdata.select_flush_mode()

    # オブジェクトデータを更新する
    selectob.data.update()

    # 現在選択中の辺に対して設定を行う
    # シームの設定を行う
    if arg_seam == True:
        bpy.ops.mesh.mark_seam(clear=False)

    # シャープの設定を行う
    if arg_sharp == True:
        bpy.ops.mesh.mark_sharp()
    
    # クリースの設定を行う
    if arg_crease == True:
        bpy.ops.transform.edge_crease(value=1.0)
    
    # ベベルの設定を行う
    if arg_bevel == True:
        bpy.ops.transform.edge_bevelweight(value=1.0)

    # オブジェクトモードに移行する
    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

    return True

# シャープ辺を対象とする辺分離モディファイアを適用する
def apply_split_sharpedge(arg_objectname="Default") -> bool:
    """対象オブジェクトにブーリアンモディファイアの差分を適用する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})

    Returns:
        bool -- 実行正否
    """
    
    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False

    # 指定オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 「辺分離」モディファイアを追加する
    # 辺分離モディファイアのインタフェース
    # (https://docs.blender.org/api/current/bpy.types.EdgeSplitModifier.html)
    bpy.ops.object.modifier_add(type='EDGE_SPLIT')
  
    # 作成モディファイアを取得する
    split_modifier = selectob.modifiers[-1]
  
    # シャープ辺のみで分離
    split_modifier.use_edge_angle = False
    split_modifier.use_edge_sharp = True

    # 「辺分離」モディファイアを適用する
    bpy.ops.object.modifier_apply(apply_as='DATA',modifier=split_modifier.name)

    return True

for mesh in bpy.data.objects:
    if mesh.type == 'MESH':
        mark_edges_Znormal(arg_objectname=mesh.name, arg_sharp=True)
        apply_split_sharpedge(arg_objectname=mesh.name)

これで全てのメッシュオブジェクトの陰影を修正できました。

次はテクスチャの反映です。
bluebirdofoz.hatenablog.com
bluebirdofoz.hatenablog.com

Bevel Curve Toolsアドオンを使ってBlenderで髪の毛オブジェクトを作る その２（メッシュへの変換とミラー）

本日は Blender の小ネタ枠です。
Bevel Curve Tools アドオンを使ってBlenderで髪の毛オブジェクトを作る手順を記事にします。

前回記事の続きです。
bluebirdofoz.hatenablog.com

曲線オブジェクトをメッシュに変更する

今回からは一旦 Bevel Curve Tools アドオンでの編集を確定して仕上げを行っていきます。
最初に、形状の編集を行えるようにするため、全ての曲線オブジェクトをメッシュに変更します。

アウトライナーウィンドウから全てのカーブオブジェクトを選択します。
[カーブ]タブから[To Mesh(es)]をクリックして、メッシュへの変換を行います。

これで全てのオブジェクトがメッシュオブジェクトに変換されました。

オブジェクトを左右対称にする

次に、各メッシュオブジェクトにミラーモディファイアを適用して左右対称にしていきます。
中央のメッシュオブジェクトを一例に手順を書き進めます。

オブジェクトを半分にカットする

前回作成した曲線オブジェクトは断面を簡略化したため、下部の中央に頂点がありません。
このため、まずは中央の部分に頂点を作成する必要があります。

今回は左右非対称な場合でも中央の部分に頂点を作成できるようブーリアンモディファイアを活用してみます。
最初にカット行う範囲を指定するためのキューブオブジェクトを作成します。

以下のように左半分を覆う形で立方体オブジェクトを配置しました。
このとき、中央の点にピッタリ重なるように立方体を置くと、ブーリアンの演算がエラーを起こすので僅かにずらしています。

再び、左右対称にしたいオブジェクトを選択して、[モディファイア]タブを開きます。

[モディファイアーの追加]から[ブーリアン]モディファイアを選択します。

[演算]に[差分]を選択し、[オブジェクト]に作成した[Cube]オブジェクトを指定します。
[重複のしきい値]は先ほどのずらしに合わせて調整します。

これでオブジェクトが半分にカットされました。
最後に、ブーリアンモディファイアを適用します。

立方体オブジェクトを非表示にすると、綺麗に分割されていることが分かります。

ミラーを設定する

次にオブジェクトにミラーモディファイアを適用します。
今のままだと断面にメッシュが貼られているため、[編集モード]で面を選択して削除します。

この状態でオブジェクトにミラーモディファイアを適用します。

これでオブジェクトがミラーされ、左右対称なオブジェクトになりました。
[クリッピング]を有効にして、ブーリアンでのずらし分を[マージ]の結合距離に設定しておけば不要な頂点が削除されます。

処理の自動化

上記の作業を全てのメッシュに実施します。
手作業で実施すると時間がかかる上、再加工が大変になってしまうのでスクリプト化しました。
以下の記事の python スクリプトの関数を全てのオブジェクトに対して処理を行います。
bluebirdofoz.hatenablog.com

実行スクリプト例（クリックで展開）

# bpyインポート
import bpy
# メッシュ操作のため
import bmesh

# ブーリアンモディファイアを使って対象オブジェクトをX軸で分割する
# その後、ミラーモディファイアでX軸対称のオブジェクトとする
def apply_boolean_mirror(arg_objectname="Default") -> bool:
    """ブーリアンモディファイアを使って対象オブジェクトをX軸で分割する
    その後、ミラーモディファイアでX軸対称のオブジェクトとする

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})

    Returns:
        bool -- 実行正否
    """
    
    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # オブジェクトがメッシュであるか確認する
    if selectob.type != 'MESH':
        # 指定オブジェクトがメッシュでない場合は処理しない
        return False

    # ブーリアン用モディファイアの名前を指定する
    boolean_objname = "Difference"

    # 中央頂点でのブーリアン演算のエラーを防ぐため
    # 調整用のずらしと各判定しきい値を設定する
    diff_shift = 0.0001
    cleanup_threshold = diff_shift * 10
    delzero_threshold = cleanup_threshold * 2
    mirror_threshold = delzero_threshold * 2

    # 対象オブジェクトのトランスフォームを適用する
    trans_result = transform_apply_target(arg_objectname=arg_objectname)
    if trans_result != True:
        # 適用に失敗した場合は処理しない
        return False

    # ブーリアンモディファイアの差分検出用Cubeを作成する
    make_result = make_cube_difference(arg_objectname=arg_objectname, arg_makename=boolean_objname, arg_shift=diff_shift)
    if make_result != True:
        # Cube作成に失敗した場合は処理しない
        return False
    
    # ブーリアンモディファイアの差分適用を実行する
    apply_result = apply_boolean_difference(arg_objectname=arg_objectname, arg_diffname=boolean_objname)
    if apply_result != True:
        # ブーリアン作成に失敗した場合は処理しない
        return False

    # オブジェクトの孤立を削除(どの面にもつながっていない辺や頂点を削除する)を行う
    cleanup_result = cleanup_mesh_object(arg_objectname=arg_objectname, arg_threshold=cleanup_threshold)
    if cleanup_result != True:
        # 削除に失敗した場合は処理しない
        return False
    
    # X軸ゼロにある面を削除する
    delzero_result = delete_face_xzero(arg_objectname=arg_objectname, arg_threshold=delzero_threshold)
    if delzero_result != True:
        # 削除に失敗した場合は処理しない
        return False

    # X軸のミラーモディファイアを適用する
    mirror_result = apply_mirror_Xclipping(arg_objectname=arg_objectname, arg_threshold=mirror_threshold)
    if mirror_result != True:
        # ミラーに失敗した場合は処理しない
        return False

    return True

# 対象オブジェクトのトランスフォームを適用する
def transform_apply_target(arg_objectname="Default") -> bool:
    """対象オブジェクトのトランスフォームを適用する
    
    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})

    Returns:
        bool -- 実行の正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # 不要なオブジェクトを選択しないように
    # 全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)

    # 指定のオブジェクトのみを選択状態にする
    selectob.select_set(True)
    
    # 対象オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 全てのトランスフォームを適用する
    bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)

    return True

# ブーリアンモディファイアの差分検出用Cubeを作成する
def make_cube_difference(arg_objectname="Default", arg_makename="Difference", arg_shift=0.0) -> bool:
    """ブーリアンモディファイアの差分検出用Cubeを作成する

    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})
        arg_makename {str} -- 作成オブジェクト名 (default: {"Difference"})
        arg_shift {float} -- ずらし (default: {0.0})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # 指定オブジェクトの境界情報を取得する
    # オブジェクトのインタフェース
    # (https://docs.blender.org/api/current/bpy.types.Object.html)
    target_boundbox = selectob.bound_box

    # 変数の初期化
    vertcount = 0
    center_x = 0.0
    center_y = 0.0
    center_z = 0.0

    # 頂点座標の加算
    for vert_boundbox in target_boundbox:
        center_x += vert_boundbox[0]
        center_y += vert_boundbox[1]
        center_z += vert_boundbox[2]
        vertcount += 1

    # 中点の計算
    center_x = center_x / vertcount
    center_y = center_y / vertcount
    center_z = center_z / vertcount

    # 寸法の取得
    dimension_x = selectob.dimensions[0]
    dimension_y = selectob.dimensions[1]
    dimension_z = selectob.dimensions[2]

    # もし作成予定と同名のメッシュオブジェクトが既に存在していれば新規作成しない
    if arg_makename in bpy.data.objects:
        return False

    # Cubeオブジェクトを作成する
    bpy.ops.mesh.primitive_cube_add(
        size=2.0,
        location=(0.0, 0.0, 0.0),
        rotation=(0.0, 0.0, 0.0)
    )

    # 作成したオブジェクトの参照を取得する
    makeob = bpy.context.view_layer.objects.active
    
    # 作成オブジェクト名を変更する
    makeob.name = arg_makename
    
    # 作成オブジェクトの位置を中点位置に変更する
    makeob.location = (center_x, center_y, center_z)

    # 作成オブジェクトのスケールを設定する
    # (対象オブジェクトより少し大きめのサイズにする)
    makeob.scale = ((dimension_x + 1.0) / 2.0, (dimension_y + 1.0) / 2.0, (dimension_z + 1.0) / 2.0)

    # 作成オブジェクトをX軸のマイナス側に移動する
    makeob.location[0] = -1.0 * ((dimension_x + 1.0) / 2.0)

    # 中央頂点でのブーリアン演算のエラーを防ぐためのずらし量を設定する
    makeob.location[0] = makeob.location[0] + arg_shift

    return True

# 対象オブジェクトにブーリアンモディファイアの差分を適用する
# 差分に用いたオブジェクトは削除する
def apply_boolean_difference(arg_objectname="Default", arg_diffname="Difference") -> bool:
    """対象オブジェクトにブーリアンモディファイアの差分を適用する
    差分に用いたオブジェクトは削除する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})
        arg_diffname {str} -- 差分オブジェクト名 (default: {"Difference"})

    Returns:
        bool -- 実行正否
    """

    # 差分オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    diffob = bpy.data.objects.get(arg_diffname)

    # 差分オブジェクトが存在するか確認する
    if diffob == None:
        # 差分オブジェクトが存在しない場合は処理しない
        return False
    
    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # 指定オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob
    
    # 「ブーリアン」モディファイアを追加する
    # ブーリアンモディファイアのインタフェース
    # (https://docs.blender.org/api/current/bpy.types.BooleanModifier.html)
    bpy.ops.object.modifier_add(type='BOOLEAN')

    # 追加されたモディファイアを取得する
    boolean_modifier = selectob.modifiers[-1]

    # 演算方法に[差分]を指定する
    boolean_modifier.operation = 'DIFFERENCE'

    # 統合対象にオブジェクトを指定する
    boolean_modifier.object = diffob

    # 重複の敷居値を指定する
    boolean_modifier.double_threshold = 0.000001

    # 「ブーリアン」モディファイアを適用する
    bpy.ops.object.modifier_apply(apply_as='DATA',modifier=boolean_modifier.name)

    # 統合したオブジェクトを削除する
    bpy.data.objects.remove(diffob)

    return True

# オブジェクトに以下のクリーンアップを実行
# ・大きさ０を融解：面積が０の面を削除し、１つの頂点にまとめる
# ・孤立を削除：どの面にもつながっていない辺や頂点を削除する
# ・重複頂点を削除：重複している頂点を１つの頂点にまとめる
def cleanup_mesh_object(arg_objectname="Default", arg_threshold=0.0001) -> bool:
    """オブジェクトにクリーンアップを実行
    ・大きさ０を融解：面積が０の面を削除し、１つの頂点にまとめる
    ・孤立を削除：どの面にもつながっていない辺や頂点を削除する
    ・重複頂点を削除：重複している頂点を１つの頂点にまとめる
    
    Keyword Arguments:
        arg_objectname {str} -- 指定オブジェクト名 (default: {"Default"})
        arg_threshold {float} -- 結合しきい値 (default: {0.0001})

    Returns:
        bool -- 実行の正否
    """

    # 他のオブジェクトに操作を適用しないよう全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    targetob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if targetob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False

    # 変更オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = targetob
  
    # 編集モードに移行する
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)

    # 頂点を全選択した状態とする
    bpy.ops.mesh.select_all(action='SELECT') 

    # 大きさ0を融解（結合距離 0.01）
    bpy.ops.mesh.dissolve_degenerate(threshold=0.01)

    # 変更を反映するため再び頂点を全選択
    bpy.ops.mesh.select_all(action='SELECT') 

    # 孤立を削除（頂点、辺のみ）
    bpy.ops.mesh.delete_loose(use_verts=True, use_edges=True, use_faces=False)

    # 孤立を削除で全選択が解除されるので再び頂点を全選択
    bpy.ops.mesh.select_all() 

    # 重複頂点を削除（結合距離、非選択部の結合無効）
    bpy.ops.mesh.remove_doubles(threshold=arg_threshold, use_unselected=False)

    # オブジェクトモードに移行する
    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

    return True

# X軸ゼロにある面を削除する
def delete_face_xzero(arg_objectname="Default", arg_threshold=0.0001) -> bool:
    """X軸ゼロにある面を削除する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})
        arg_threshold {float} -- 選択しきい値 (default: {0.0001})

    Returns:
        bool -- 実行正否
    """

    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # 不要なオブジェクトを選択しないように
    # 全てのオブジェクトを走査する
    for ob in bpy.context.scene.objects:
        # 非選択状態に設定する
        ob.select_set(False)

    # 指定のオブジェクトのみを選択状態にする
    selectob.select_set(True)
    
    # 対象オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 編集モードに移行する
    # モード切替のマニュアル
    # (https://docs.blender.org/api/current/bpy.ops.object.html#bpy.ops.object.mode_set)
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)

    # メッシュデータを取得する
    # メッシュアクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMesh)
    meshdata = bmesh.from_edit_mesh(selectob.data)

    # 選択モードを面選択モードにする
    meshdata.select_mode = {'VERT'}

    # 一度選択を全てクリアする
    bpy.ops.mesh.select_all(action='DESELECT')

    # 頂点を走査する
    # 頂点アクセスのマニュアル
    # (https://docs.blender.org/api/current/bmesh.types.html?highlight=bmedge#bmesh.types.BMVert)
    for v in meshdata.verts:
        # X軸の値がしきい値以下の頂点を取得する
        if v.co.x < arg_threshold:
            # 頂点を選択状態にする
            v.select_set(True)
        else:
            # 頂点を非選択状態にする
            v.select_set(False)

    # 辺または面の選択状態を更新する
    # (頂点の選択による面選択を有効化するため)
    meshdata.select_flush_mode()

    # 断面の面を削除する
    bpy.ops.mesh.delete(type='FACE')
    
    # オブジェクトモードに移行する
    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

    return True

# X軸のミラーモディファイアを適用する
def apply_mirror_Xclipping(arg_objectname="Default", arg_threshold=0.0001) -> bool:
    """対象オブジェクトにブーリアンモディファイアの差分を適用する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})
        arg_threshold {float} -- 結合しきい値 (default: {0.0001})

    Returns:
        bool -- 実行正否
    """
    
    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return False
    
    # 指定オブジェクトをアクティブに変更する
    bpy.context.view_layer.objects.active = selectob

    # 「ミラー」モディファイアを追加する
    # ミラーモディファイアのインタフェース
    # (https://docs.blender.org/api/current/bpy.types.MirrorModifier.html)
    bpy.ops.object.modifier_add(type='MIRROR')
  
    # 作成モディファイアを取得する
    mirror_modifier = selectob.modifiers[-1]
  
    # X軸でミラー
    mirror_modifier.use_axis[0] = True
    mirror_modifier.use_axis[1] = False
    mirror_modifier.use_axis[2] = False
  
    # オブション設定(結合,クリッピング,頂点グループ)
    mirror_modifier.use_mirror_merge = True
    mirror_modifier.use_clip = True
    mirror_modifier.use_mirror_vertex_groups = True
  
    # 結合距離
    mirror_modifier.merge_threshold = arg_threshold

    # 「ミラー」モディファイアを適用する
    bpy.ops.object.modifier_apply(apply_as='DATA',modifier=mirror_modifier.name)

    return True

# オブジェクトのバウンドボックスから中点を計算する
def get_object_center(arg_objectname="Default") -> list:
    """オブジェクトのバウンドボックスから中点を計算する

    Keyword Arguments:
        arg_objectname {str} -- 対象オブジェクト名 (default: {"Default"})

    Returns:
        list -- 中点座標
    """
    
    # 指定オブジェクトを取得する
    # (get関数は対象が存在しない場合 None が返る)
    selectob = bpy.data.objects.get(arg_objectname)

    # 指定オブジェクトが存在するか確認する
    if selectob == None:
        # 指定オブジェクトが存在しない場合は処理しない
        return [0.0, 0.0, 0.0]
    
    # 指定オブジェクトの境界情報を取得する
    # オブジェクトのインタフェース
    # (https://docs.blender.org/api/current/bpy.types.Object.html)
    target_boundbox = selectob.bound_box

    # 変数の初期化
    vertcount = 0
    center_x = 0.0
    center_y = 0.0
    center_z = 0.0

    # 頂点座標の加算
    for vert_boundbox in target_boundbox:
        center_x += vert_boundbox[0]
        center_y += vert_boundbox[1]
        center_z += vert_boundbox[2]
        vertcount += 1

    # 中点の計算
    center_x = center_x / vertcount
    center_y = center_y / vertcount
    center_z = center_z / vertcount

    return [center_x, center_y, center_z]

for mesh in bpy.data.objects:
    if mesh.type == 'MESH':
        apply_boolean_mirror(arg_objectname=mesh.name)

これで左右対称なメッシュオブジェクトに加工することができました。

次はシャープの設定と辺分離を使って陰影を修正します。
bluebirdofoz.hatenablog.com

Bevel Curve Toolsアドオンを使ってBlenderで髪の毛オブジェクトを作る その１

本日は Blender の小ネタ枠です。
前回紹介した Bevel Curve Tools アドオンを使ってBlenderで髪の毛オブジェクトを作る手順を記事にします。
bluebirdofoz.hatenablog.com

今回の作成物

ホロモンの首回りの毛皮のベースオブジェクトを Bevel Curve Tools アドオンを使って作り込みます。
以下のような完成図を目指します。

基礎となる髪の毛オブジェクトの作成

Dual Tipオブジェクトの作成

髪の毛の束を幾つも重ね合わせるような形で作成していきます。
まずは基礎となるひとまとまりの髪の毛オブジェクトを作成します。

髪の毛オブジェクト作成用の Blender の新規オブジェクトを作成しました。

[カーブ]タブ内の[New Beveled Curve]をクリックして曲線オブジェクトを生成します。

最終的に左右対称なオブジェクトとしたいので、X軸に対して対称となるようオブジェクトを移動します。
カーブオブジェクトを選択し、[編集モード]に移行します。

制御点を移動し、以下のように配置し直しました。

[カーブ]タブの[Add/Override Bevel]をクリックして形状を再設定します。
ベースとなる曲線オブジェクトの[Radius Falloff]は[Dual Tip]に設定します。
今回はなるべくローポリゴンなオブジェクトとしたいので[タイプ]は[三角]としています。

膨らみの部分形状は制御点を調整することで変更することができます。

同じ作業を繰り返して曲線オブジェクトを追加していきます。
まずは凡その形が出来上がりました。

One Tipオブジェクトの利用

次に厚みを付けていきます。
付け根の部分から重ねるように[Dual Tip]の曲線オブジェクトを追加していきます。

ある程度、曲線オブジェクトを重ねたら、上端が隠れて見えない部分の曲線オブジェクトが出てきます。
こういったオブジェクトについては[Dual Tip]ではなく[One Tip]を利用すると、制御点が少ないため作業が短縮できます。

今回は束の中央部分が膨らんだような形にしたかったので、最終的には全て[Doal Tip]を利用しました。

オブジェクトのリダクション

このままだとポリゴン数が多いので、可能な限りリダクションしていきます。
まずは各曲線オブジェクトの解像度を調整して形が崩れない程度にポリゴン数を減らします。

断面もポリゴン数を減らします。
曲線オブジェクトを一つ選択して[Edit Bevel]をクリックします。

頂点を融解していき、なるべく断面が単純な形になるよう変更します。

これで断面のポリゴン数が減りました。

他の曲線オブジェクトも同様に断面を単純な形に変更します。

これでポリゴン数を凡そ４分の１にすることができました。
スムースシェードの影響で影の付き方が変になってしまっていますが、これは後々修正を行います。

次はこれらの曲線オブジェクトをメッシュオブジェクトに変換します。
bluebirdofoz.hatenablog.com