/
Blender Optimization package (BOP)
Blender Optimization package (BOP)
Maroš Štuler
Maroš Klapáč
Owned by Maroš Štuler
Welcome on documentation page for a Blender addon called Blender Optimization package. Shortly BOP. Documentation provide all necessary explanations including tutorial how to install addon
What is BOP ?
BOP stands for Blender Optimization package. It is a python script made in Blender and is meant to be used for a Twinzo clients and automatization processes specific for Twinzo use-case. Script uses multiple Build in functions which can greatly help with 3D model optimization and save time.
How it looks like ?
What individual functions does script use ?
Script uses these functions:
It will delete all mesh faces which normals are facing down (Z-). Function also ignore objects with active modifiers
It will smooth out mesh normals to default value. Usually it’s 30°
Custom Split Normals are a way to tweak/fake shading by pointing them towards other directions than default, auto-computed ones. By deleting them 3D model switch to default one provided by Blender
It will delete duplicated meshes which are roughly at the same location and same shape
It will convert Triangulated mesh into the Quads for a Unity
It will merge connected or unconnected vertices which positions are exact or very close (Threshold is 0.05)
It will simplify your mesh by dissolving vertices and edges separating flat regions. Reduces detail on planar faces and linear edges
It will make sure that all non necessary or unused data are deleted so exported model will be clean (Applies on whole scene)
It will put all objects inside scene under the empty parent object in order to function properly in Unity (Applies on all objects) Also it will keep hierarchy for multi-storey buildings
It will recalculate the normals of selected faces so that they point outside the volume that the face belongs to
It will rotate 3D model in such a way, that side with higher average number of normals facing corresponding direction will be rotated to facing up (Z+). Function is intended to use on Scanned meshes!
It will set objects origin point to their relative median position
It will reset object scale values in scene to 1 (Ignores empty and instances)
It will merge similar materials based on their values and colors (Applies on all objects in project)
It will delete unnecessary types of objects like (Empty, Lights, Objects without mesh data). (Its best to use it before Object Instancer and Reparent function!)
It will delete any armature or bones in scene (Be careful if there is no selected object, it will clear all parents in scene!)
It will delete animations in scene
It will Bake Animation data into objects itself. This will allow easier manipulation with objects
It will adjust LOD names to ensure that Unity will recognize them
It will enable Automatic packing of external data such as textures and others into .blend file. Default state is False. Since its toggle, if you press it twice, it will disable function. Additionally you can check it in File - External data - Automatically Pack Resources
It will Delete non visible geometry via camera array and ray casting
How to install addon ?
Software needed:
Blender 3.4 or higher
BOP (Twinzo addon) - Download addon (Current version is 2.9)
Download zip file called BOP
Then we head to Blender and install addon. Click on edit panel in top left corner, then choose Preferences.
If you are using Blender 4.1 or older
Then choose Add-ons and click on Install in top right corner.
Find the downloaded ZIP file and click again on Install button.
After that make sure you enabled addon.
If you are using Blender 4.2 or newer
Then head to Extensions, click on drop down arrow in top right corner and choose option Install Legacy Add-on or Install from Disk
Find downloaded ZIP file and click again on Install button.
After that make sure you enabled addon
How to use it ?
After we installed addon we need to press N to bring up side panel and locate it under Twinzo section
Now you should see this panel:
There are 4 Buttons.
FIX my Classic Model
FIX my Scanned Model
RESET
Need help ?
There are 8 drop down menus
Individual Functions
Object Separator
Object Instancer
Analyze scene
Decimator v5
Exporter
Documentation
Updater
FIX my Classic Model button:
This button execute multiple functions which are specifically designed for a Classic Models like Demo Factory or Demo Office which you can check in app
You can use this button also for a Scanned Models but its not specifically designed for them
This button execute individual functions automatically in this order
Bake Animation data
Reset Origin
Reset Scale to 1
Recalculate Mesh Normals
Auto Smooth All
Delete Custom split Normals
Convert triangulated mesh into quads
Merge Close vertices
Remove Unused datablocks
Delete Bloat
Merge Similar Materials
Delete Downward faces
Create Instanced meshes
Decimator_v5
Adjust LOD names
Reparent
FIX my Scanned Model button:
This button execute multiple functions which are suitable for a Scanned Models via Lidar and similar technologies. Which are scanned models ? You can check Construction house or Twinzo office inside Twinzo app
You can use this button also for a Classic Models but its not specifically designed for them
Delete Animations
Delete any Armature and Bones
Reset Origin
Reset Scale to 1
Delete Custom split Normals
Merge Close vertices
Remove Unused datablocks
Delete Bloat
Fix Scan rotation
Merge Similar Materials
Decimator_v5
Adjust LOD names
Reparent
RESET button:
Reset button will reset whole scene into the original state. Depending on your previous steps it may not resets everything as you expect.
Use this button with CAUTION!
Need help ? button:
Need help ? button is located under the drop down menu of Documentation and it will bring you to the addon documentation webpage
Individual functions
Drop down menu contain all individual functions which can be executed manually in any order as you like
Almost all functions works either on selected objects or when is nothing selected it will apply on all objects in scene
You can also search for each individual function by pressing F3 or Spacebar
Object Separator
Object Separator will separate objects by loose parts (Mesh parts which are not connected to anything) and deletes meshes with Z-dimensions equal to 0
Its best to use it before Object Instancer
Object Instancer
Object Instancer will make identic or very similar objects as instanced one. Its doing it by checking distances between mesh vertices. Script will also remake already instanced meshes.
Instanced objects are very important in our workflow.
Analyze scene
Analyze scene will do exactly what is says. Its divided into 2 categories: Classical mesh and Scan Lidar mesh. Each category holds analyze scene tools designed for specific mesh type. Currently there are 2 types of tools: Heatmap and Statistic chart.
Heatmap:
Heatmap is graphical representation of data visualized in different colors, based on your model condition. You can check your model condition by using various methods:
It will assign colors to objects based on number of polygons
It will assign colors to objects based on face orientation (Backface culling)
It will assing colors to multi user objects (Instanced meshes) and non multi user objects (Not Instanced meshes)
It will assign colors to objects based on their mesh density. In more complex scenes, this function can take a some time
Statistic chart:
By pressing button Calculate Statistics, script will analyze scene and write statistics down bellow. There are two panels:
Statistics
In statistics panel are stored various information about currently opened scene
Results
In Results panel are stored Potentional Issues which are based on collected statistics in currently opened scene. Potentional Issues means that your model exceeded certain limit and may not work in Twinzo app
Decimator v5
Decimator v5 is a tool, designed to reduce vertex count while mostly preserving model shape and keeping textures mapping untouched. Tool is compatible with multi-user objects (Meshes with shared geometry). You can use Decimator v5 even on Scanned meshes but if your scan has significantly less vertexes than 750K, function can be too aggressive.
Tool is utilizing Blender native Decimate (Collapse) function with dynamic ratio values. Ratio values are dynamically calculated based on object face count and dimensions.
Conditions:
If object has less faces, decimate function will be less aggressive
If object dimensions are smaller than specified limit, decimate function will use aggressive decimate ratio since those objects are prompt to be less visible in app
Non multi-user objects are processed separately
More details can be found in addon code
Reducing vertex count is heavy process and can take several minutes to compute. If you are not satisfied with results, you can always press CTRL+Z to revert changes.
Exporter
Exporter will do exactly what is says. In order to export your model, you need to specify valid export location. You can do that by pressing folder icon next to predefined text "Choose path".
Couple things to know:
Exported file format will be always FBX
You don't need to write .fbx file extension while choosing export destination and file name. Exporter will automatically add it for you
Why my exported file include name "BOP" before file format extension ?
"BOP" text before file format extension will let us know that you used our addon and that can speed up processing if file will be uploaded through automatic Twinzo platform
If you set location which is not accessible or doesn't exist, addon will prompt you with error.
Documentation
Documentation contain button which direct you to this page
Updater
Updater drop down menu contain button for checking available updates
Known limitations
Since every 3D model is build differently with unique purpose in mind, sometimes addon will not perform as you expected. BOP is build to cover most of the general optimization steps to help you prepare your 3D model for a Twinzo app. If addon fails in some point to process your 3D model, you may consider to try fix it manually or try to use functions in different order. We also provide guideline to help you with it: https://twinzo.atlassian.net/l/cp/ZLbu2p6W
When addon tends to get slow or fail:
When trying to optimize large number of objects at once (like 6000 and more)
When trying to optimize very dense meshes with millions of polygons (1M and more), (Doesn't count for Lidar or photogrammetry based meshes)
Function Merge close vertices relies on model scale units. If due to unit conversion, model scaling is about the values like 0.001 or negative -0.001 and more, it may require manual adjustment
Code snippet (Python)
# This script is not licensed and its primary designed for Twinzo use-cases.
# However you are free to use, modify, and share this script, with or without modifications
#----------------------------Purpose----------------------------#
# Script is made in mind to help and automate optimization processes
#----------------------------Disclaimer----------------------------#
# Since every 3D model is made differently and for different purpose
# Some parts of the script may not work or behave differently than expected
# Depending on scene and model complexity, some scripts take some time to execute
# Enjoy
bl_info = {
"name": "BOptimization package",
"author": "Twinzo",
"version": (2, 9),
"blender": (3, 4, 0),
"location": "View > N > Twinzo panel",
"description": "Optimization package for process automatization",
"doc_url": "https://twinzo.atlassian.net/wiki/spaces/PUBD/pages/104398849/Blender+Optimization+package+BOP",
"category": "Object"
}
import bpy
import bmesh
import webbrowser
import math
import re
import os
import random
import mathutils
import bpy.utils.previews
from mathutils import Vector, bvhtree
from mathutils import Matrix
import threading
#----------------------------Enable developer extras----------------------------#
# Enable developer extras to be able to search for custom operators
def enable_developer_extras():
# Access user preferences
prefs = bpy.context.preferences
# Access the view section of user preferences
view_prefs = prefs.view
# Enable developer extras
view_prefs.show_developer_ui = True
#----------------------------Update checking----------------------------#
# Check for addon updates
def check_for_update():
bpy.context.window_manager.popup_menu(update_notification_menu, title="Addon Updater", icon='INFO')
# Update notification menu
def update_notification_menu(self, context):
layout = self.layout
layout.label(text=f"Current Version: {bl_info['version'][0]}.{bl_info['version'][1]}")
layout.label(text="Click on button bellow to visit addon page")
layout.operator("wm.url_open", text="Open Website").url = "https://twinzo.sharepoint.com/:f:/s/Publicdocumentation/Eo7iFbv43WxJh76Tn9b-dm8BTi_fMkn2sZjEr8m3U0VW4Q?e=o0bkPh"
#----------------------------Defined functions----------------------------#
# Function to delete faces with normals facing downward (treshold is defined in class)
def delete_downward_faces(threshold=0.4):
try:
selected_objects = bpy.context.selected_objects
# Check if any objects are selected
if selected_objects:
for obj in selected_objects:
if obj.type == 'MESH':
bpy.context.view_layer.objects.active = obj
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.normals_make_consistent(inside=False)
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.mode_set(mode='EDIT')
bm = bmesh.from_edit_mesh(obj.data)
faces_to_delete = []
for face in bm.faces:
# Calculate the face normal
normal = face.normal
normal_world = obj.matrix_world.inverted().transposed() @ normal
# Check if the face normal has a valid length
if normal.length > 0 and normal_world.length > 0:
# Calculate the angle between the face normal and the negative Z-axis
angle = normal_world.angle(Vector((0, 0, -1)))
if normal_world.z <= -threshold and angle <= threshold:
faces_to_delete.append(face)
if faces_to_delete:
# Deselect all faces and select the faces to delete
bpy.ops.mesh.select_all(action='DESELECT')
for face in faces_to_delete:
face.select = True
# Delete the selected faces
bpy.ops.mesh.delete(type='FACE')
# Update the mesh after deleting the faces
bmesh.update_edit_mesh(obj.data)
bpy.ops.object.mode_set(mode='OBJECT')
# Deselect all objects at the end
bpy.ops.object.select_all(action='DESELECT')
else:
# Function to check if a face is facing downward
def is_face_facing_downward(face, obj, threshold=0.2):
z_vector = Vector((0, 0, -1)) # Negative Z-axis as a Vector
world_matrix = obj.matrix_world
normal = face.normal.copy()
# Transform the face normal into world space
normal = world_matrix.to_3x3() @ normal
# Ensure the normal is normalized for consistent comparison
normal.normalize()
# Skip zero-length vectors to avoid the angle calculation error
if normal.length == 0:
return False
# Compare the angle between the face normal and the downward direction (negative Z)
angle = normal.angle(z_vector)
# Tighten the angle threshold and z-component check for stricter deletion criteria
return normal.z <= threshold and angle <= 0.523 # 0.523 radians = 30 degrees
# Dictionary to keep track of processed multi-user objects
processed_multi_user_objects = {}
# Loop through visible objects and delete downward-facing faces
for obj in bpy.context.visible_objects:
if obj.type == 'MESH' and not obj.modifiers and not obj.is_instancer:
# Check if object data is shared among multiple objects
if obj.data.users > 1:
multi_user_type = obj.data.name # Use the data name as a unique identifier
# Process only once per multi-user mesh
if multi_user_type not in processed_multi_user_objects:
bm = bmesh.new()
bm.from_mesh(obj.data)
# Identify faces to delete
faces_to_delete = [face for face in bm.faces if is_face_facing_downward(face, obj, threshold=0.2)]
# Delete faces directly in bmesh
if faces_to_delete:
bmesh.ops.delete(bm, geom=faces_to_delete, context='FACES')
# Write changes back to the mesh
bm.to_mesh(obj.data)
bm.free()
# Mark the object as processed
processed_multi_user_objects[multi_user_type] = obj
else:
# For non-multi-user objects, apply the logic directly
bm = bmesh.new()
bm.from_mesh(obj.data)
# Identify faces to delete
faces_to_delete = [face for face in bm.faces if is_face_facing_downward(face, obj, threshold=0.2)]
# Delete faces directly in bmesh
if faces_to_delete:
bmesh.ops.delete(bm, geom=faces_to_delete, context='FACES')
# Write changes back to the mesh
bm.to_mesh(obj.data)
bm.free()
# Deselect all objects at the end
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("An error occurred:", str(e))
print("Continuing")
# Define Function to apply "Convert Tris to Quads" to all objects
def tris_to_quads():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
# Switch to edit mode
bpy.ops.object.mode_set(mode='EDIT')
if not bpy.context.scene.tool_settings.use_transform_correct_face_attributes:
bpy.context.scene.tool_settings.use_transform_correct_face_attributes = True
if not bpy.context.scene.tool_settings.use_transform_correct_keep_connected:
bpy.context.scene.tool_settings.use_transform_correct_keep_connected = True
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='FACE')
bpy.ops.mesh.tris_convert_to_quads(face_threshold=0.698132, shape_threshold=0.698132, uvs=False)
# Switch back to object mode
bpy.ops.object.mode_set(mode='OBJECT')
# Deselect all
bpy.ops.object.select_all(action='DESELECT')
else:
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Get all visible mesh objects in the scene
visible_mesh_objects = [
obj for obj in bpy.context.scene.objects
if obj.type == 'MESH' and obj.visible_get()
]
if not visible_mesh_objects:
print("No visible mesh objects in the scene.")
return # Exit if no visible mesh objects are found
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Select all visible mesh objects
for obj in visible_mesh_objects:
obj.select_set(True)
# Make one random mesh object active
active_object = random.choice(visible_mesh_objects)
bpy.context.view_layer.objects.active = active_object
# Switch to object mode to apply selection
bpy.ops.object.mode_set(mode='OBJECT')
# Switch to edit mode for all selected mesh objects and convert triangles to quads
bpy.ops.object.mode_set(mode='EDIT')
if not bpy.context.scene.tool_settings.use_transform_correct_face_attributes:
bpy.context.scene.tool_settings.use_transform_correct_face_attributes = True
if not bpy.context.scene.tool_settings.use_transform_correct_keep_connected:
bpy.context.scene.tool_settings.use_transform_correct_keep_connected = True
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.tris_convert_to_quads(face_threshold=0.698132, shape_threshold=0.698132, uvs=False)
bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Tris to Quads failed:", str(e))
print("Continuing")
# Function to apply auto-smooth to all objects
def apply_auto_smooth():
try:
selected_objects = bpy.context.selected_objects
blender_version = bpy.app.version
if selected_objects:
for obj in selected_objects:
if obj.type == 'MESH':
bpy.context.view_layer.objects.active = obj
# Check Blender version to determine shading method
if blender_version >= (3, 6, 9):
if "shade_smooth_by_angle" in dir(bpy.ops.object):
# Use shade_smooth_by_angle if available
bpy.ops.object.shade_smooth_by_angle(angle=0.523599, keep_sharp_edges=True)
else:
# Fallback to shade_smooth if shade_smooth_by_angle isn't available
bpy.ops.object.shade_smooth(use_auto_smooth=True)
else:
# Use shade_smooth for older versions
bpy.ops.object.shade_smooth(use_auto_smooth=True)
else:
# Deselect all objects to ensure autosmooth is applied to all visible objects
bpy.ops.object.select_all(action='DESELECT')
# Get all visible mesh objects in the scene
visible_mesh_objects = [
obj for obj in bpy.context.scene.objects
if obj.type == 'MESH' and obj.visible_get()
]
if not visible_mesh_objects:
print("No visible mesh objects in the scene.")
return # Exit if no visible mesh objects are found
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Select all visible mesh objects
for obj in visible_mesh_objects:
obj.select_set(True)
# Make one random mesh object active
active_object = random.choice(visible_mesh_objects)
bpy.context.view_layer.objects.active = active_object
if blender_version >= (3, 6, 9):
if "shade_smooth_by_angle" in dir(bpy.ops.object):
# Use shade_smooth_by_angle if available
bpy.ops.object.shade_smooth_by_angle(angle=0.523599, keep_sharp_edges=True)
else:
# Fallback to shade_smooth if shade_smooth_by_angle isn't available
bpy.ops.object.shade_smooth(use_auto_smooth=True)
else:
# Use shade_smooth for older versions
bpy.ops.object.shade_smooth(use_auto_smooth=True)
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Autosmooth failed:", str(e))
print("Continuing")
# Function to delete custom split normals data for all objects
def delete_custom_split_normals():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
for obj in selected_objects:
if obj.type == 'MESH':
bpy.context.view_layer.objects.active = obj
bpy.ops.mesh.customdata_custom_splitnormals_clear()
else:
# Dictionary to keep track of processed multi-user objects
processed_multi_user_objects = {}
# Deselect all objects to ensure autosmooth is applied to all visible objects
bpy.ops.object.select_all(action='DESELECT')
for obj in bpy.context.visible_objects:
if obj.type == 'MESH':
if obj.data.users > 1:
multi_user_type = obj.data.name # Use the data name as a unique identifier
# Check if this multi-user type has been processed
if multi_user_type not in processed_multi_user_objects:
# Set this object as the active one
bpy.context.view_layer.objects.active = obj
# Clear custom split normals
bpy.ops.mesh.customdata_custom_splitnormals_clear()
# Mark this type as processed
processed_multi_user_objects[multi_user_type] = obj
else:
# For non-multi-user objects, apply the logic directly
bpy.context.view_layer.objects.active = obj
bpy.ops.mesh.customdata_custom_splitnormals_clear()
# Deselect all objects at the end
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Autosmooth failed:", str(e))
print("Continuing")
# Function to merge close vertices
def merge_close_vertices():
try:
threshold_distance = 0.001
selected_objects = bpy.context.selected_objects
if selected_objects:
for obj in selected_objects:
if obj.type == 'MESH':
# Select the object and make it active
bpy.context.view_layer.objects.active = obj
bpy.ops.object.mode_set(mode='EDIT')
# Get the mesh data of the object
mesh = bmesh.from_edit_mesh(obj.data)
# Ensure we're in vertex select mode
bpy.ops.mesh.select_mode(type="VERT")
# Merge close vertices
bmesh.ops.remove_doubles(mesh, verts=mesh.verts, dist=threshold_distance)
# Update mesh data
bmesh.update_edit_mesh(obj.data)
# Switch back to object mode
bpy.ops.object.mode_set(mode='OBJECT')
else:
# Get all visible mesh objects in the scene
visible_mesh_objects = [
obj for obj in bpy.context.scene.objects
if obj.type == 'MESH' and obj.visible_get()
]
if not visible_mesh_objects:
print("No visible mesh objects in the scene.")
return # Exit if no visible mesh objects are found
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Select all visible mesh objects
for obj in visible_mesh_objects:
obj.select_set(True)
# Make one random mesh object active
active_object = random.choice(visible_mesh_objects)
bpy.context.view_layer.objects.active = active_object
# Perform operations on all selected objects
bpy.ops.object.mode_set(mode='EDIT')
# Select all vertices
bpy.ops.mesh.select_all(action='SELECT')
# Remove doubles
bpy.ops.mesh.remove_doubles(threshold=threshold_distance)
# Switch back to object mode
bpy.ops.object.mode_set(mode='OBJECT')
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Merge close vertices failed:", str(e))
print("Continuing")
# Function to Use Limited Dissolve
def limited_dissolve():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='FACE')
bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665) #Adjust angle
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
else:
# Dictionary to keep track of processed multi-user objects
processed_multi_user_objects = {}
# Deselect all objects to ensure autosmooth is applied to all visible objects
bpy.ops.object.select_all(action='DESELECT')
for obj in bpy.context.visible_objects:
if obj.type == 'MESH':
if obj.data.users > 1:
multi_user_type = obj.data.name # Use the data name as a unique identifier
# Check if this multi-user type has been processed
if multi_user_type not in processed_multi_user_objects:
# Set this object as the active one
bpy.context.view_layer.objects.active = obj
obj.select_set(True) # Select only the current object
# Switch to EDIT mode
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='FACE')
bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665) # Adjust the angle limit as needed
# Switch back to OBJECT mode
bpy.ops.object.mode_set(mode='OBJECT')
# Deselect the object and mark this type as processed
obj.select_set(False)
processed_multi_user_objects[multi_user_type] = obj
else:
bpy.context.view_layer.objects.active = obj
obj.select_set(True) # Select only the current object
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='FACE')
bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665) # Adjust the angle limit as needed
bpy.ops.object.mode_set(mode='OBJECT')
obj.select_set(False)
# Deselect all objects at the end
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Limited dissolve failed:", str(e))
print("Continuing")
# Function to remove unused datablock
def remove_unused_datablocks():
# Remove orphaned data (materials, textures, meshes, etc.)
bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True)
# Function to reparent
def reparent(empty_objects):
def select_recursive(obj, selected_objects):
for child_obj in obj.children:
if child_obj.type == 'MESH':
selected_objects.append(child_obj)
if child_obj.children:
select_recursive(child_obj, selected_objects)
try:
empty_found = False
for specific_part in ['Outside', 'Interior', 'Architecture']:
# Clear existing selection
bpy.ops.object.select_all(action='DESELECT')
# Check if the empty object contains the specified part
matching_objects = [obj for obj in bpy.data.objects if obj.type == 'EMPTY' and specific_part in obj.name]
if matching_objects:
empty_found = True
for empty_object in matching_objects:
selected_objects = []
select_recursive(empty_object, selected_objects)
# # Select the mesh objects
# for obj in selected_objects:
# obj.select_set(True)
# Reparent the mesh objects back under the empty object with CLEAR_KEEP_TRANSFORM
# bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
for obj in selected_objects:
obj.parent = empty_object
# Clear existing selection
bpy.ops.object.select_all(action='DESELECT')
# Select hierarchy under the empty object
bpy.context.view_layer.objects.active = empty_object
bpy.ops.object.select_hierarchy(direction='CHILD', extend=True)
# Filter selected objects to keep only empty objects under the empty object
empty_objects_to_delete = [
obj for obj in bpy.context.selected_objects
if obj.type == 'EMPTY' and obj.parent == empty_object
]
# Delete the identified empty objects
bpy.ops.object.select_all(action='DESELECT')
for obj in empty_objects_to_delete:
obj.select_set(True)
bpy.ops.object.delete(use_global=False)
# # Delete all empty objects not under an empty parent called 'Main'
# main_empty = bpy.data.objects.get('Main')
# if main_empty:
# # Gather all empty objects not parented to 'Main' and not named 'Main'
# empty_objects_to_delete = [
# obj for obj in bpy.data.objects if obj.type == 'EMPTY' and obj != main_empty and obj.parent != main_empty
# ]
# # Delete these empty objects
# bpy.ops.object.select_all(action='DESELECT')
# for obj in empty_objects_to_delete:
# obj.select_set(True)
# bpy.ops.object.delete(use_global=False)
# Execute the specified code if none of the empty objects is found
if not empty_found:
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.object.select_by_type(extend=False, type='EMPTY')
bpy.ops.object.delete(use_global=False)
bpy.ops.object.select_all(action='DESELECT')
# Create Main empty object
bpy.ops.object.empty_add(type='PLAIN_AXES', align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
main_obj = bpy.context.object
main_obj.name = "Main"
# Create Floor 0 empty object and parent it to Main
bpy.ops.object.empty_add(type='PLAIN_AXES', align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
floor_0_obj = bpy.context.object
floor_0_obj.name = "Floor 0"
floor_0_obj.parent = main_obj
# List of child objects to be created under Floor 0
child_names = ["Floor 0 Architecture", "Floor 0 Interior", "Floor 0 Outside"]
# Dictionary to store references to the created objects
child_objects = {}
# Create child objects and parent them to Floor 0
for name in child_names:
bpy.ops.object.empty_add(type='PLAIN_AXES', align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
child_obj = bpy.context.object
child_obj.name = name
child_obj.parent = floor_0_obj
child_objects[name] = child_obj # Store reference to the object
# Select all visible mesh objects in the scene
bpy.ops.object.select_all(action='DESELECT')
for obj in bpy.context.scene.objects:
if obj.type == 'MESH' and obj.visible_get():
obj.select_set(True)
# Parent all selected mesh objects to "Floor 0 Architecture"
floor_0_arch_obj = child_objects["Floor 0 Architecture"]
bpy.context.view_layer.objects.active = floor_0_arch_obj # Set "Floor 0 Architecture" as active object
bpy.ops.object.parent_set(type='OBJECT', keep_transform=True)
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Push undo step
bpy.ops.ed.undo_push()
except Exception as e:
print("Error:", str(e))
print("Continuing")
# Function to recalculate normals
def recalculate_normals():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
for obj in selected_objects:
bpy.context.view_layer.objects.active = obj
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.normals_make_consistent(inside=False)
bpy.ops.object.mode_set(mode='OBJECT')
else:
# Get all visible mesh objects in the scene
visible_mesh_objects = [
obj for obj in bpy.context.scene.objects
if obj.type == 'MESH' and obj.visible_get()
]
if not visible_mesh_objects:
print("No visible mesh objects in the scene.")
return # Exit if no visible mesh objects are found
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Select all visible mesh objects
for obj in visible_mesh_objects:
obj.select_set(True)
# Make one random mesh object active
active_object = random.choice(visible_mesh_objects)
bpy.context.view_layer.objects.active = active_object
# Switch to edit mode
bpy.ops.object.mode_set(mode='EDIT')
# Select all vertices
bpy.ops.mesh.select_all(action='SELECT')
# Recalculate normals
bpy.ops.mesh.normals_make_consistent(inside=False)
# Deselect all objects
bpy.ops.mesh.select_all(action='DESELECT')
# Switch back to object mode
bpy.ops.object.mode_set(mode='OBJECT')
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Recalculate normals failed:", str(e))
print("Continuing")
# Function to open a Addon documentation
def open_url(url):
webbrowser.open(url)
# Function to open Fix scan Rotation
def rotate_model_operator():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
for obj in selected_objects:
if obj.type == "MESH" and obj.data.users == 1:
bpy.context.view_layer.objects.active = obj
bpy.ops.object.select_all(action='DESELECT')
obj.select_set(True)
try:
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
except RuntimeError as e:
if "Cannot apply to a multi user" in str(e):
print(f"Skipping multi-user object: {obj.name}")
continue
else:
raise e
# Count the number of face normals facing in each direction
normal_counts = [0, 0, 0] # X, Y, Z
data = obj.data
for polygon in data.polygons:
normal = polygon.normal
if normal.x > 0:
normal_counts[0] += 1
if normal.y > 0:
normal_counts[1] += 1
if normal.z > 0:
normal_counts[2] += 1
# Find the index of the direction with the highest normal count
highest_normal_direction = normal_counts.index(max(normal_counts))
# Calculate the rotation angle based on the highest normal direction
rotation_angle = math.radians(-90 * highest_normal_direction)
# Rotate the object to align the highest normal direction with the Z-up direction
obj.rotation_euler = (0, 0, rotation_angle)
bpy.ops.object.select_all(action='DESELECT')
else:
for obj in bpy.context.visible_objects:
if obj.type == "MESH" and obj.data.users == 1:
bpy.context.view_layer.objects.active = obj
bpy.ops.object.select_all(action='DESELECT')
obj.select_set(True)
try:
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
except RuntimeError as e:
if "Cannot apply to a multi user" in str(e):
print(f"Skipping multi-user object: {obj.name}")
continue
else:
raise e
# Count the number of face normals facing in each direction
normal_counts = [0, 0, 0] # X, Y, Z
data = obj.data
for polygon in data.polygons:
normal = polygon.normal
if normal.x > 0:
normal_counts[0] += 1
if normal.y > 0:
normal_counts[1] += 1
if normal.z > 0:
normal_counts[2] += 1
# Find the index of the direction with the highest normal count
highest_normal_direction = normal_counts.index(max(normal_counts))
# Calculate the rotation angle based on the highest normal direction
rotation_angle = math.radians(-90 * highest_normal_direction)
# Rotate the object to align the highest normal direction with the Z-up direction
obj.rotation_euler = (0, 0, rotation_angle)
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("rotate_model_operator() failed:", str(e))
print("Continuing")
# Function to reset origin on all objects in scene
def reset_origin():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
for obj in selected_objects:
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.ed.undo_push
else:
# Deselect all objects at the start (only once)
bpy.ops.object.select_all(action='DESELECT')
# Dictionary to track objects by their mesh data
mesh_data_to_obj = {}
# List to store objects that should have their origin reset
objects_to_reset = []
# Loop through all mesh objects to organize them by mesh data
for obj in bpy.data.objects:
if obj.type == 'MESH' and obj.visible_get() and not obj.animation_data and (not obj.data.shape_keys or not obj.data.shape_keys.animation_data) and not obj.constraints:
mesh_data = obj.data
# Track objects sharing the same mesh data
if mesh_data not in mesh_data_to_obj:
mesh_data_to_obj[mesh_data] = []
mesh_data_to_obj[mesh_data].append(obj)
# Now, loop through the mesh data dictionary
for obj_list in mesh_data_to_obj.values():
# Check if any object in the list has animation data
has_animation_data = any(other_obj.animation_data for other_obj in obj_list)
# If no object in the list has animation data, add them to the reset list
if not has_animation_data:
objects_to_reset.extend(obj_list)
# If we found objects that need their origin reset
if objects_to_reset:
# Manually set the active object and reset origin without re-selecting everything
bpy.context.view_layer.objects.active = objects_to_reset[0]
# Perform the origin set operation directly on the objects
for obj in objects_to_reset:
obj.select_set(True) # Set the selection status
# Apply the origin_set operation to the selected objects
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
# Deselect all objects at the end (once)
bpy.ops.object.select_all(action='DESELECT')
# Push an undo step to the stack
bpy.ops.ed.undo_push()
except Exception as e:
print("Reset origin failed:", str(e))
print("Continuing")
# Function to reset scene to original state
def reset_to_original_state():
# Store the initial state of the scene when the script is run for the first time
if not hasattr(bpy.types.Scene, 'initial_objects'):
bpy.types.Scene.initial_objects = None
bpy.types.Scene.initial_cameras = None
bpy.types.Scene.initial_lights = None
bpy.types.Scene.initial_materials = None
bpy.types.Scene.initial_objects = bpy.data.objects[:]
bpy.types.Scene.initial_cameras = bpy.data.cameras[:]
bpy.types.Scene.initial_lights = bpy.data.lights[:]
bpy.types.Scene.initial_materials = bpy.data.materials[:]
# Delete all objects, cameras, and lights that were added after importing the model
for obj in bpy.data.objects:
if obj not in bpy.context.scene.initial_objects:
bpy.data.objects.remove(obj)
for camera in bpy.data.cameras:
if camera not in bpy.context.scene.initial_cameras:
bpy.data.cameras.remove(camera)
for light in bpy.data.lights:
if light not in bpy.context.scene.initial_lights:
bpy.data.lights.remove(light)
# Function to remove duplicated materials
def merge_similar_materials():
try:
def are_values_similar(v1, v2, tolerance):
return abs(v1 - v2) <= tolerance
def get_shader_nodes(material):
"""Returns the BSDF nodes (Principled, Diffuse, Transparent, Translucent) for a given material."""
bsdf_nodes = {"principled": None, "diffuse": None, "transparent": None, "translucent": None}
if material and material.use_nodes:
for node in material.node_tree.nodes:
if node.type == 'BSDF_PRINCIPLED':
bsdf_nodes["principled"] = node
elif node.type == 'BSDF_DIFFUSE':
bsdf_nodes["diffuse"] = node
elif node.type == 'BSDF_TRANSPARENT':
bsdf_nodes["transparent"] = node
elif node.type == 'BSDF_TRANSLUCENT':
bsdf_nodes["translucent"] = node
return bsdf_nodes
def get_or_create_default_material():
"""Checks if DefaultMaterial exists; if not, creates one and returns it."""
mat_name = "DefaultMaterial"
# Check if material already exists
existing_material = bpy.data.materials.get(mat_name)
if existing_material:
return existing_material
# Create default material if it doesn't exist
mat = bpy.data.materials.new(name=mat_name)
mat.use_nodes = True
bsdf_node = next((node for node in mat.node_tree.nodes if node.type == 'BSDF_PRINCIPLED'), None)
if not bsdf_node:
return None
# Set default material properties
bsdf_node.inputs['Base Color'].default_value = (0.8, 0.8, 0.8, 1.0) # Light gray
bsdf_node.inputs['Metallic'].default_value = 0.0
bsdf_node.inputs['Roughness'].default_value = 0.5
bsdf_node.inputs['Alpha'].default_value = 1.0
return mat
# Define tolerance values for each attribute
diffuse_tolerance = 0.1 # Adjust as needed for diffuse color comparison
metallic_tolerance = 0.1 # Adjust as needed for metallic comparison
roughness_tolerance = 0.1 # Adjust as needed for roughness comparison
alpha_tolerance = 0.1 # Adjust as needed for alpha comparison
color_tolerance = 0.1 # Used for Diffuse & Translucent Color comparison
# Create dictionaries to store material data (Script will compare values based on dictionary categories)
material_data = {}
# Set to track merged materials (to avoid re-merging)
merged_materials = set()
# Get a list of all visible objects in the current scene
visible_objects = [obj for obj in bpy.context.scene.objects if obj.visible_get()]
# Get or create the default material
default_material = get_or_create_default_material()
# Iterate over objects
for obj in visible_objects:
if obj.type == 'MESH':
if obj.data.color_attributes:
continue
if not obj.material_slots:
obj.data.materials.append(default_material)
for slot in obj.material_slots:
material = slot.material
if not material or material.node_tree is None:
continue
if material in merged_materials:
continue
# Check if the material has a texture added to the TEX_IMAGE node
has_texture = False
for node in material.node_tree.nodes:
if node.type == 'TEX_IMAGE' and node.image:
has_texture = True
break
# Skip materials with a texture in the TEX_IMAGE node
if has_texture:
continue
# Get shader nodes
nodes = get_shader_nodes(material)
# Extract properties
base_color = (0, 0, 0, 1)
metallic = 0.0
roughness = 0.5
alpha = 1.0
diffuse_color = (0, 0, 0, 1)
translucent_color = (0, 0, 0, 1)
has_transparent = nodes["transparent"] is not None
if nodes["principled"]:
bsdf_node = nodes["principled"]
base_color = bsdf_node.inputs['Base Color'].default_value
metallic = bsdf_node.inputs['Metallic'].default_value
roughness = bsdf_node.inputs['Roughness'].default_value
alpha = bsdf_node.inputs['Alpha'].default_value
if nodes["diffuse"]:
diffuse_color = nodes["diffuse"].inputs['Color'].default_value
if nodes["translucent"]:
translucent_color = nodes["translucent"].inputs['Color'].default_value
key = (
tuple(base_color[:3]), # RGB only
metallic,
roughness,
alpha,
tuple(diffuse_color[:3]), # Diffuse color
tuple(translucent_color[:3]), # Translucent color
has_transparent # Boolean
)
merged_material = None
for existing_key, materials in material_data.items():
if materials[0][0] == material:
continue
base_color_match = all(
are_values_similar(v1, v2, diffuse_tolerance)
for v1, v2 in zip(base_color[:3], existing_key[0])
)
metallic_match = are_values_similar(metallic, existing_key[1], metallic_tolerance)
roughness_match = are_values_similar(roughness, existing_key[2], roughness_tolerance)
alpha_match = are_values_similar(alpha, existing_key[3], alpha_tolerance)
diffuse_match = all(
are_values_similar(v1, v2, color_tolerance)
for v1, v2 in zip(diffuse_color[:3], existing_key[4])
)
translucent_match = all(
are_values_similar(v1, v2, color_tolerance)
for v1, v2 in zip(translucent_color[:3], existing_key[5])
)
transparent_match = existing_key[6] == has_transparent
if (
base_color_match and metallic_match and roughness_match and alpha_match
and diffuse_match and translucent_match and transparent_match
):
merged_material = materials[0][0]
break
if merged_material is None:
material_data[key] = [(material, base_color)]
else:
for obj in visible_objects:
for slot in obj.material_slots:
if slot.material == material:
slot.material = merged_material
merged_materials.add(material)
# Remove unused materials and fix suffixes
for material in bpy.data.materials:
material.name = re.sub(r'\.\d+$', '', material.name)
if not any(slot.material == material for obj in visible_objects for slot in obj.material_slots):
bpy.data.materials.remove(material)
# Iterate over all materials in the current Blender file
for material in bpy.data.materials:
# Ensure the material uses nodes
if material.use_nodes:
# Get the node tree of the material
node_tree = material.node_tree
# Find the relevant BSDF nodes
bsdf_nodes = []
for node in node_tree.nodes:
if node.type in {'BSDF_PRINCIPLED', 'BSDF_TRANSPARENT', 'BSDF_TRANSLUCENT'}:
bsdf_nodes.append(node)
# Process each relevant BSDF node
for bsdf_node in bsdf_nodes:
# Copy the Viewport Display color to the Base Color
viewport_color = material.diffuse_color[:3] # Get the RGB part of the diffuse color
if bsdf_node.type == 'BSDF_PRINCIPLED':
base_color = bsdf_node.inputs['Base Color'].default_value[:3] # Get the RGB part of the Base Color
input_name = 'Base Color'
elif bsdf_node.type == 'BSDF_TRANSPARENT' or bsdf_node.type == 'BSDF_TRANSLUCENT':
base_color = bsdf_node.inputs['Color'].default_value[:3] # Get the RGB part of the Color
input_name = 'Color'
# Skip if the Base Color is already the same as the Viewport Display color
if viewport_color != base_color:
bsdf_node.inputs[input_name].default_value = (*viewport_color, 1.0) # Set Color with full alpha
except Exception as e:
print("Merge similar materials failed:", str(e))
print("Continuing")
# Function to make instanced objects from similar meshes in scene with treshold
def compare_objects(obj1, obj2, threshold_distance):
try:
mesh_data1, mesh_data2 = obj1.data, obj2.data
# Compare geometry
for v1, v2 in zip(mesh_data1.vertices, mesh_data2.vertices):
if (v1.co - v2.co).length > threshold_distance:
return False
# Compare materials (ignoring order of slots)
materials1 = {slot.material for slot in obj1.material_slots if slot.material}
materials2 = {slot.material for slot in obj2.material_slots if slot.material}
if materials1 != materials2:
return False
return True
except Exception as e:
print("Compare_meshes failed:", str(e))
print("Continuing")
# Function to separate objects by loose parts and delete faces with Z-dimension equal to 0
def object_separator():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
for obj in selected_objects:
if obj.type == 'MESH' and obj.data.users == 1:
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='VERT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.remove_doubles(threshold=0.001)
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='FACE')
bpy.ops.mesh.separate(type='LOOSE')
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
else:
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.object.mode_set(mode='OBJECT')
for obj in bpy.context.visible_objects:
if obj.type == "MESH" and obj.data.users == 1:
obj.select_set(True)
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.separate(type='LOOSE')
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Object instancer failed:", str(e))
print("You are trying to separate objects with shared geometry or objects without loose parts")
# Function to delete bloat
def delete_bloat():
try:
def collect_children(parent):
""" Recursively collect all child objects of a given parent. """
children = set()
for child in parent.children:
children.add(child)
children.update(collect_children(child))
return children
# Collect all objects in the scene
all_objects = bpy.context.scene.objects
# Initialize sets to collect objects for different operations
# objects_to_delete_height = set()
objects_to_delete_type = set()
protected_objects = set()
# Find the 'Main' object and its descendants
main_obj = bpy.context.scene.objects.get('Main')
if main_obj:
# Collect children of 'Main' object
children = collect_children(main_obj)
if children:
protected_objects.add(main_obj)
protected_objects.update(children)
for obj in all_objects:
# Check if the object is a multiuser instance
if obj.users > 1:
continue # Skip multiuser objects
# # Collect objects for deletion if Z-height is close to 0
# if obj.type == 'MESH' and abs(obj.dimensions.z) < 0.001:
# objects_to_delete_height.add(obj)
# Collect objects for deletion by type
object_types_to_delete = {'CAMERA', 'LIGHT', 'CURVE'}
if obj in protected_objects:
continue # Skip protected objects
if obj.type in object_types_to_delete or (obj.type == 'MESH' and obj.data is None):
objects_to_delete_type.add(obj)
# Check for Empty objects, delete 'Main' only if it has no children
elif obj.type == 'EMPTY' and (obj.name != 'Main' or (obj.name == 'Main' and not obj.children)):
objects_to_delete_type.add(obj)
# # Delete selected objects by height
# bpy.ops.object.select_all(action='DESELECT')
# for obj in objects_to_delete_height:
# obj.select_set(True)
# bpy.ops.object.delete()
# Delete objects by type
for obj in objects_to_delete_type:
bpy.data.objects.remove(obj, do_unlink=True)
# Delete cameras
for camera in bpy.context.scene.collection.objects:
if camera.type == 'CAMERA':
bpy.data.objects.remove(camera, do_unlink=True)
# Delete lights
for light in bpy.context.scene.collection.objects:
if light.type == 'LIGHT':
bpy.data.objects.remove(light, do_unlink=True)
# # Delete Images
# for image in bpy.context.scene.collection.objects:
# if image.type == 'IMAGE':
# bpy.data.objects.remove(image, do_unlink=True)
# Delete Curves
for curve in bpy.context.scene.collection.objects:
if curve.type == 'CURVE':
bpy.data.objects.remove(curve, do_unlink=True)
# Call reparent function since it will delete unnecessary empty objects
# try:
# bpy.ops.object.reparent()
#
# except Exception as e:
# print("Reparent function inside Delete bloat failed:", str(e))
# print("Continuing")
# bpy.ops.object.select_all(action='SELECT')
# bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
# bpy.ops.object.select_all(action='DESELECT')
# bpy.ops.object.empty_add(type='PLAIN_AXES', align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
# bpy.ops.object.select_grouped(type='TYPE')
# bpy.ops.object.delete(use_global=False)
# bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Delete bloat failed:", str(e))
print("Continuing")
# Function to reset model scaling to 0 (Ignores instanced objects)
def reset_scale_to_1():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
# Collect non-empty, non-instanced objects
objects_to_reset_scale = [obj for obj in selected_objects
if obj.type != 'EMPTY' and not obj.is_instancer and obj.data.users == 1]
# Set the active object to the first in the list
if objects_to_reset_scale:
bpy.context.view_layer.objects.active = objects_to_reset_scale[0]
# Apply scale to all objects in batches
batch_size = 10 # Adjust this value based on your scene's performance
for i in range(0, len(objects_to_reset_scale), batch_size):
batch = objects_to_reset_scale[i:i + batch_size]
# Select objects in the batch
for obj in batch:
obj.select_set(True)
# Apply scale
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True, properties=True, isolate_users=False)
# Deselect objects in the batch
for obj in batch:
obj.select_set(False)
# bpy.ops.object.select_all(action='SELECT')
# bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
else:
# Deselect all objects first to ensure we're starting clean
bpy.ops.object.select_all(action='DESELECT')
# Collect non-empty, non-instanced objects without animations, shapekey animations, or constraints
objects_to_reset_scale = [obj for obj in bpy.context.visible_objects
if obj.type == 'MESH'
and not obj.is_instancer
and obj.data.users == 1
and not obj.animation_data
and (not obj.data.shape_keys or not obj.data.shape_keys.animation_data)
and not obj.constraints]
# Set the active object to the first in the list
if objects_to_reset_scale:
bpy.context.view_layer.objects.active = objects_to_reset_scale[0]
# Apply scale to all objects in batches
batch_size = 10 # Adjust this value based on your scene's performance
for i in range(0, len(objects_to_reset_scale), batch_size):
batch = objects_to_reset_scale[i:i + batch_size]
# Select objects in the batch
for obj in batch:
obj.select_set(True)
# Apply scale transformation
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True, properties=True, isolate_users=False)
# Deselect objects in the batch
for obj in batch:
obj.select_set(False)
# Final deselection of all objects
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Reset scale failed:", str(e))
print("Continuing")
# Function to delete any bones or armature in the scene
def delete_armatures_and_bones():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
for obj in selected_objects:
if obj.type == 'ARMATURE':
# Detach all children of the armature
children = [child for child in obj.children if child.type != 'ARMATURE']
for child in children:
# If armature has a parent, set it as the parent for its children
if obj.parent:
child.matrix_parent_inverse = child.matrix_world.inverted()
child.parent = obj.parent
else:
child.matrix_parent_inverse = child.matrix_world.inverted()
child.parent = None
# Delete armature object
bpy.data.objects.remove(obj)
else:
# No selected objects; iterate through objects in the scene
armatures_to_delete = []
for obj in bpy.context.scene.objects:
if obj.type == 'ARMATURE' and obj.visible_get():
armatures_to_delete.append(obj)
# Detach children of each armature
for armature in armatures_to_delete:
children = [child for child in armature.children if child.type != 'ARMATURE']
for child in children:
# If armature has a parent, set it as the parent for its children
if armature.parent:
child.matrix_parent_inverse = child.matrix_world.inverted()
child.parent = armature.parent
else:
child.matrix_parent_inverse = child.matrix_world.inverted()
child.parent = None
# Delete selected armatures
bpy.ops.object.select_all(action='DESELECT')
for obj in armatures_to_delete:
obj.select_set(True)
bpy.ops.object.delete()
# Clear selection
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Delete armature and bones failed:", str(e))
print("Continuing")
# Function to delete any animation data from objects in scene
def delete_animations():
try:
selected_objects = bpy.context.selected_objects
if selected_objects:
# Clear animation data for selected objects
bpy.ops.anim.keyframe_clear_v3d()
bpy.ops.object.select_all(action='DESELECT')
else:
# Get all visible mesh objects in the scene
visible_objects_with_animation = [
obj for obj in bpy.context.scene.objects
if obj.visible_get() and obj.animation_data
]
if not visible_objects_with_animation:
print("No visible objects with animation.")
return # Exit if no visible mesh objects are found
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Select all visible mesh objects
for obj in visible_objects_with_animation:
obj.select_set(True)
# Make one random mesh object active
active_object = random.choice(visible_objects_with_animation)
bpy.context.view_layer.objects.active = active_object
# Clear animation data for selected objects
bpy.ops.anim.keyframe_clear_v3d()
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Delete animations failed:", str(e))
print("Continuing")
# Function to fix LOD namings in all objects in the scene
def lod_rename():
try:
# Get a list of all objects in the scene
objects = bpy.data.objects
# Iterate through all objects
for obj in objects:
# Check if the object name contains "LOD" followed by a number
import re
match = re.search(r'LOD\d+', obj.name)
if match:
# Extract the matched text
lod_text = match.group()
# Remove the matched text from the original name
new_name = obj.name.replace(lod_text, '')
# Append an underscore and the matched text to the end of the name
new_name += '_' + lod_text
# Rename the object with the modified name
obj.name = new_name
except Exception as e:
print("LOD_rename failed:", str(e))
print("Continuing")
# Function to delete duplicated objects in the scene
def select_and_delete_duplicates(threshold=0.1, exclude_text="LOD"):
try:
# bpy.ops.object.select_by_type(type='MESH')
# bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
bpy.ops.object.select_all(action='DESELECT')
# Dictionary to store mesh objects based on their location and shape
mesh_object_data = {}
# Function to calculate the distance between two objects
def distance_threshold(obj1, obj2):
distance = math.sqrt(
(obj1[0] - obj2[0]) ** 2 +
(obj1[1] - obj2[1]) ** 2 +
(obj1[2] - obj2[2]) ** 2
)
return distance <= threshold
# Iterate through all mesh objects in the scene
for obj in bpy.data.objects:
# Check if the object is a mesh, is visible in the scene, and does not contain the exclude_text in its name
if obj.type == 'MESH' and obj.visible_get() and exclude_text not in obj.name:
# Create a tuple with the location and vertices (shape) rounded to 5 decimal places
data_key = (
round(obj.location.x, 5),
round(obj.location.y, 5),
round(obj.location.z, 5),
tuple(round(v.co.x, 5) for v in obj.data.vertices),
tuple(round(v.co.y, 5) for v in obj.data.vertices),
tuple(round(v.co.z, 5) for v in obj.data.vertices)
)
# Check if there are existing objects within the distance threshold
duplicate_found = False
for existing_key in mesh_object_data:
if distance_threshold(data_key, existing_key):
duplicate_found = True
mesh_object_data[existing_key].append(obj)
break
# If no duplicates are found within the threshold, add the object to the dictionary
if not duplicate_found:
mesh_object_data[data_key] = [obj]
# Iterate through the dictionary and delete duplicates, leaving one in each group
for key, mesh_objects in mesh_object_data.items():
if len(mesh_objects) > 1:
for obj in mesh_objects[1:]:
bpy.data.objects.remove(obj, do_unlink=True)
except Exception as e:
print("Delete Duplicated meshes failed:", str(e))
print("Continuing")
# Function to reduce vertex count of objects in the scene
def decimator_v5():
try:
def adjust_ratio(face_count, dimensions):
ratio = 1.0
if sum(1 for dim in dimensions if dim < 0.3) >= 2:
ratio = 0.2
elif face_count >= 100000:
ratio = 0.3
elif face_count >= 50000:
ratio = 0.4
elif face_count >= 10000:
ratio = 0.5
elif face_count >= 5000:
ratio = 0.6
elif face_count >= 2000:
ratio = 0.7
elif face_count >= 800:
ratio = 0.8
return ratio
# Dictionary to store multi-user objects
multi_user_objects = {}
# Get all visible mesh objects
visible_meshes = [obj for obj in bpy.context.scene.objects if obj.type == 'MESH' and obj.visible_get()]
# Iterate over visible mesh objects
for obj in visible_meshes:
# Check if object has less than 800 faces
if len(obj.data.polygons) < 1000:
continue
# Check if object is multi-user
if obj.data.users > 1:
# Check if object type already exists in dictionary
if obj.data.name in multi_user_objects:
continue # Skip this object if another instance of the same type has been processed
multi_user_objects[obj.data.name] = obj # Add object to dictionary
obj = multi_user_objects[obj.data.name] # Use the original object
# Select the object
bpy.context.view_layer.objects.active = obj
bpy.ops.object.mode_set(mode='EDIT')
if not bpy.context.scene.tool_settings.use_transform_correct_face_attributes:
bpy.context.scene.tool_settings.use_transform_correct_face_attributes = True
if not bpy.context.scene.tool_settings.use_transform_correct_keep_connected:
bpy.context.scene.tool_settings.use_transform_correct_keep_connected = True
bpy.ops.mesh.select_all(action='SELECT')
# Calculate face count and dimensions
face_count = len(obj.data.polygons)
dimensions = obj.dimensions
# Adjust ratio based on face count and dimensions
ratio = adjust_ratio(face_count, dimensions)
# Apply decimate operator
bpy.ops.mesh.decimate(ratio=ratio)
# Switch back to object mode
bpy.ops.object.mode_set(mode='OBJECT')
except Exception as e:
print("Decimator v5 failed:", str(e))
print("Continuing")
# Function to pack external data into blend file
def pack_external_data_into_blend_file():
try:
bpy.ops.file.autopack_toggle()
except Exception as e:
print("Pack external data failed:", str(e))
print("Continuing")
# Function to cut meshes into individual floors
def floor_cutter(delete_interval=5):
# Temporary delete instanced meshes
def necessary_model_preparations():
bpy.ops.object.select_by_type(type='MESH')
bpy.ops.object.make_single_user(object=True, obdata=True, material=False, animation=False, obdata_animation=False)
bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
bpy.ops.object.select_all(action='DESELECT')
def delete_leftovers():
# Get all mesh objects with no polygons
objects_to_delete = [obj for obj in bpy.context.scene.objects if obj.type == 'MESH' and len(obj.data.polygons) == 0]
# Select the objects to delete
for obj in objects_to_delete:
obj.select_set(True)
# Delete the selected objects
bpy.ops.object.delete()
bpy.ops.object.select_all(action='DESELECT')
def perform_bisect_operations(objects, heights):
# Create a dictionary to store processed objects for each height
processed_objects_dict = {height: set() for height in heights}
# Counter to keep track of processed objects
processed_count = 0
# Iterate over each height
for height in heights:
print(f"\nRunning bisect operation at height: {height}")
# Iterate over each object
for obj in objects:
print("Processing object:", obj.name if obj else None)
# Check if the object still exists
if obj is None or obj.name not in bpy.context.scene.objects:
print("Object no longer exists. Skipping...")
continue
# Skip the object if it's not a mesh, it's hidden, it has already been processed for this height, it has no polygons, or its z-dimension is zero
if obj.type != 'MESH' or obj.hide_get() or obj.name in processed_objects_dict[height] or len(
obj.data.vertices) == 0 or obj.dimensions.z == 0:
print("Skipping object:", obj.name)
continue
# Add the object to the set of processed objects for this height
processed_objects_dict[height].add(obj.name)
print("Creating copy of object:", obj.name)
# Create a unique copy of the object
copied_obj = obj.copy()
copied_obj.data = obj.data.copy() # Ensure the copied object has its own mesh data
bpy.context.collection.objects.link(copied_obj)
# Add the copied object to the set of processed objects for this height
processed_objects_dict[height].add(copied_obj.name)
# Perform bisect operation on the original object with clear_inner=True
print("Bisecting original object:", obj.name)
bpy.context.view_layer.objects.active = obj
obj.select_set(True)
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.bisect(plane_co=(0, 0, height), plane_no=(0, 0, 1), clear_inner=True, clear_outer=False,
use_fill=True)
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
# Select the copied object
print("Selecting copied object:", copied_obj.name)
copied_obj.select_set(True)
bpy.context.view_layer.objects.active = copied_obj
# Perform bisect operation on the copied object with clear_outer=True
print("Bisecting copied object:", copied_obj.name)
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.bisect(plane_co=(0, 0, height), plane_no=(0, 0, 1), clear_inner=False, clear_outer=True,
use_fill=True)
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
# Increment the processed objects count
processed_count += 1
# Check if it's time to delete leftovers
if processed_count % delete_interval == 0:
print("Deleting leftovers...")
delete_leftovers()
# Get height values from objects in "Floor planes" collection
floor_planes_collection = bpy.data.collections.get("Floor planes")
if not floor_planes_collection:
print("Error: Collection 'Floor planes' not found.")
else:
heights = [obj.location.z for obj in floor_planes_collection.objects if obj.type == 'MESH']
# Get all objects in the scene
objects = bpy.context.scene.objects
necessary_model_preparations()
perform_bisect_operations(objects, heights)
def after_cleanup():
print("Cleaning again")
# Loop through each object
for obj in objects:
# Check if the object is a mesh and has no polygons
if obj.type == 'MESH' and len(obj.data.polygons) == 0:
# Select the object
obj.select_set(True)
else:
obj.select_set(False)
# Delete the selected objects
bpy.ops.object.delete()
bpy.ops.object.select_all(action='DESELECT')
after_cleanup()
def origin_correction():
print("origin correction")
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.object.reset_origin()
origin_correction()
def parent_mesh_objects_based_on_height():
# Define the collection name where floor planes are stored
collection_name = "Floor planes"
# Get the collection
collection = bpy.data.collections.get(collection_name)
if not collection:
print(f"Collection '{collection_name}' not found")
return
# Extract height values from the z location of objects in the collection
floor_data = []
for obj in collection.objects:
if obj.type == 'MESH': # Assuming floor planes are mesh objects
floor_data.append((obj.name, obj.location[2]))
# Sort the floor data by height
floor_data.sort(key=lambda x: x[1])
# Create main parent object to hold all empty floor parents
bpy.ops.object.empty_add(location=(0, 0, 0))
main_parent = bpy.context.active_object
main_parent.name = "Main"
main_parent.empty_display_size = 1.0
# Create empty parent objects for "Floor Architecture", "Interior", and "Others" and store their names
floor_names = []
floor_ranges = []
prev_val = None
for i, (floor_name, height) in enumerate(floor_data):
floor_name_with_index = f"{floor_name} / ZHeight {height:.2f}"
floor_names.append(floor_name_with_index)
if prev_val is not None:
floor_ranges.append((prev_val, height))
prev_val = height
# Create empty object for "Floor Architecture" under main parent
bpy.ops.object.empty_add(location=(0, 0, 0))
floor_parent = bpy.context.active_object
floor_parent.name = floor_name_with_index
floor_parent.empty_display_size = 0.5
floor_parent.parent = main_parent
# Create empty objects for "Architecture", "Interior", and "Others" under each "Floor Architecture"
for category in ["Architecture", "Interior", "Others"]:
bpy.ops.object.empty_add(location=(0, 0, 0))
category_parent = bpy.context.active_object
category_parent.name = f"{floor_name_with_index} {category}"
category_parent.empty_display_size = 0.3
category_parent.parent = floor_parent
# Get z location of visible mesh objects in the scene
visible_mesh_objects_z = {}
for obj in bpy.context.scene.objects:
if obj.type == 'MESH' and obj.visible_get():
visible_mesh_objects_z[obj.name] = obj.location[2]
# Parent mesh objects to corresponding "Architecture" empty parent based on ranges
for obj_name, z_loc in visible_mesh_objects_z.items():
parent_assigned = False
# Handle objects lower than the first specified value
if z_loc < floor_ranges[0][0]:
first_floor_name = floor_names[0]
first_architecture_parent_name = f"{first_floor_name} Architecture"
if first_architecture_parent_name in bpy.data.objects:
first_architecture_parent = bpy.data.objects[first_architecture_parent_name]
obj = bpy.data.objects[obj_name]
obj.parent = first_architecture_parent
parent_assigned = True
# Handle objects within the specified ranges
for i, (start, end) in enumerate(floor_ranges):
if start <= z_loc < end:
floor_name = floor_names[i]
architecture_parent_name = f"{floor_name} Architecture"
if architecture_parent_name in bpy.data.objects:
architecture_parent = bpy.data.objects[architecture_parent_name]
obj = bpy.data.objects[obj_name]
obj.parent = architecture_parent
parent_assigned = True
break
# If no appropriate range found, assign to the last floor
if not parent_assigned and floor_ranges:
last_floor_name = floor_names[-1]
last_architecture_parent_name = f"{last_floor_name} Architecture"
if last_architecture_parent_name in bpy.data.objects:
last_architecture_parent = bpy.data.objects[last_architecture_parent_name]
obj = bpy.data.objects[obj_name]
obj.parent = last_architecture_parent
parent_mesh_objects_based_on_height()
# Remove mesh objects in collection "Floor planes"
def remove_floor_planes():
collection = bpy.data.collections.get("Floor planes")
if collection:
for obj in collection.objects:
if obj.type == 'MESH':
bpy.data.objects.remove(obj, do_unlink=True)
remove_floor_planes()
# Remove increment suffix from empty objects' names
def remove_increment_suffix():
for obj in bpy.data.objects:
if obj.type == 'EMPTY':
original_name = obj.name
# Check if name ends with increment suffix
dot_index = original_name.rfind('.')
if dot_index != -1 and original_name[dot_index+1:].isdigit():
# Remove increment suffix
new_name = original_name[:dot_index]
obj.name = new_name
# remove_increment_suffix()
# Function to dynamically update Default Floor slider inside Floor cutter
def update_default_floor(self, context):
scene = context.scene
max_floors = scene.number_of_floors
# Ensure default_floor does not exceed number_of_floors
if scene.default_floor > max_floors:
scene.default_floor = max_floors
# Function to dynamically update Nubmer of Floors slider inside Floor cutter
def update_number_of_floors(self, context):
update_default_floor(self, context)
# Function to display heatmap by polygon number
def display_heatmap_by_polygons():
# Precompute color mapping
color_mapping = {
(0, 800): (0.0, 1.0, 0.0, 1.0), # Good
(801, 5000): (1.0, 0.5, 0.0, 1.0), # Mid
(5001, float('inf')): (1.0, 0.0, 0.0, 1.0) # Bad
}
# Batch face color assignment
processed_meshes = set()
for obj in bpy.context.visible_objects:
if obj.type == 'MESH' and obj.data.polygons:
mesh_data = obj.data
# Skip if this mesh data has already been processed
if mesh_data in processed_meshes:
continue
num_polygons = len(mesh_data.polygons)
# Determine the color based on the number of polygons using color_mapping
color = next((mapped_color for (min_polygons, max_polygons), mapped_color in color_mapping.items()
if min_polygons <= num_polygons <= max_polygons), None)
if color is not None:
# Ensure the mesh has a vertex color layer named "Heatmap"
color_layer = mesh_data.vertex_colors.get("Heatmap")
if color_layer is None:
color_layer = mesh_data.vertex_colors.new(name="Heatmap")
# Set "Heatmap" as the active vertex color layer
mesh_data.vertex_colors.active = color_layer
# Set the color for all faces of the object
color_data = [color] * len(mesh_data.loops)
# Use batch update with `foreach_set`
color_layer.data.foreach_set("color", [component for loop in mesh_data.loops for component in color])
# Mark this mesh data as processed
processed_meshes.add(mesh_data)
# Set the shading color type to 'VERTEX' in the active 3D Viewport
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D':
space.shading.color_type = 'VERTEX'
break
break
# Function to visualize backface culling
def create_face_color_manager():
# Store the original colors in the closure
original_face_front_color = None
original_face_back_color = None
def set_face_colors(face_front_rgba, face_back_rgba):
nonlocal original_face_front_color, original_face_back_color
# Retrieve the current active theme
active_theme = bpy.context.preferences.themes.items()[0][1]
# Access the ThemeView3D settings
theme_view3d = active_theme.view_3d
# Store the original colors if not already stored
if original_face_front_color is None:
original_face_front_color = theme_view3d.face_front[:]
if original_face_back_color is None:
original_face_back_color = theme_view3d.face_back[:]
# Modify the face_front and face_back properties with provided RGBA values
theme_view3d.face_front = face_front_rgba
theme_view3d.face_back = face_back_rgba
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D':
if not space.overlay.show_face_orientation:
space.overlay.show_face_orientation = True
break
def restore_face_colors():
nonlocal original_face_front_color, original_face_back_color
# Retrieve the current active theme
active_theme = bpy.context.preferences.themes.items()[0][1]
# Access the ThemeView3D settings
theme_view3d = active_theme.view_3d
# Restore the original colors if they were stored
if original_face_front_color is not None:
theme_view3d.face_front = original_face_front_color
original_face_front_color = None # Reset to allow setting new one
if original_face_back_color is not None:
theme_view3d.face_back = original_face_back_color
original_face_back_color = None # Reset to allow setting new one
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D':
if space.overlay.show_face_orientation:
space.overlay.show_face_orientation = False
break
return set_face_colors, restore_face_colors
# Function to clear heatmap data
def clear_heatmap_data():
attribute_name = 'Heatmap'
# Loop through each object in the scene
for obj in bpy.data.objects:
if obj.type == 'MESH':
# Access the mesh data
mesh_data = obj.data
# Check if the vertex color layer with the specified name exists
if attribute_name in mesh_data.color_attributes:
# Remove the vertex color layer directly
mesh_data.color_attributes.remove(mesh_data.color_attributes[attribute_name])
# Set the shading color type to 'MATERIAL' in all 3D Viewports
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D':
space.shading.color_type = 'MATERIAL'
break
break
# Function to visualize instanced meshes (Multi user objects)
def display_heatmap_by_instances():
# Define the colors to be used for multiuser and non-multiuser objects
multiuser_color = (0.0, 1.0, 0.0, 1.0) # Green
non_multiuser_color = (1.0, 0.0, 0.0, 1.0) # Red
# Track processed mesh data blocks to handle each only once
processed_meshes = set()
# Iterate over all objects in the scene
for obj in bpy.context.visible_objects:
if obj.type == 'MESH' and obj.data.polygons:
mesh_data = obj.data
# Skip if this mesh data has already been processed
if mesh_data in processed_meshes:
continue
# Determine the color based on whether the object is multiuser or not
color = multiuser_color if mesh_data.users > 1 else non_multiuser_color
# Ensure the mesh has a vertex color layer named "Heatmap"
color_layer = mesh_data.vertex_colors.get("Heatmap")
if color_layer is None:
color_layer = mesh_data.vertex_colors.new(name="Heatmap")
# Set "Heatmap" as the active vertex color layer
mesh_data.vertex_colors.active = color_layer
# Set the color for all faces of the object
# Use a list comprehension for faster color data setup
color_data = [color] * len(mesh_data.loops)
# Use batch update with `foreach_set`
color_layer.data.foreach_set("color", [comp for loop in mesh_data.loops for comp in color])
# Mark this mesh data as processed
processed_meshes.add(mesh_data)
# Set the shading color type to 'VERTEX' in the active 3D Viewport
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D':
space.shading.color_type = 'VERTEX'
space.overlay.show_face_orientation = False
break
break
# Function to visualize objects by their mesh density
def display_heatmap_by_density():
orange_threshold = 0.2
red_threshold = 0.1
# Define color mapping
green_color = (0.0, 1.0, 0.0, 1.0) # Green
orange_color = (1.0, 0.5, 0.0, 1.0) # Orange
red_color = (1.0, 0.0, 0.0, 1.0) # Red
# Batch face color assignment
processed_meshes = set()
for obj in bpy.context.visible_objects:
if obj.type == 'MESH' and obj.data.polygons:
mesh_data = obj.data
# Skip if this mesh data has already been processed
if mesh_data in processed_meshes:
continue
# Ensure the mesh has a vertex color layer named "Heatmap"
color_layer = mesh_data.vertex_colors.get("Heatmap")
if color_layer is None:
color_layer = mesh_data.vertex_colors.new(name="Heatmap")
# Set "Heatmap" as the active vertex color layer
mesh_data.vertex_colors.active = color_layer
# Get the transformation matrix of the object
obj_matrix = obj.matrix_world
# Function to check if vertices are closely packed
def vertices_are_close(face, threshold):
vertices = [obj_matrix @ mesh_data.vertices[vertex].co for vertex in face.vertices]
for i, v1 in enumerate(vertices):
for v2 in vertices[i+1:]:
distance = (v1 - v2).length
if distance > threshold:
return False
return True
# Set the color for faces based on vertex density
for poly in mesh_data.polygons:
if vertices_are_close(poly, red_threshold):
color = red_color
elif vertices_are_close(poly, orange_threshold):
color = orange_color
else:
color = green_color
for loop_index in poly.loop_indices:
color_layer.data[loop_index].color = color
# Mark this mesh data as processed
processed_meshes.add(mesh_data)
# Set the shading color type to 'VERTEX' in the active 3D Viewport
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D':
space.shading.color_type = 'VERTEX'
break
break
# Function to bake animations to keyframes
def bake_animations():
blender_version = bpy.app.version
# Get the frame start and frame end from the current scene
scene = bpy.context.scene
frame_start = scene.frame_start
frame_end = scene.frame_end
# Deselect all objects first
bpy.ops.object.select_all(action='DESELECT')
# Collect objects that need to be selected in one iteration
objects_to_select = set() # Using a set to avoid duplicates
for obj in bpy.data.objects:
# Check if the object is visible
if obj.visible_get():
# Add object if it has animation data
if obj.animation_data is not None:
objects_to_select.add(obj)
# If the object is an armature, also select the armature itself
if obj.type == 'ARMATURE' and obj.animation_data is not None:
objects_to_select.add(obj)
# Add all objects parented to this armature or its bones
for child_obj in bpy.data.objects:
if child_obj.parent == obj or (child_obj.parent_type == 'BONE' and child_obj.parent == obj):
objects_to_select.add(child_obj)
# If the object's parent has animation data, select the object
if obj.parent is not None and obj.parent.animation_data is not None:
objects_to_select.add(obj)
# Select all the collected objects
for obj in objects_to_select:
obj.select_set(True)
if blender_version >= (4, 1, 0):
# Use the frame_start and frame_end from the scene
bpy.ops.nla.bake(
frame_start=frame_start,
frame_end=frame_end,
step=1,
only_selected=True,
visual_keying=True,
clear_constraints=True,
clear_parents=False,
use_current_action=False,
clean_curves=False,
bake_types={'OBJECT'}, # Bake only OBJECT animation (no pose bones)
channel_types={'BBONE', 'LOCATION', 'PROPS', 'ROTATION', 'SCALE'}
)
else:
# Use the frame_start and frame_end from the scene
bpy.ops.nla.bake(
frame_start=frame_start,
frame_end=frame_end,
step=1,
only_selected=True,
visual_keying=True,
clear_constraints=True,
clear_parents=False,
use_current_action=False,
clean_curves=False,
bake_types={'OBJECT'}, # Bake only OBJECT animation (no pose bones)
)
bpy.ops.object.select_all(action='DESELECT')
# Function to delete non visible geometry via camera array and raycasting
def delete_non_visible_geometry():
previous_resolution_x = None
previous_resolution_y = None
previous_camera_type = None
def create_vertex_groups():
# Create a new vertex group with the same name as the object
vertex_group = obj.vertex_groups.new(name=obj.name)
# Access the bmesh data of the object
bm = bmesh.new()
bm.from_mesh(obj.data)
# Add all vertices to the vertex group
for v in bm.verts:
vertex_group.add([v.index], 1.0, 'ADD')
# Clean up the bmesh
bm.free()
def delete_vertex_groups():
# Collect the vertex groups that match the object's name
groups_to_delete = [vg for vg in obj.vertex_groups if vg.name == obj.name]
# Remove the collected vertex groups
for group in groups_to_delete:
obj.vertex_groups.remove(group)
def set_origin_to_cursor():
# Select all objects with linked data
bpy.ops.object.select_linked(type='OBDATA')
# Set the origin of all selected objects to the 3D cursor
bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')
# Optionally, you can deselect all objects after the operation
bpy.ops.object.select_all(action='DESELECT')
def set_origin_to_geometry():
# Select all objects with linked data
bpy.ops.object.select_linked(type='OBDATA')
# Set the origin of all selected objects to the 3D cursor
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
# Optionally, you can deselect all objects after the operation
bpy.ops.object.select_all(action='DESELECT')
def get_or_create_collection(name):
"""Helper function to get or create a collection."""
collection = bpy.data.collections.get(name)
if collection is None:
collection = bpy.data.collections.new(name)
bpy.context.scene.collection.children.link(collection)
return collection
def store_current_data():
nonlocal previous_resolution_x, previous_resolution_y, previous_camera_type
scene = bpy.context.scene
# Get active camera data
if scene.camera:
camera = scene.camera.data
# Store camera type if camera exists
previous_camera_type = camera.type
# Store resolution
previous_resolution_x = scene.render.resolution_x
previous_resolution_y = scene.render.resolution_y
def set_scene_resolution():
scene = bpy.context.scene
# Set new render resolution to 800x800
scene.render.resolution_x = 800
scene.render.resolution_y = 800
def restore_previous_data():
nonlocal previous_resolution_x, previous_resolution_y, previous_camera_type
# Check if previous resolution data exists
if previous_resolution_x is not None and previous_resolution_y is not None:
scene = bpy.context.scene
# Restore the resolution
scene.render.resolution_x = previous_resolution_x
scene.render.resolution_y = previous_resolution_y
# Check if previous camera type data exists
if previous_camera_type is not None:
# Get active camera data
if scene.camera:
camera = scene.camera.data
camera.type = previous_camera_type
def create_camera(name, location, obj_bbox_size, scale_multiplier):
"""Create and return a camera with orthographic scale set dynamically and adjusted by a multiplier."""
# Create the camera object
camera_data = bpy.data.cameras.new(name)
camera = bpy.data.objects.new(name, camera_data)
# Set the camera's location
camera.location = location
# Set the camera to orthographic mode
camera.data.type = 'ORTHO'
# Compute the base orthographic scale based on the object's bounding box size
base_ortho_scale = obj_bbox_size * 0.75 # Base scale adjustment
# Apply the multiplier to the base orthographic scale
camera.data.ortho_scale = base_ortho_scale * scale_multiplier
return camera
def create_cameras_around_object(num_cameras=8, scale=15, collection_name="BOPCameraArrayCollection", scale_multiplier=2.0, close_camera_factor=0.5):
# Check if there is an active object
if bpy.context.active_object is None:
raise ValueError("No active object found. Please select an object.")
# Get the active object
obj = bpy.context.active_object
# Ensure the object is a MESH
if obj.type != 'MESH':
raise ValueError("Active object is not a MESH. Please select a MESH object.")
# Get the object's bounding box dimensions in world space
bbox_corners = [obj.matrix_world @ mathutils.Vector(corner) for corner in obj.bound_box]
bbox_min = mathutils.Vector((min([v.x for v in bbox_corners]), min([v.y for v in bbox_corners]), min([v.z for v in bbox_corners])))
bbox_max = mathutils.Vector((max([v.x for v in bbox_corners]), max([v.y for v in bbox_corners]), max([v.z for v in bbox_corners])))
# Calculate the center of the bounding box in world coordinates
bbox_center = (bbox_max + bbox_min) / 2
# Calculate the bounding box size (diagonal length)
bbox_size = (bbox_max - bbox_min).length
# Set the radius as a function of the bounding box size
radius = bbox_size * 1.5 # Adjust multiplier to control how far cameras are placed
# # Remove existing cameras
# cameras = [obj for obj in bpy.data.objects if obj.type == 'CAMERA']
# for cam in cameras:
# bpy.data.objects.remove(cam, do_unlink=True)
# Create a collection for the cameras
camera_collection = get_or_create_collection(collection_name)
### Create the 90-degree cameras (horizontal ring, no change in Z)
for i in range(num_cameras):
angle = (2 * math.pi / num_cameras) * i # Distribute cameras evenly in a circle
x = math.cos(angle) * radius
y = math.sin(angle) * radius
z = bbox_center.z # Use the Z of the bounding box center in world coordinates
# Convert to world coordinates relative to the bounding box center
camera_location = bbox_center + mathutils.Vector((x, y, 0)) # Z stays at bbox_center.z
# Create and position the camera with dynamic orthographic scale and multiplier
camera_name = f"Camera_90deg_{i+1}"
camera = create_camera(camera_name, camera_location, bbox_size, scale_multiplier)
vertex_group_name = obj.name
# Use 'Track To' constraint to make the camera always look at the object
track_to = camera.constraints.new(type='TRACK_TO')
track_to.target = obj
track_to.subtarget = vertex_group_name
track_to.track_axis = 'TRACK_NEGATIVE_Z' # Track along negative Z axis
track_to.up_axis = 'UP_Y' # Keep Y axis as the up direction
# Link the camera to the collection
camera_collection.objects.link(camera)
### Create the 60-degree cameras (closer to the object and slightly elevated)
elevation_scaling_factor = 0.75 # Factor to lower the elevation of 60-degree cameras
closer_radius = radius * close_camera_factor # Bring the 60-degree cameras closer
for i in range(num_cameras):
angle = (2 * math.pi / num_cameras) * i # Distribute cameras evenly in a circle
x = math.cos(angle) * closer_radius # Use the closer radius
y = math.sin(angle) * closer_radius # Use the closer radius
z = bbox_center.z + closer_radius * math.tan(math.radians(50)) * elevation_scaling_factor # Reduced Z elevation
# Convert to world coordinates relative to the bounding box center
camera_location = bbox_center + mathutils.Vector((x, y, z - bbox_center.z)) # Adjust Z based on bbox_center
# Create and position the camera with dynamic orthographic scale and multiplier
camera_name = f"Camera_60deg_{i+1}"
camera = create_camera(camera_name, camera_location, bbox_size, scale_multiplier)
vertex_group_name = obj.name
# Use 'Track To' constraint to make the camera always look at the object
track_to = camera.constraints.new(type='TRACK_TO')
track_to.target = obj
track_to.subtarget = vertex_group_name
track_to.track_axis = 'TRACK_NEGATIVE_Z' # Track along negative Z axis
track_to.up_axis = 'UP_Y' # Keep Y axis as the up direction
# Link the camera to the collection
camera_collection.objects.link(camera)
### Create and position the top-down camera (no angle here, directly above)
top_down_camera_name = "Camera_TopDown"
top_down_camera_location = bbox_center + mathutils.Vector((0, 0, radius)) # Set height based on radius
top_down_camera = create_camera(top_down_camera_name, top_down_camera_location, bbox_size, scale_multiplier)
vertex_group_name = obj.name
# Set the top-down camera to look directly at the object using the 'Track To' constraint
track_to_top_down = top_down_camera.constraints.new(type='TRACK_TO')
track_to_top_down.target = obj
track_to_top_down.subtarget = vertex_group_name
track_to_top_down.track_axis = 'TRACK_NEGATIVE_Z'
track_to_top_down.up_axis = 'UP_Y'
# Link the top-down camera to the collection
camera_collection.objects.link(top_down_camera)
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Reselect and activate the original object
obj.select_set(True)
bpy.context.view_layer.objects.active = obj
def get_camera_rays(scene, obj):
"""Generate rays from all cameras to multiple points on each face of the object with adaptive sampling."""
matrix_world = obj.matrix_world
rays = []
bm = bmesh.new()
bm.from_mesh(obj.data)
bm.faces.ensure_lookup_table()
# Directly access the 'BOPCameraArrayCollection'
camera_collection = scene.collection.children['BOPCameraArrayCollection']
# Get all cameras in the collection
cameras = [obj for obj in camera_collection.objects if obj.type == 'CAMERA']
# Define thresholds for small, medium, and large face areas
small_face_threshold = 0.5 # Faces smaller than this will be considered "small"
large_face_threshold = 1.0 # Faces larger than this will be considered "large"
for face in bm.faces:
# Calculate face center in world space
face_center = matrix_world @ face.calc_center_median()
face_verts = [matrix_world @ vert.co for vert in face.verts]
# Calculate face area
face_area = face.calc_area()
# Initialize points to cast rays at (start with the center)
face_points = [face_center]
# Adaptive sampling based on face area
if face_area > large_face_threshold:
# Large face: Use center, vertices, and midpoints
midpoints = []
for i in range(len(face_verts)):
next_i = (i + 1) % len(face_verts)
midpoint = (face_verts[i] + face_verts[next_i]) / 2
midpoints.append(midpoint)
face_points += face_verts + midpoints # Add vertices and midpoints
elif face_area > small_face_threshold:
# Medium face: Use center and vertices
face_points += face_verts # Add vertices
# Small faces only use the center (already included)
for camera in cameras:
for point in face_points:
# Calculate the ray direction from the camera to the face point
ray_direction = (point - camera.location).normalized()
rays.append((camera.location, ray_direction, face.index))
bm.free()
return rays
def batch_ray_casts(rays, bvh_tree, obj_matrix_world):
"""Process ray casts using BVH tree."""
visible_faces = set()
for ray_origin, ray_direction, face_index in rays:
# Transform ray origin and direction to local space of the object
local_ray_origin = obj_matrix_world.inverted() @ ray_origin
local_ray_direction = obj_matrix_world.inverted().to_3x3() @ ray_direction
# Cast ray in the BVH tree
hit_location, hit_normal, hit_index, hit_distance = bvh_tree.ray_cast(local_ray_origin, local_ray_direction)
if hit_index == face_index:
visible_faces.add(face_index)
return visible_faces
def delete_non_visible_geometry(obj, threshold=0.9, collection_name="BOPCameraArrayCollection"):
"""Delete geometry that is not visible from any camera using BVH tree."""
# Switch to object mode
bpy.ops.object.mode_set(mode='OBJECT')
# Start BMesh processing
bm = bmesh.new()
bm.from_mesh(obj.data)
bm.faces.ensure_lookup_table()
# Build BVH Tree
bvh = bvhtree.BVHTree.FromBMesh(bm)
# Generate camera rays for all cameras
camera_rays = get_camera_rays(bpy.context.scene, obj)
# Check visibility of faces
obj_matrix_world = obj.matrix_world
visible_faces = batch_ray_casts(camera_rays, bvh, obj_matrix_world)
faces_to_delete = []
for face in bm.faces:
if face.index not in visible_faces:
faces_to_delete.append(face)
# Apply threshold to faces_to_delete
# num_faces_to_delete = int(len(faces_to_delete) * threshold)
# faces_to_delete = faces_to_delete[:num_faces_to_delete]
# Delete faces
if faces_to_delete:
bmesh.ops.delete(bm, geom=faces_to_delete, context='FACES')
bm.to_mesh(obj.data)
bm.free()
if collection_name in bpy.data.collections:
# Get the collection
collection = bpy.data.collections[collection_name]
# Iterate through the objects in the collection
for obj in collection.objects:
# Check if the object is a camera
if obj.type == 'CAMERA':
# Delete the camera
bpy.data.objects.remove(obj, do_unlink=True)
# After all cameras are deleted, remove the collection
bpy.data.collections.remove(collection)
store_current_data()
set_scene_resolution()
# This will keep track of processed multi user object (Its important to keep this, otherwise blender will most likely crash)
processed_meshes = set()
selected_objects = bpy.context.selected_objects
if selected_objects:
# Iterate through objects in the scene
for obj in selected_objects:
# Check if the object is a mesh and if it's visible in the scene
if obj.type == 'MESH' and not obj.modifiers and obj.visible_get():
# Check if this mesh data has already been processed
if obj.data in processed_meshes:
# print(f"Skipped {obj.name}: Already processed another object with the same mesh data")
continue
# Check the number of polygons (faces)
num_faces = len(obj.data.polygons)
if num_faces > 4:
# Mark this mesh data as processed
processed_meshes.add(obj.data)
# Set the object as active
bpy.context.view_layer.objects.active = obj
# Perform operations
create_vertex_groups()
# set_origin_to_geometry()
create_cameras_around_object()
# set_origin_to_cursor()
delete_non_visible_geometry(obj)
# set_origin_to_geometry()
delete_vertex_groups()
obj.data.update()
# Deselect the object
obj.select_set(False)
# else:
# print(f"Skipped {obj.name}: Only {num_faces} polygons")
# else:
# print(f"Skipped {obj.name}: Not a visible mesh object")
else:
# Iterate through objects in the scene
for obj in bpy.context.scene.objects:
# Check if the object is a mesh and if it's visible in the scene
if obj.type == 'MESH' and not obj.modifiers and obj.visible_get():
# Check if this mesh data has already been processed
if obj.data in processed_meshes:
# print(f"Skipped {obj.name}: Already processed another object with the same mesh data")
continue
# Check the number of polygons (faces)
num_faces = len(obj.data.polygons)
if num_faces > 3500:
# Mark this mesh data as processed
processed_meshes.add(obj.data)
# Set the object as active
bpy.context.view_layer.objects.active = obj
# Perform operations
create_vertex_groups()
# set_origin_to_geometry()
create_cameras_around_object()
# set_origin_to_cursor()
delete_non_visible_geometry(obj)
# set_origin_to_geometry()
delete_vertex_groups()
obj.data.update()
# Deselect the object
obj.select_set(False)
# else:
# print(f"Skipped {obj.name}: Only {num_faces} polygons")
# else:
# print(f"Skipped {obj.name}: Not a visible mesh object")
restore_previous_data()
#----------------------------Operators----------------------------#
# Operator to execute check updates
class CheckForUpdateOperator(bpy.types.Operator):
"""Check updates"""
bl_idname = "wm.check_for_update"
bl_label = "BOP - Check for Update"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
check_for_update()
print("Operator: check_for_update() executed")
return {'FINISHED'}
# Operator to execute the delete downward faces function
class OBJECT_OT_delete_downward_faces(bpy.types.Operator):
"""It will delete all mesh faces which normals are facing down (Z-). Function also ignore objects with active modifiers. (If wrong faces are deleted, try to use Reset Scale to 1 function at first"""
bl_idname = "object.delete_downward_faces"
bl_label = "BOP - Delete Downward Faces"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
delete_downward_faces()
print("Operator: delete_downward_faces(threshold) executed")
return {'FINISHED'}
# Operator to convert from tris to quads
class OBJECT_OT_tris_to_quads(bpy.types.Operator):
"""It will convert Triangulated mesh into the Quads for a Unity"""
bl_idname = "object.tris_to_quads"
bl_label = "BOP - Tris to Quads"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
tris_to_quads()
print("Operator: delete_downward_faces(threshold) executed")
return {'FINISHED'}
# Operator to execute the auto-smooth function
class OBJECT_OT_auto_smooth_all(bpy.types.Operator):
"""It will smooth out mesh normals to default value. Usually it’s 30°"""
bl_idname = "object.auto_smooth_all"
bl_label = "BOP - Auto Smooth All"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
apply_auto_smooth()
print("Operator: apply_auto_smooth() executed")
return {'FINISHED'}
# Operator to delete custom split normals data
class OBJECT_OT_delete_custom_normals(bpy.types.Operator):
"""Custom Split Normals are a way to tweak/fake shading by pointing them towards other directions than default, auto-computed ones. By deleting them 3D model switch to default one provided by Blender"""
bl_idname = "object.delete_custom_normals"
bl_label = "BOP - Delete Custom Normals"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
delete_custom_split_normals()
print("Operator: delete_custom_split_normals() executed")
return {'FINISHED'}
# Operator to execute the merge close vertices function
class OBJECT_OT_merge_close_vertices(bpy.types.Operator):
"""It will merge connected or unconnected vertices which positions are exact or very close (Threshold is 0.001)"""
bl_idname = "object.merge_close_vertices"
bl_label = "BOP - Merge Close Vertices"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
merge_close_vertices()
print("Operator: merge_close_vertices() executed")
return {'FINISHED'}
# Operator to execute limited dissolve function
class OBJECT_OT_limited_dissolve(bpy.types.Operator):
"""It will simplify your mesh by dissolving vertices and edges separating flat regions. Reduces detail on planar faces and linear edges"""
bl_idname = "object.limited_dissolve"
bl_label = "BOP - Limited Dissolve"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
limited_dissolve()
print("Operator: limited_dissolve() executed")
return {'FINISHED'}
# Operator to remove unused datablocks
class OBJECT_OT_remove_unused_datablocks(bpy.types.Operator):
"""It will make sure that all non necessary or unused data are deleted so exported model will be clean (Applies on whole scene)"""
bl_idname = "object.remove_unused_datablocks"
bl_label = "BOP - Remove Unused Datablocks"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
remove_unused_datablocks()
print("Operator: remove_unused_datablocks() executed")
return {'FINISHED'}
# Operator to reparent mesh for Unity
class OBJECT_OT_reparent(bpy.types.Operator):
"""It will put all objects inside scene under the empty parent object in order to function properly in Unity (Applies on all objects) Also it will keep hierarchy for multi-storey buildings"""
bl_idname = "object.reparent"
bl_label = "BOP - Reparent"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
reparent(['Outside', 'Interior', 'Architecture', 'Floor'])
print("Operator: reparent(['Outside', 'Interior', 'Architecture', 'Floor']) executed")
return {'FINISHED'}
# Operator to recalculate normals
class OBJECT_OT_recalculate_normals(bpy.types.Operator):
"""It will recalculate the normals of selected faces so that they point outside the volume that the face belongs to"""
bl_idname = "object.recalculate_normals"
bl_label = "BOP - Recalculate Mesh Normals"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
recalculate_normals()
print("Operator: recalculate_normals() executed")
return {'FINISHED'}
# Operator to execute the open documentation URL function
class OBJECT_OT_open_url_operator(bpy.types.Operator):
"""It will open addon documentations in default web browser"""
bl_idname = "object.open_url_operator"
bl_label = "BOP - Open URL"
bl_options = {'REGISTER', 'UNDO'}
url: bpy.props.StringProperty(name="URL", default="https://twinzo.atlassian.net/wiki/spaces/PUBD/pages/104398849/Blender+Optimization+package+BOP")
def execute(self, context):
open_url(self.url)
print("Operator: open_url(self.url) executed")
return {'FINISHED'}
# Operator to execute the rotate model function
class OBJECT_OT_rotate_model_to_highest_normal_direction(bpy.types.Operator):
"""It will rotate 3D model in such a way, that side with higher average number of normals facing corresponding direction will be rotated to facing up (Z+). Function is intended to use on Scanned meshes!"""
bl_idname = "object.rotate_model_operator"
bl_label = "BOP - Rotate Scan"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
rotate_model_operator()
print("Operator: rotate_model_operator() executed")
return {'FINISHED'}
# Operator to execute the reset origin function
class OBJECT_OT_reset_origin(bpy.types.Operator):
"""It will set objects origin point to their relative median position"""
bl_idname = "object.reset_origin"
bl_label = "BOP - Reset Origin"
bl_options = set()
def execute(self, context):
reset_origin()
bpy.ops.ed.undo_push(message='BOP - Reset Origin')
print("Operator: reset_origin() executed")
return {'FINISHED'}
# Operator to execute Reset scene to original state
class OBJECT_OT_reset_to_original_state(bpy.types.Operator):
"""It will reset everythig to the original state, USE IT WITH CAUTION!"""
bl_idname = "object.reset"
bl_label = "BOP - Reset to original state"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
reset_to_original_state()
print("Operator: reset_to_original_state() executed")
return {'FINISHED'}
# Operator to execute remove duplicated materials function
class OBJECT_OT_merge_similar_materials(bpy.types.Operator):
"""It will merge similar materials based on their values and colors (Applies on all objects in project)"""
bl_idname = "object.merge_similar_materials"
bl_label = "BOP - Remove duplicated materials"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
merge_similar_materials()
print("Operator: merge_similar_materials() executed")
return {'FINISHED'}
# Operator to execute create instanced objects function
class OBJECT_OT_create_instances(bpy.types.Operator):
"""It will make identic or very similar objects as a instanced one. It is best to use it after Reset Origin function. Applies on all objects in scene!"""
bl_label = "BOP - Create Instances"
bl_idname = "object.create_instances"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
try:
# Get all visible mesh objects in the scene
visible_mesh_objects = [
obj for obj in bpy.context.scene.objects
if obj.type == 'MESH' and obj.visible_get()
]
if not visible_mesh_objects:
print("No visible mesh objects in the scene.")
return {'CANCELLED'}
# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')
# Select all visible mesh objects
for obj in visible_mesh_objects:
obj.select_set(True)
# Make one random mesh object active
active_object = random.choice(visible_mesh_objects)
bpy.context.view_layer.objects.active = active_object
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.mode_set(mode='OBJECT')
# obj = bpy.context.view_layer.objects.active
# if not obj or obj.type != 'MESH':
# mesh_objects = [obj for obj in bpy.context.visible_objects if obj.type == 'MESH' and len(obj.data.vertices) != 0]
# if mesh_objects:
# obj = mesh_objects[0]
# bpy.context.view_layer.objects.active = obj
# else:
# return {'CANCELLED'}
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bm = bmesh.from_edit_mesh(obj.data)
vertices_sorted = sorted(bm.verts, key=lambda v: v.co.z)
vertex_mapping = {old_index: new_index for new_index, old_index in enumerate(v.index for v in vertices_sorted)}
bpy.ops.mesh.select_all(action='DESELECT')
for v in bm.verts:
v.index = vertex_mapping[v.index]
bmesh.update_edit_mesh(obj.data)
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
threshold_distance = 0.03
object_data = [obj for obj in bpy.context.visible_objects if obj.type == 'MESH' and len(obj.data.vertices) != 0]
object_groups = {}
for obj1 in object_data:
added_to_group = False
for group, group_objects in object_groups.items():
obj2 = group_objects[0]
if compare_objects(obj1, obj2, threshold_distance):
group_objects.append(obj1)
added_to_group = True
break
if not added_to_group:
object_groups[obj1] = [obj1]
for group_objects in object_groups.values():
if len(group_objects) > 1:
original_obj = group_objects[0]
for obj in group_objects[1:]:
obj.data = original_obj.data
except Exception as e:
print("Object instancer failed:", str(e))
print("Continuing")
print("Operator: object.create_instances() executed")
return {'FINISHED'}
# Operator to execute object separator function
class OBJECT_OT_object_separator(bpy.types.Operator):
"""It will separate objects by loose parts (Its best to use it before Object Instancer and script will also ignore Instanced meshes!)"""
bl_idname = "object.object_separator"
bl_label = "BOP - Object Separator"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
object_separator()
print("Operator: object_separator() executed")
return {'FINISHED'}
# Operator to execute delete bloat function
class OBJECT_OT_delete_bloat(bpy.types.Operator):
"""It will delete unnecessary types of objects like (Empty, Lights, Objects without mesh data). (Its best to use it before Object Instancer and Reparent function!)"""
bl_idname = "object.delete_bloat"
bl_label = "BOP - Delete bloat"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
delete_bloat()
print("Operator: delete_bloat() executed")
return {'FINISHED'}
# Operator to execute reset scale of objects to 1 function
class OBJECT_OT_reset_scale_to_1(bpy.types.Operator):
"""It will reset object scale values in scene to 1 (Ignores empty and instances)"""
bl_idname = "object.reset_scale_to_1"
bl_label = "BOP - Reset scale to 1"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
reset_scale_to_1()
print("Operator: reset_scale_to_1() executed")
return {'FINISHED'}
# Operator to execute delete armatures and bones function
class OBJECT_OT_delete_armatures_and_bones(bpy.types.Operator):
"""It will delete visible armature or bones in scene (Nested objects will be preserved)"""
bl_idname = "object.delete_armatures_and_bones"
bl_label = "BOP - Delete armature or bones"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
delete_armatures_and_bones()
print("Operator: delete_armatures_and_bones() executed")
return {'FINISHED'}
# Operator to execute delete animations function
class OBJECT_OT_delete_animations(bpy.types.Operator):
"""It will delete animations on visible objects in scene"""
bl_idname = "object.delete_animations"
bl_label = "BOP - Delete animations in scene"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
delete_animations()
print("Operator: delete_animations() executed")
return {'FINISHED'}
# Operator to execute delete animations function
class OBJECT_OT_lod_rename(bpy.types.Operator):
"""It will adjust LOD names in order to work with Unity"""
bl_idname = "object.lod_rename"
bl_label = "BOP - LOD_Rename"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
lod_rename()
print("Operator: lod_rename() executed")
return {'FINISHED'}
# Operator to execute delete duplicated meshes function
class OBJECT_OT_delete_duplicated_meshes(bpy.types.Operator):
"""It will delete duplicated meshes which are roughly at the same location and same shape"""
bl_idname = "object.delete_duplicated_meshes"
bl_label = "BOP - Delete_Duplicated_meshes"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
select_and_delete_duplicates()
print("Operator:select_and_delete_duplicates() executed")
return {'FINISHED'}
# Operator to execute export model function
class OBJECT_OT_export_model(bpy.types.Operator):
"""It will export selected models as FBX file"""
bl_idname = "object.export_model"
bl_label = "BOP - Export model"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
try:
# Check if the specified export path is valid
export_path = context.scene.export_path
# Add ".fbx" suffix if not already present
if not export_path.lower().endswith(".fbx"):
export_path += "BOP.fbx"
if not os.path.isabs(export_path):
self.report({'ERROR'}, "Invalid export path")
return {'CANCELLED'}
# Check if there are already selected objects
selected_objects = bpy.context.selected_objects
if selected_objects:
# Export FBX with custom settings using the specified export path
bpy.ops.export_scene.fbx(
filepath=export_path,
use_selection=True,
global_scale=1.0,
apply_unit_scale=True,
apply_scale_options='FBX_SCALE_UNITS',
bake_space_transform=False,
use_space_transform=True,
colors_type='SRGB',
object_types={'MESH', 'EMPTY', 'ARMATURE', 'OTHER'},
use_mesh_modifiers=True,
mesh_smooth_type='OFF',
use_mesh_edges=False,
use_tspace=False,
use_custom_props=False,
add_leaf_bones=False,
bake_anim=True,
bake_anim_use_all_actions=False,
bake_anim_use_nla_strips=False,
bake_anim_use_all_bones=True,
bake_anim_force_startend_keying=True,
bake_anim_step=1,
bake_anim_simplify_factor=1,
path_mode='COPY',
embed_textures=True
)
# Clear selection after export
bpy.ops.object.select_all(action='DESELECT')
else:
if not selected_objects:
# If no objects are selected, select all visible meshes in the scene
for obj in bpy.context.visible_objects:
if obj.type == 'MESH':
obj.select_set(True)
# Export FBX with custom settings using the specified export path
bpy.ops.export_scene.fbx(
filepath=export_path,
use_selection=True,
global_scale=1.0,
apply_unit_scale=True,
apply_scale_options='FBX_SCALE_UNITS',
bake_space_transform=False,
use_space_transform=True,
colors_type='SRGB',
object_types={'MESH', 'EMPTY', 'ARMATURE', 'OTHER'},
use_mesh_modifiers=True,
mesh_smooth_type='OFF',
use_mesh_edges=False,
use_tspace=False,
use_custom_props=False,
add_leaf_bones=False,
bake_anim=True,
bake_anim_use_all_actions=False,
bake_anim_use_nla_strips=False,
bake_anim_use_all_bones=True,
bake_anim_force_startend_keying=True,
bake_anim_step=1,
bake_anim_simplify_factor=1,
path_mode='COPY',
embed_textures=True
)
# Clear selection after export
bpy.ops.object.select_all(action='DESELECT')
except Exception as e:
print("Exporting failed:", str(e))
print("Continuing")
print("Operator: object.export_model() executed")
return {'FINISHED'}
# Operator to execute Analyze classical scene function
class SCENE_OT_classical_calculate_statistics(bpy.types.Operator):
"""It will analyze scene and print collected statistics bellow"""
bl_idname = "classical_scene.calculate_statistics"
bl_label = "BOP - Calculate Statistics"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
# Get the active scene
scene = bpy.context.scene
# Clear the existing unsuitability messages
context.scene.statistics.unsuitability_messages.clear()
# Initialize variables to count polygons, objects, and the farthest object
poly_count = 0
object_count = 0
material_count = len(bpy.data.materials)
closest_object_name = ""
closest_distance = float('inf')
total_scale = 0
shared_geometry_count = 0
has_bones_or_armatures = False
has_animation = False
# Initialize variables for additional checks
empty_parents_count = 0
camera_count = 0
light_count = 0
image_count = 0
curve_count = 0
texture_count = 0
materials_mapped = False # Initialize as False
# Initialize variables to store total dimensions
exceeded_x = None
exceeded_y = None
has_mesh_objects = False
lod_detected = False
lod_level = None
# Multi story building variables
building_hierarchy = False
multi_storey_building = False
floor_count = 0
floor_names = []
osm_detected = {
"OSM Detected": False,
".osm Collection Detected": False,
"way_profiles Collection Detected": False,
}
# dimension size by pressing N and click on Item panel to show Transform values
threshold = 5000
# Create a dictionary to track unique mesh data names and their counts
unique_mesh_data = {}
# Create a list of possible suffixes from ".001" to ".100"
possible_suffixes = [f".{str(i).zfill(3)}" for i in range(1, 101)]
# Initialize a set to store material names
material_names = set()
# Iterate through all objects in the scene
for obj in scene.objects:
if obj.type == 'MESH':
has_mesh_objects = True
# If the object is a mesh, add its polygon count to the total
poly_count += len(obj.data.polygons)
# Check if this mesh data is already encountered
mesh_data_name = obj.data.name
if mesh_data_name in unique_mesh_data:
# This is a shared geometry object
shared_geometry_count += 1
else:
# This is a unique geometry object, add it to the dictionary
unique_mesh_data[mesh_data_name] = True
# Increment the object count
object_count += 1
# Check if the object has materials assigned
if obj.material_slots:
materials_mapped = True # Set to True if any material is assigned to any object
# Calculate the distance from the world origin (0,0,0) in meters
distance_meters = obj.location.length # Blender Units, which are assumed to be in meters
# Check if this object is farther than the previously farthest
if distance_meters < closest_distance:
closest_distance = distance_meters
closest_object_name = obj.name
# Calculate the scale for this object
scale = obj.scale
total_scale += (scale.x + scale.y + scale.z) / 3 # Average the scale components
# Additional checks for empty parents, cameras, lights, loose geometry, and small Z-height
if obj.type == 'EMPTY': #and not obj.children:
empty_parents_count += 1
elif obj.type == 'CAMERA':
camera_count += 1
elif obj.type == 'LIGHT':
light_count += 1
elif obj.type == 'IMAGE':
image_count += 1
elif obj.type == 'CURVE':
curve_count += 1
# Check if the object is of type 'ARMATURE' or if it has bones
if obj.type == 'ARMATURE' or (obj.type == 'MESH' and obj.find_armature()):
has_bones_or_armatures = True
# Check for animation in the scene
if scene.animation_data:
has_animation = True
if obj.type == 'MESH':
# Get the dimensions of the object
x, y, _ = obj.dimensions # Discard the Z dimension
# Check if the X or Y dimension exceeds the threshold
if x > threshold:
exceeded_x = (obj.name, x)
if y > threshold:
exceeded_y = (obj.name, y)
# Check if there is a LOD object and which level (Checking by name)
for i in range(10):
lod_name = "LOD{}".format(i)
if lod_name in obj.name:
lod_detected = True
# Split the name to extract the LOD number
lod_number_str = obj.name.split("LOD")[1]
try:
# Try to convert the extracted portion to an integer
lod_number = int(lod_number_str)
# Compare the LOD level
if lod_level is None or lod_number > lod_level:
lod_level = lod_number
except ValueError:
# Ignore cases where the extracted portion is not a valid integer
continue
# Check for the ".osm_building" or ".osm_roads" condition among selected objects
if any(".osm_building" in obj.name or ".osm_roads" in obj.name for obj in bpy.context.scene.objects):
osm_detected["OSM Detected"] = True
# Iterate through all materials in the scene and count texture nodes with images (Better to keep outside first loop)
for material in bpy.data.materials:
if material.use_nodes and material.node_tree:
for node in material.node_tree.nodes:
if isinstance(node, bpy.types.ShaderNodeTexImage) and node.image is not None:
texture_count += 1
# Iterate through all collections in the scene to check for partial collection names
for collection in bpy.context.scene.collection.children:
if ".osm" in collection.name:
osm_detected[".osm Collection Detected"] = True
if "way_profiles" in collection.name:
osm_detected["way_profiles Collection Detected"] = True
# Determine if any of the conditions were met and store True or False in osm_detected
osm_detected = any(value for value in osm_detected.values())
# Calculate the average scale only if there are mesh objects
average_scale = total_scale / object_count if has_mesh_objects else 0
# Calculate the percentage of objects with shared geometry
percentage_shared = (shared_geometry_count / object_count) * 100 if has_mesh_objects else 0
# Function to recursively search for the empty parent hierarchy
def search_empty_hierarchy(obj):
nonlocal floor_count, floor_names, building_hierarchy, multi_storey_building
# Check if the object is an empty or a mesh
if obj.type == 'EMPTY' or obj.type == 'MESH':
# Check if the empty's name matches the hierarchy structure
if obj.name.startswith("Main") and len(obj.children) > 0:
# Check if there's at least one child object starting with "Floor"
floor_children = [child for child in obj.children if child.name.startswith("Floor")]
if floor_children:
# Increment floor count
floor_count += len(floor_children)
# Record floor names
floor_names.extend([child.name for child in floor_children])
# Check if there is more than one floor child
if len(floor_children) > 1:
multi_storey_building = True
# Check if at least one of the required children is present for any floor
required_children = ["Architecture", "Interior", "Outside"]
for floor_child in floor_children:
children_names = [child.name for child in floor_child.children]
if any(required_child in child_name for required_child in required_children for child_name in children_names):
# Hierarchy found, set global variable to True
building_hierarchy = True
return
# Recursively search through children
for child in obj.children:
search_empty_hierarchy(child)
# Start search from the root of the scene's objects
for obj in bpy.data.objects:
search_empty_hierarchy(obj)
if building_hierarchy:
break
# Set the calculated values to the properties
context.scene.statistics.poly_count = poly_count
context.scene.statistics.object_count = object_count
context.scene.statistics.material_count = material_count
context.scene.statistics.closest_object_name = closest_object_name
context.scene.statistics.closest_distance = closest_distance
context.scene.statistics.total_scale = total_scale
context.scene.statistics.shared_geometry_count = shared_geometry_count
context.scene.statistics.has_bones_or_armatures = has_bones_or_armatures
context.scene.statistics.has_animation = has_animation
context.scene.statistics.empty_parents_count = empty_parents_count
context.scene.statistics.camera_count = camera_count
context.scene.statistics.light_count = light_count
context.scene.statistics.image_count = image_count
context.scene.statistics.curve_count = curve_count
context.scene.statistics.texture_count = texture_count
context.scene.statistics.exceeded_x = exceeded_x
context.scene.statistics.exceeded_y = exceeded_y
context.scene.statistics.average_scale = average_scale
context.scene.statistics.percentage_shared = percentage_shared
context.scene.statistics.building_hierarchy = building_hierarchy
context.scene.statistics.multi_storey_building = multi_storey_building
context.scene.statistics.floor_count = floor_count
# Initialize a list to store unsuitability messages
unsuitability_messages = []
# Check suitability conditions and append appropriate messages. Only these condition described bellow can result into reject model
if poly_count > 1250000:
unsuitability_messages.append("Too many polygons ({} polygons, should be less or equal to 1250000 (1.25M)).".format(poly_count))
#if poly_count < 100:
# unsuitability_messages.append("There are ({} polygons), model is considered as a bloat.".format(poly_count))
if object_count > 6000:
unsuitability_messages.append("Too many objects ({} objects, should be less or equal to 6000).".format(object_count))
#if object_count < 1:
# unsuitability_messages.append("({} mesh objects detected), model is considered as a bloat.".format(object_count))
if closest_distance > 5000:
unsuitability_messages.append("Farthest object is too far from the origin ({} meters, should be less or equal to 5000 meters).".format(farthest_distance))
if average_scale < 0.01:
unsuitability_messages.append("Average scale is too small ({:.2f}, should be bigger or equal to 0.1).".format(average_scale))
if material_count > 200:
unsuitability_messages.append("Too many materials ({} materials), should be less or equal 200.".format(len(bpy.data.materials)))
if not materials_mapped:
unsuitability_messages.append("Materials are not mapped to any objects in the scene.")
if exceeded_x or exceeded_y:
unsuitability_messages.append("One of your models exceeded total limit size (5KM). Please check your conversion units or make sure that your model is exported in meters")
if percentage_shared < 40:
unsuitability_messages.append("There are less than 40% objects with shared geometry")
if (camera_count > 0 or light_count > 0 or curve_count > 0):
unsuitability_messages.append("Please delete unnecessary objects like camera, light or curve")
if empty_parents_count > 100:
unsuitability_messages.append("Please minimize amount of empty objects in scene")
if has_bones_or_armatures == True:
unsuitability_messages.append("Please delete any armatures or bones from scene")
if has_animation == True:
unsuitability_messages.append("Animations are not currently supported")
if building_hierarchy == False:
unsuitability_messages.append("Your model is missing required Hierarchy. Please use Reparent function or check Documentation")
for message in unsuitability_messages:
new_item = context.scene.statistics.unsuitability_messages.add()
new_item.message = message
print("Operator: scene.calculate_statistics() executed")
return {'FINISHED'}
# Operator to execute Analyze scanned scene function
class SCENE_OT_scanned_calculate_statistics(bpy.types.Operator):
"""It will analyze scene and print collected statistics bellow"""
bl_idname = "scanned_scene.calculate_statistics"
bl_label = "BOP - Calculate Statistics"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
# Get the active scene
scene = bpy.context.scene
# Clear the existing unsuitability messages
context.scene.statistics.unsuitability_messages.clear()
# Initialize variables to count polygons, objects, materials, textures, and the farthest object
poly_count = 0
object_count = 0
material_count = len(bpy.data.materials)
texture_count = 0
closest_object_name = ""
closest_distance = float('inf')
total_scale = 0
# Initialize variables for additional checks
empty_parents_count = 0
camera_count = 0
light_count = 0
image_count = 0
small_z_height_count = 0
materials_with_missing_textures = []
materials_mapped = False # Initialize as False
# Initialize variables to store treshold exceeded dimensions
exceeded_x = None
exceeded_y = None
has_mesh_objects = False
lod_detected = False
lod_level = None
# Multi story building variables
building_hierarchy = False
multi_storey_building = False
floor_count = 0
floor_names = []
osm_detected = {
"OSM Detected": False,
".osm Collection Detected": False,
"way_profiles Collection Detected": False,
}
# Specify the dimension threshold in Blender units (assuming Blender's default unit is meters), You can verify
# dimension size by pressing N and click on Item panel to show Transform values
threshold = 5000
# Create a dictionary to track unique mesh data names and their counts
unique_mesh_data = {}
# Initialize a set to store material names
material_names = set()
# Iterate through all objects in the scene
for obj in scene.objects:
if obj.type == 'MESH':
has_mesh_objects = True
# If the object is a mesh, add its polygon count to the total
poly_count += len(obj.data.polygons)
# Increment the object count
object_count += 1
# Check if the object has materials assigned
if obj.material_slots:
materials_mapped = True # Set to True if any material is assigned to any object
# Check if this object is farther than the previously farthest
if obj.type == 'MESH':
# Calculate the global position of the object
global_pos = obj.matrix_world.translation
# Calculate the distance from the world origin (0,0,0) in meters
distance_meters = global_pos.length # Blender Units, which are assumed to be in meters
# Check if this object is closer than the previously closest
if distance_meters < closest_distance:
closest_distance = distance_meters
closest_object_name = obj.name
# Calculate the scale for this object
scale = obj.scale
total_scale += (scale.x + scale.y + scale.z) / 3 # Average the scale components
# Additional checks for empty parents, cameras, lights, loose geometry, and small Z-height
if obj.type == 'EMPTY' and not obj.children:
empty_parents_count += 1
elif obj.type == 'CAMERA':
camera_count += 1
elif obj.type == 'LIGHT':
light_count += 1
elif obj.type == 'IMAGE':
image_count += 1
elif obj.type == 'MESH':
z_dimension = obj.dimensions.z
if z_dimension < 0.001:
small_z_height_count += 1
if obj.type == 'MESH':
# Get the dimensions of the object
x, y, _ = obj.dimensions # Discard the Z dimension
# Check if the X or Y dimension exceeds the threshold
if x > threshold:
exceeded_x = (obj.name, x)
if y > threshold:
exceeded_y = (obj.name, y)
# Check if there is a LOD object and which level (Checking by name)
for i in range(10):
lod_name = "LOD{}".format(i)
if lod_name in obj.name:
lod_detected = True
# Split the name to extract the LOD number
lod_number_str = obj.name.split("LOD")[1]
try:
# Try to convert the extracted portion to an integer
lod_number = int(lod_number_str)
# Compare the LOD level
if lod_level is None or lod_number > lod_level:
lod_level = lod_number
except ValueError:
# Ignore cases where the extracted portion is not a valid integer
continue
# Check for the ".osm_building" or ".osm_roads" condition among selected objects
if any(".osm_building" in obj.name or ".osm_roads" in obj.name for obj in bpy.context.scene.objects):
osm_detected["OSM Detected"] = True
# Iterate through all materials in the scene and count texture nodes with images (Better to keep outside first loop)
for material in bpy.data.materials:
if material.use_nodes and material.node_tree:
for node in material.node_tree.nodes:
if isinstance(node, bpy.types.ShaderNodeTexImage) and node.image is not None:
texture_count += 1
if hasattr(node, 'image') and (not node.image or not os.path.exists(node.image.filepath)):
materials_with_missing_textures.append(material.name)
break
# Iterate through all collections in the scene to check for partial collection names
for collection in bpy.context.scene.collection.children:
if ".osm" in collection.name:
osm_detected[".osm Collection Detected"] = True
if "way_profiles" in collection.name:
osm_detected["way_profiles Collection Detected"] = True
# Determine if any of the conditions were met and store True or False in osm_detected
osm_detected = any(value for value in osm_detected.values())
# Calculate the average scale for all objects in the scene
average_scale = total_scale / object_count if has_mesh_objects else 0
def search_empty_hierarchy(obj):
nonlocal floor_count, floor_names, building_hierarchy, multi_storey_building
# Check if the object is an empty or a mesh
if obj.type == 'EMPTY' or obj.type == 'MESH':
# Check if the empty's name matches the hierarchy structure
if obj.name.startswith("Main") and len(obj.children) > 0:
# Check if there's at least one child object starting with "Floor"
floor_children = [child for child in obj.children if child.name.startswith("Floor")]
if floor_children:
# Increment floor count
floor_count += len(floor_children)
# Record floor names
floor_names.extend([child.name for child in floor_children])
# Check if there is more than one floor child
if len(floor_children) > 1:
multi_storey_building = True
# Check if at least one of the required children is present for any floor
required_children = ["Architecture", "Interior", "Outside"]
for floor_child in floor_children:
children_names = [child.name for child in floor_child.children]
if any(required_child in child_name for required_child in required_children for child_name in children_names):
# Hierarchy found, set global variable to True
building_hierarchy = True
return
# Recursively search through children
for child in obj.children:
search_empty_hierarchy(child)
# Start search from the root of the scene's objects
for obj in bpy.data.objects:
search_empty_hierarchy(obj)
if building_hierarchy:
break
# Set the calculated values to the properties
context.scene.statistics.poly_count = poly_count
context.scene.statistics.object_count = object_count
context.scene.statistics.material_count = material_count
context.scene.statistics.closest_object_name = closest_object_name
context.scene.statistics.closest_distance = closest_distance
context.scene.statistics.total_scale = total_scale
context.scene.statistics.empty_parents_count = empty_parents_count
context.scene.statistics.camera_count = camera_count
context.scene.statistics.light_count = light_count
context.scene.statistics.image_count = image_count
context.scene.statistics.texture_count = texture_count
context.scene.statistics.exceeded_x = exceeded_x
context.scene.statistics.exceeded_y = exceeded_y
context.scene.statistics.average_scale = average_scale
context.scene.statistics.building_hierarchy = building_hierarchy
context.scene.statistics.multi_storey_building = multi_storey_building
context.scene.statistics.floor_count = floor_count
# Initialize a list to store unsuitability messages
unsuitability_messages = []
# Check suitability conditions and append appropriate messages
if poly_count > 2500000:
unsuitability_messages.append("(Too many polygons ({} polygons), should be les or equal 2500000.".format(poly_count))
#if poly_count < 100:
# unsuitability_messages.append("There are ({} polygons), model is considered as a bloat.".format(poly_count))
if object_count > 100:
unsuitability_messages.append("Too many objects ({} objects), should be less or equal 100.".format(object_count))
#if object_count < 1:
# unsuitability_messages.append("({} mesh objects detected), model is considered as a bloat.".format(object_count))
if material_count > 100:
unsuitability_messages.append("Too many materials ({} materials), should be less or equal 100.".format(material_count))
if not materials_mapped:
unsuitability_messages.append("Materials are not mapped to any objects in the scene.")
if texture_count > 100:
unsuitability_messages.append("Too many textures ({} textures), should be less or equal 100.".format(texture_count))
#if texture_count == 0:
# unsuitability_messages.append("There are ({} textures), should be more than that.".format(texture_count))
if closest_distance > 5000:
unsuitability_messages.append("Closest object is too far from the origin ({} meters, should be less or equal to 5000 meters).".format(closest_distance))
if average_scale < 0.01:
unsuitability_messages.append("Average scale is too small ({:.2f}), should be bigger or equal 0.1.".format(average_scale))
if exceeded_x or exceeded_y:
unsuitability_messages.append("One of your models exceeded total limit size (5KM). Please check your conversion units or make sure that your model is exported in meters")
if building_hierarchy == False:
unsuitability_messages.append("Your model is missing required Hierarchy. Please use Reparent function or check Documentation")
for message in unsuitability_messages:
new_item = context.scene.statistics.unsuitability_messages.add()
new_item.message = message
print("Operator: scanned_scene.calculate_statistics() executed")
return {'FINISHED'}
# Operator to execute display heatmap by polygon function
class OBJECT_OT_polygon_heatmap(bpy.types.Operator):
"""It will assign colors to objects based on number of polygons"""
bl_idname = "object.polygon_heatmap"
bl_label = "HM - Visualize by polygons"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
display_heatmap_by_polygons()
print("Operator: object.polygon_heatmap() executed")
return {'FINISHED'}
# Operator to execute clear heatmap data function
class OBJECT_OT_clear_heatmap_data(bpy.types.Operator):
"""It will clear heatmap data"""
bl_idname = "object.polygon_heatmap_clear"
bl_label = "HM - Clear heatmap data"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
clear_heatmap_data()
restore_face_colors()
print("Operator: object.polygon_heatmap_clear() executed")
return {'FINISHED'}
# Operator to execute display heatmap by face orientation function
class OBJECT_OT_face_orientation_heatmap(bpy.types.Operator):
"""It will assign colors to objects based on face orientation (Backface culling)"""
bl_idname = "object.face_orientation_heatmap"
bl_label = "HM - Visualize by face orientation"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
set_face_colors((0.0, 1.0, 0.0, 0.737), (1.0, 0.0, 0.0, 0.737))
print("Operator: object.face_orientation_heatmap() executed")
return {'FINISHED'}
# Operator to execute display heatmap by instances function
class OBJECT_OT_display_heatmap_by_instances(bpy.types.Operator):
"""It will assing colors to multi user objects (Instanced meshes)
and non multi user objects (Not Instanced meshes)"""
bl_idname = "object.heatmap_by_instances"
bl_label = "HM - Visualize by instances"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
display_heatmap_by_instances()
print("Operator: object.heatmap_by_instances() executed")
return {'FINISHED'}
# Operator to execute display heatmap by mesh density function
class OBJECT_OT_display_heatmap_by_meshdensity(bpy.types.Operator):
"""It will assign colors to objects based on their mesh density
In more complex scenes, this function can take a some time"""
bl_idname = "object.heatmap_by_meshdensity"
bl_label = "HM - Visualize by meshdensity"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
display_heatmap_by_density()
print("Operator: object.heatmap_by_meshdensity() executed")
return {'FINISHED'}
# Operator to execute decimator v4 function
class OBJECT_OT_decimator_v5(bpy.types.Operator):
"""It will reduce vertex count and try to keep shape as much as possible (Applies on all visible objects!)"""
bl_idname = "object.decimator_v5"
bl_label = "BOP - Reduce_vertex_count"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
decimator_v5()
print("Operator: decimator_v5() executed")
return {'FINISHED'}
# Operator to execute pack external data into blend file function
class OBJECT_OT_pack_external_data_into_blend_file(bpy.types.Operator):
"""It will enable Automatic packing of external data such as textures and others into .blend file. Default state is False.
Since its toggle, if you press it twice, it will disable function. Additionally you can check it in File - External data - Automatically Pack Resources"""
bl_idname = "object.pack_external_data"
bl_label = "BOP - Pack external data into blend file"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
pack_external_data_into_blend_file()
print("Operator: pack_external_data_into_blend_file() executed")
return {'FINISHED'}
# Operator to execute CreatePlanes function
class OBJECT_OT_CreatePlanes(bpy.types.Operator):
"""It will create Floor planes which should be placed at each floor starting height. Floor planes also indicates
for script where to cut model into individual floors. Floor planes are specifically named based your input and they
are located inside Floor planes collection folder"""
bl_idname = "object.create_planes_operator"
bl_label = "Create Planes"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
scene = context.scene
# Check if "Floor planes" collection exists, if not, create it
if "Floor planes" not in bpy.data.collections:
floor_planes_collection = bpy.data.collections.new("Floor planes")
bpy.context.scene.collection.children.link(floor_planes_collection)
else:
floor_planes_collection = bpy.data.collections["Floor planes"]
# Create a material for the planes
mat = bpy.data.materials.new(name="FloorMaterial")
mat.use_nodes = False
mat.diffuse_color = (1, 1, 1, 0.2) # Set the color to white
mat.use_fake_user = True # Ensure material is not deleted
new_planes = []
# Create the specified number of planes and place them along the Z-axis
for i in range(scene.number_of_floors):
bpy.ops.mesh.primitive_plane_add(size=40, enter_editmode=False, align='WORLD', location=(0, 0, i * 2))
plane = bpy.context.active_object
plane.name = f"Floor Temp {i}"
# Assign the material to the plane
plane.data.materials.append(mat)
# Link the new plane to the "Floor planes" collection
floor_planes_collection.objects.link(plane)
# Unlink the plane from the main collection to keep it only in "Floor planes"
bpy.context.scene.collection.objects.unlink(plane)
new_planes.append(plane)
# Rename the planes with the correct prefix after all planes are created
total_planes = len(floor_planes_collection.objects)
prefix_length = 3 # We want a 3-digit prefix
for index, plane in enumerate(new_planes):
new_prefix = str(total_planes - 1 - index).zfill(prefix_length)
plane.name = f"{new_prefix} / Floor {index}"
def add_default_suffix_to_floor():
# Get the collection name and default floor number from the scene properties
collection_name = "Floor planes"
default_floor = bpy.context.scene.default_floor - 1 # Adjust for zero-based indexing
# Get the collection containing the floor planes
collection = bpy.data.collections.get(collection_name)
if not collection:
print(f"Collection '{collection_name}' not found.")
return
# Filter out mesh objects from the collection
mesh_objects = [obj for obj in collection.objects if obj.type == 'MESH']
# Sort mesh objects based on their Z-coordinate (from bottom to top)
mesh_objects.sort(key=lambda obj: obj.location.z)
# Check if the default_floor is valid
if default_floor >= len(mesh_objects):
print("Invalid default floor number.")
return
# Get the object at the default floor index
default_object = mesh_objects[default_floor]
# Add "Default" as a suffix to the object name
default_object.name += " Default"
# print(f"Added 'Default' as a suffix to the object name: {default_object.name}")
add_default_suffix_to_floor()
return {'FINISHED'}
# Operator to execute FloorCutter function
class OBJECT_OT_FloorCutter(bpy.types.Operator):
"""It will start Floorcutting process.
If you are not satisfied with results press CTRL+Z to revert changes"""
bl_idname = "object.floor_cutter"
bl_label = "BOP - Floor cutter"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
floor_cutter(delete_interval=5)
print("Operator: floor_cutter() executed")
return {'FINISHED'}
# Operator to execute FloorCutter function
class OBJECT_OT_BakeAnimationData(bpy.types.Operator):
"""It will Bake Animation data into objects itself. This
will allow easier manipulation with objects"""
bl_idname = "object.bake_animation_data"
bl_label = "BOP - Bake Animation data"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
bake_animations()
print("Operator: bake_animations() executed")
return {'FINISHED'}
# Operator to execute Delente non visible geometry function
class OBJECT_OT_Delete_non_visible_geometry(bpy.types.Operator):
"""It will Delete non visible geometry via camera
array and ray casting"""
bl_idname = "object.delete_non_visible_geometry"
bl_label = "BOP - Delete non visible geometry"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
delete_non_visible_geometry()
print("Operator: delete_non_visible_geometry() executed")
return {'FINISHED'}
#----------------------------PROPERTY GROUPS----------------------------#
# Property group for Analyze scene
class UnsuitabilityMessageItem(bpy.types.PropertyGroup):
message: bpy.props.StringProperty(name="Message")
# Property group for Analyze scene
# Convert variables into properties
class SceneStatisticsProperties(bpy.types.PropertyGroup):
poly_count: bpy.props.IntProperty(name="Polygon Count", default=0)
object_count: bpy.props.IntProperty(name="Object Count", default=0)
material_count: bpy.props.IntProperty(name="Material Count", default=0)
closest_object_name: bpy.props.StringProperty(name="Closest Object Name", default="")
closest_distance: bpy.props.FloatProperty(name="Closest Distance", default=0.0)
total_scale: bpy.props.FloatProperty(name="Total Scale", default=0.0)
shared_geometry_count: bpy.props.IntProperty(name="Shared Geometry Count", default=0)
has_bones_or_armatures: bpy.props.BoolProperty(name="Has Bones or Armatures", default=False)
has_animation: bpy.props.BoolProperty(name="Has Animation", default=False)
empty_parents_count: bpy.props.IntProperty(name="Empty Parents Count", default=0)
camera_count: bpy.props.IntProperty(name="Camera Count", default=0)
light_count: bpy.props.IntProperty(name="Light Count", default=0)
image_count: bpy.props.IntProperty(name="Image Count", default=0)
curve_count: bpy.props.IntProperty(name="Curve Count", default=0)
texture_count: bpy.props.IntProperty(name="Texture Count", default=0)
exceeded_x: bpy.props.PointerProperty(type=bpy.types.Object)
exceeded_y: bpy.props.PointerProperty(type=bpy.types.Object)
average_scale: bpy.props.FloatProperty(name="Average Scale", default=0.0)
percentage_shared: bpy.props.FloatProperty(name="Percentage Shared", default=0.0)
building_hierarchy: bpy.props.BoolProperty(name="Model has Hierarchy", default = False)
multi_storey_building: bpy.props.BoolProperty(name="Multi storey building", default = False)
floor_count: bpy.props.IntProperty(name="Floor count", default=0)
# Change the unsuitability_messages property to a collection
unsuitability_messages: bpy.props.CollectionProperty(type=UnsuitabilityMessageItem)
#----------------------------MULTICLASS OPERATORS----------------------------#
# Multiclass operators will take existing operators described above and execute them in defined order under def execute section
class ClassicModelOperator(bpy.types.Operator):
"""It will execute functions best for Classic models"""
bl_idname = "object.custom_multi_class_operator1"
bl_label = "BOP - Custom Multi-Class Operator"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
print("Your Classic Model is FIXED!")
# Execute operators in this order (Classic 3D model)
bpy.ops.object.bake_animation_data()
# bpy.ops.object.delete_animations()
# bpy.ops.object.delete_armatures_and_bones()
bpy.ops.object.reset_origin()
bpy.ops.object.reset_scale_to_1()
bpy.ops.object.recalculate_normals()
bpy.ops.object.auto_smooth_all()
bpy.ops.object.delete_custom_normals()
bpy.ops.object.tris_to_quads()
bpy.ops.object.merge_close_vertices()
bpy.ops.object.remove_unused_datablocks()
bpy.ops.object.delete_bloat()
bpy.ops.object.merge_similar_materials()
bpy.ops.object.delete_downward_faces()
bpy.ops.object.create_instances()
bpy.ops.object.decimator_v5()
bpy.ops.object.lod_rename()
bpy.ops.object.reparent()
return {'FINISHED'}
class ScannedModelOperator(bpy.types.Operator):
"""It will execute functions best for Scanned models"""
bl_idname = "object.custom_multi_class_operator2"
bl_label = "BOP - Custom Multi-Class Operator"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
print("Your Scanned Model is FIXED!")
# Execute operators in this order (Scanned Model)
bpy.ops.object.delete_animations()
bpy.ops.object.delete_armatures_and_bones()
bpy.ops.object.reset_origin()
bpy.ops.object.reset_scale_to_1()
bpy.ops.object.delete_custom_normals()
bpy.ops.object.merge_close_vertices()
bpy.ops.object.remove_unused_datablocks()
bpy.ops.object.delete_bloat()
bpy.ops.object.rotate_model_operator()
bpy.ops.object.merge_similar_materials()
bpy.ops.object.decimator_v5()
bpy.ops.object.lod_rename()
bpy.ops.object.reparent()
return {'FINISHED'}
#----------------------------PANEL with buttons in View_3D----------------------------#
# Panel to show the Custom OperatorPanel with Classic and Scanned model functions
class OperatorHolderPanel(bpy.types.Panel):
bl_idname = "OBJECT_PT_custom_operator_panel"
bl_label = "Twinzo"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
def draw(self, context):
layout = self.layout
layout.label(text="Click on one of the buttons")
layout.label(text="to optimize your 3D model.")
layout.label(text="For undo press CTRL+Z")
# Add a separator (vertical spacing)
layout.separator()
# Add the custom operator button
layout.operator("object.custom_multi_class_operator1", text="FIX my Classic Model")
# Add the custom operator button2
layout.operator("object.custom_multi_class_operator2", text="FIX my Scanned Model")
# Add a separator (vertical spacing)
layout.separator()
# Add the object reset button
layout.operator("object.reset", text="RESET")
# Panel to show Object Separator Functions
class ObjectSeparator(bpy.types.Panel):
"""Panel with ObjectSeparator function"""
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Object Separator"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.label(text="In order to separate objects")
layout.label(text="you can either select")
layout.label(text="desired object or let script")
layout.label(text="to apply it on all objects.")
layout.label(text="For undo press CTRL+Z")
# Add a separator (vertical spacing)
layout.operator("object.object_separator", text="Separate Objects")
# Panel to show Object Instancer Functions
class ObjectInstancer(bpy.types.Panel):
"""Panel with ObjectInstancer function"""
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Object Instancer"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.label(text="Identic or very similar objects")
layout.label(text="will share their geometry, which")
layout.label(text="results in better performance")
layout.label(text="Applies on all objects in scene!")
# Add a separator (vertical spacing)
layout.operator("object.create_instances", text="Create Instanced Objects")
# Panel to show Individual Functions
class IndividualFunctions(bpy.types.Panel):
"""Individual functions, which you can manually execute as you like"""
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Individual Functions"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
# SubPanel to show Delete/Cleanup section
class DeleteCleanupSubPanel(bpy.types.Panel):
bl_parent_id = "IndividualFunctions"
bl_label = "DELETE / CLEAN UP"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='EVENT_X')
def draw(self, context):
layout = self.layout
row = layout.row()
layout.label(text="Delete unnecessary geometry")
# Add the delete downward faces button
layout.operator("object.delete_downward_faces", text="Delete Downward Faces", icon='EVENT_X')
# Add the delete duplicated meshes button
layout.operator("object.delete_duplicated_meshes", text="Delete Duplicated Meshes", icon='EVENT_X')
# Add the delete bloat button
layout.operator("object.delete_bloat", text="Delete Bloat", icon='EVENT_X')
# Add the delete armatures and bones button
layout.operator("object.delete_armatures_and_bones", text="Delete Armature and Bones", icon='EVENT_X')
# Add the delete animations button
layout.operator("object.delete_animations", text="Delete Animations", icon='EVENT_X')
# Add the delete non visible geometry button
layout.operator("object.delete_non_visible_geometry", text="Delete Non Visible Geometry", icon='EVENT_X')
layout.label(text="Cleanup tools")
# Add the remove unused datablocks button
layout.operator("object.remove_unused_datablocks", text="Remove Unused Datablocks", icon='EVENT_X')
# SubPanel to show MeshModify section
class MeshModifySubPanel(bpy.types.Panel):
bl_parent_id = "IndividualFunctions"
bl_label = "MESH MODIFY"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='MODIFIER_DATA')
def draw(self, context):
layout = self.layout
row = layout.row()
# Add the merge close vertices button
layout.operator("object.merge_close_vertices", text="Merge Close Vertices", icon='MODIFIER_DATA')
# Add the tris to quads button
layout.operator("object.tris_to_quads", text="Tris to Quads", icon='MODIFIER_DATA')
# Add the limited dissolve button
layout.operator("object.limited_dissolve", text="Use Limited Dissolve", icon='MODIFIER_DATA')
# Add the fix scan rotation button
layout.operator("object.rotate_model_operator", text="Fix Scan Rotation", icon='MODIFIER_DATA')
# Add the reset origin button
layout.operator("object.reset_origin", text="Reset Origin", icon='MODIFIER_DATA')
# Add the reset scale button
layout.operator("object.reset_scale_to_1", text="Reset Scale to 1", icon='MODIFIER_DATA')
# SubPanel to show Shading section
class ShadingSubPanel(bpy.types.Panel):
bl_parent_id = "IndividualFunctions"
bl_label = "SHADING"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='DISC')
def draw(self, context):
layout = self.layout
row = layout.row()
# Add the auto-smooth button
layout.operator("object.auto_smooth_all", text="Auto Smooth", icon='DISC')
# Add the recalculate normals button
layout.operator("object.recalculate_normals", text="Recalculate Mesh Normals", icon='DISC')
# Add the delete custom normals button
layout.operator("object.delete_custom_normals", text="Delete Custom Split Normals", icon='DISC')
# SubPanel to show Hierarchy section
class HierarchySubPanel(bpy.types.Panel):
bl_parent_id = "IndividualFunctions"
bl_label = "HIERARCHY"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='OUTLINER')
def draw(self, context):
layout = self.layout
row = layout.row()
# Add the reparent all button
layout.operator("object.reparent", text="Reparent", icon='OUTLINER')
# SubPanel to show Material section
class MaterialSubPanel(bpy.types.Panel):
bl_parent_id = "IndividualFunctions"
bl_label = "MATERIALS"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='SHADING_TEXTURE')
def draw(self, context):
layout = self.layout
row = layout.row()
# Add the remove duplicated materials button
row.operator("object.merge_similar_materials", text="Merge Similar Materials", icon='SHADING_TEXTURE')
# SubPanel to show Others section
class AnimationsSubPanel(bpy.types.Panel):
bl_parent_id = "IndividualFunctions"
bl_label = "ANIMATIONS"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='ARMATURE_DATA')
def draw(self, context):
layout = self.layout
# Add bake animation data button
layout.operator("object.bake_animation_data", text="Bake Animation data", icon='ARMATURE_DATA')
# SubPanel to show Others section
class OthersSubPanel(bpy.types.Panel):
bl_parent_id = "IndividualFunctions"
bl_label = "OTHERS"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='COLLAPSEMENU')
def draw(self, context):
layout = self.layout
# Add the adjust LODs button
layout.operator("object.lod_rename", text="Adjust LOD names", icon='COLLAPSEMENU')
# Add the pack external data button
layout.operator("object.pack_external_data", text="Toggle Pack External data", icon='COLLAPSEMENU')
# Panel to show the DocumantationPanel
class DocumentationPanel(bpy.types.Panel):
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Documentation"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
# Add button for Operator to execute the open URL function
layout.operator("object.open_url_operator", text="Need help ?")
# Panel to show the UpdatePanel
class UpdatePanel(bpy.types.Panel):
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Updater"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
# Add the object Check update button
layout.operator("wm.check_for_update", text="Check update")
# Panel to show Object Instancer Functions
class Decimator_v5Panel(bpy.types.Panel):
"""Panel with Decimator v5 function"""
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Decimator v5"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.label(text="Decimator v5 will try to reduce")
layout.label(text="vertex count as much as possible")
layout.label(text="Reducing vertex count is heavy process")
layout.label(text="and can take a while to compute")
layout.label(text="---------------------------------")
layout.label(text="If you are not satisfied with results")
layout.label(text="Press CTRL+Z to revert changes")
layout.label(text="Applies on all visible objects!")
# Add a blank separator
layout.separator()
# Add button for Operator to execute the Decimator_v5 function
layout.operator("object.decimator_v5", text="Process")
# Panel to show the Analyze scene function
class VIEW3D_PT_scene_statistics(bpy.types.Panel):
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Analyze scene"
bl_idname = "PT_Scene_Statistics"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.label(text="Choose category based on your")
layout.label(text="model type.")
# Panel to hold classical scene statistics functions
class VIEW3D_PT_classical_scene_statistics_holder(bpy.types.Panel):
bl_parent_id = "PT_Scene_Statistics"
bl_label = "CLASSICAL MESH"
bl_idname = "PT_Classical_scene_statistics_holder"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='MESH_CUBE')
def draw(self, context):
layout = self.layout
# Panel to show Heatmap functions
class VIEW3D_PT_classical_scene_heatmap_holder(bpy.types.Panel):
bl_parent_id = "PT_Classical_scene_statistics_holder"
bl_label = " Heatmap"
bl_idname = "PT_Classical_scene_heatmap_holder"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='MESH_CUBE')
def draw(self, context):
blender_version = bpy.app.version
layout = self.layout
layout.label(text="Graphical representation of data visualized")
layout.label(text="in different colors")
layout.label(text="Description:")
row = layout.row()
if blender_version >= (4, 4, 0):
row.label(icon="STRIP_COLOR_04", text="Good")
row.label(icon="STRIP_COLOR_02", text="Okay")
row.label(icon="STRIP_COLOR_01", text="Not great")
layout.label(icon="STRIP_COLOR_09", text="Cannot be visualized")
else:
row.label(icon="SEQUENCE_COLOR_04", text="Good")
row.label(icon="SEQUENCE_COLOR_02", text="Okay")
row.label(icon="SEQUENCE_COLOR_01", text="Not great")
layout.label(icon="SEQUENCE_COLOR_09", text="Cannot be visualized")
# Add a separator (vertical spacing)
layout.separator()
# Add the custom operator button
layout.operator("object.polygon_heatmap", text="Heatmap by polygons", icon='MESH_CUBE')
layout.operator("object.face_orientation_heatmap", text="Heatmap by face orientation", icon='MESH_CUBE')
layout.operator("object.heatmap_by_instances", text="Heatmap by instances", icon='MESH_CUBE')
layout.operator("object.heatmap_by_meshdensity", text="Heatmap by meshdensity", icon='MESH_CUBE')
# Add a separator (vertical spacing)
layout.separator()
layout.operator("object.polygon_heatmap_clear", text="Clear Heatmap data", icon='MESH_CUBE')
# Panel to show the Analyze classical scene function
class VIEW3D_PT_classical_scene_statistics(bpy.types.Panel):
bl_parent_id = "PT_Classical_scene_statistics_holder"
bl_label = " Statistics chart"
bl_idname = "PT_Classical_scene_Statistics"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='MESH_CUBE')
def draw(self, context):
layout = self.layout
# Add a button
layout.operator("classical_scene.calculate_statistics", text="Calculate Statistics", icon='MESH_CUBE')
layout.label(text="Statistics:")
# Add a box layout with text to display the result
box = layout.box()
box.label(text=f"Polygons: {context.scene.statistics.poly_count}")
box.label(text=f"Total Mesh Objects: {context.scene.statistics.object_count}")
box.label(text=f"Materials: {context.scene.statistics.material_count}")
box.label(text=f"Closest Object: {context.scene.statistics.closest_object_name}")
box.label(text=f"Closest Distance: {context.scene.statistics.closest_distance}")
# box.label(text=f"Total Scale: {context.scene.statistics.total_scale}")
box.label(text=f"Bones or Armatures: {context.scene.statistics.has_bones_or_armatures}")
box.label(text=f"Animations: {context.scene.statistics.has_animation}")
box.label(text=f"Empty Parents: {context.scene.statistics.empty_parents_count}")
box.label(text=f"Cameras: {context.scene.statistics.camera_count}")
box.label(text=f"Lights: {context.scene.statistics.light_count}")
# box.label(text=f"Image Count: {context.scene.statistics.image_count}")
box.label(text=f"Curves: {context.scene.statistics.curve_count}")
box.label(text=f"Textures: {context.scene.statistics.texture_count}")
box.label(text=f"Exceeded X: {context.scene.statistics.exceeded_x}")
box.label(text=f"Exceeded Y: {context.scene.statistics.exceeded_y}")
box.label(text=f"Average Scale: {context.scene.statistics.average_scale:.2f}")
box.label(text=f"Shared Geometry: {context.scene.statistics.percentage_shared:.2f}%")
box.label(text=f"Building Hierarchy: {context.scene.statistics.building_hierarchy}")
box.label(text=f"Multi storey building: {context.scene.statistics.multi_storey_building}")
box.label(text=f"Floor count: {context.scene.statistics.floor_count}")
# Add a separator
layout.separator()
layout.label(text="Results")
# Add a box layout for unsuitability messages
unsuitability_box = layout.box()
unsuitability_box.label(text="Potentional Issues:")
for message_item in context.scene.statistics.unsuitability_messages:
unsuitability_box.label(text=message_item.message)
# Panel to show the Analyze scanned scene function
class VIEW3D_PT_ScanLidar_based_scene_statistics(bpy.types.Panel):
bl_parent_id = "PT_Scene_Statistics"
bl_label = "SCAN / LIDAR MESH"
bl_idname = "PT_ScanLidar_scene_Statistics"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw_header(self, context):
layout = self.layout
layout.label(icon='CAMERA_DATA')
def draw(self, context):
layout = self.layout
# Add a button
layout.operator("scanned_scene.calculate_statistics", text="Calculate Statistics", icon='CAMERA_DATA')
layout.label(text="Statistics:")
# Add a box layout with text to display the result
box = layout.box()
box.label(text=f"Polygons: {context.scene.statistics.poly_count}")
box.label(text=f"Total Mesh Objects: {context.scene.statistics.object_count}")
box.label(text=f"Materials: {context.scene.statistics.material_count}")
box.label(text=f"Closest Object: {context.scene.statistics.closest_object_name}")
box.label(text=f"Closest Distance: {context.scene.statistics.closest_distance}")
# box.label(text=f"Total Scale: {context.scene.statistics.total_scale}")
box.label(text=f"Empty Parents: {context.scene.statistics.empty_parents_count}")
box.label(text=f"Cameras: {context.scene.statistics.camera_count}")
box.label(text=f"Lights: {context.scene.statistics.light_count}")
# box.label(text=f"Image Count: {context.scene.statistics.image_count}")
box.label(text=f"Curves: {context.scene.statistics.curve_count}")
box.label(text=f"Textures: {context.scene.statistics.texture_count}")
box.label(text=f"Exceeded X: {context.scene.statistics.exceeded_x}")
box.label(text=f"Exceeded Y: {context.scene.statistics.exceeded_y}")
box.label(text=f"Average Scale: {context.scene.statistics.average_scale:.2f}")
box.label(text=f"Building Hierarchy: {context.scene.statistics.building_hierarchy}")
box.label(text=f"Multi storey building: {context.scene.statistics.multi_storey_building}")
box.label(text=f"Floor count: {context.scene.statistics.floor_count}")
# Add a separator
layout.separator()
layout.label(text="Results")
# Add a box layout for unsuitability messages
unsuitability_box = layout.box()
unsuitability_box.label(text="Potentional Issues:")
for message_item in context.scene.statistics.unsuitability_messages:
unsuitability_box.label(text=message_item.message)
# Panel to show Object Instancer Functions
class ExporterPanel(bpy.types.Panel):
"""Panel with Export function"""
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Exporter"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.label(text="Please make sure you have selected")
layout.label(text="all the objects you want to export ")
# Display the export path property
layout.prop(context.scene, "export_path")
# Add a separator (vertical spacing)
layout.operator("object.export_model", text="Export")
# Panel to show Floor cutter function
class FloorcutterPanel(bpy.types.Panel):
"""Floor cutter"""
bl_parent_id = "OBJECT_PT_custom_operator_panel"
bl_label = "Floor cutter"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Twinzo'
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
scene = context.scene
layout.label(text="Floor cutter will cut and redistribute objects into")
layout.label(text="individual floors, based on values you set in")
layout.label(text="If you are not satisfied with results")
layout.label(text="Press CTRL+Z to revert changes")
layout.label(text="---------------------------------")
layout.label(text="Step 1: Set number of Floors")
layout.label(text="and choose which floor you")
layout.label(text="want to see as default in")
layout.label(text="Digital Twin app, than press")
layout.label(text="Create Planes button:")
# Add a blank separator
layout.separator()
row = layout.row()
row.prop(scene, "number_of_floors", text="Number of Floors:")
row = layout.row()
row.prop(scene, "default_floor", text="Default Floor:")
row = layout.row()
row.operator("object.create_planes_operator")
# Add a blank separator
layout.separator()
layout.label(text="Step 2: Move every labeled plane")
layout.label(text="on each floor starting height:")
# Add a blank separator
layout.separator()
layout.label(text="Step 3: Press button bellow to start")
layout.label(text="floor cutting process:")
row = layout.row()
row.operator("object.floor_cutter")
#----------------------------Register classes----------------------------#
# Register the addon
def register():
bpy.types.Scene.export_path = bpy.props.StringProperty(
name="Export Path",
description="Path for exporting FBX file",
default="Choose path",
subtype='FILE_PATH'
)
enable_developer_extras()
global set_face_colors, restore_face_colors
set_face_colors, restore_face_colors = create_face_color_manager()
bpy.utils.register_class(CheckForUpdateOperator)
bpy.utils.register_class(OBJECT_OT_delete_downward_faces)
bpy.utils.register_class(OBJECT_OT_tris_to_quads)
bpy.utils.register_class(OBJECT_OT_auto_smooth_all)
bpy.utils.register_class(OBJECT_OT_delete_custom_normals)
bpy.utils.register_class(OBJECT_OT_delete_duplicated_meshes)
bpy.utils.register_class(OBJECT_OT_merge_close_vertices)
bpy.utils.register_class(OBJECT_OT_limited_dissolve)
bpy.utils.register_class(OBJECT_OT_remove_unused_datablocks)
bpy.utils.register_class(OBJECT_OT_reparent)
bpy.utils.register_class(OBJECT_OT_recalculate_normals)
bpy.utils.register_class(OBJECT_OT_open_url_operator)
bpy.utils.register_class(OBJECT_OT_rotate_model_to_highest_normal_direction)
bpy.utils.register_class(OBJECT_OT_reset_origin)
bpy.utils.register_class(OBJECT_OT_reset_scale_to_1)
bpy.utils.register_class(OBJECT_OT_reset_to_original_state)
bpy.utils.register_class(OBJECT_OT_merge_similar_materials)
bpy.utils.register_class(OBJECT_OT_delete_bloat)
bpy.utils.register_class(OBJECT_OT_create_instances)
bpy.utils.register_class(OBJECT_OT_object_separator)
bpy.utils.register_class(OBJECT_OT_delete_armatures_and_bones)
bpy.utils.register_class(OBJECT_OT_delete_animations)
bpy.utils.register_class(OBJECT_OT_lod_rename)
bpy.utils.register_class(OBJECT_OT_export_model)
bpy.utils.register_class(OBJECT_OT_decimator_v5)
bpy.utils.register_class(OBJECT_OT_pack_external_data_into_blend_file)
bpy.utils.register_class(OBJECT_OT_polygon_heatmap)
bpy.utils.register_class(OBJECT_OT_clear_heatmap_data)
bpy.utils.register_class(OBJECT_OT_face_orientation_heatmap)
bpy.utils.register_class(OBJECT_OT_display_heatmap_by_instances)
bpy.utils.register_class(OBJECT_OT_display_heatmap_by_meshdensity)
bpy.utils.register_class(ClassicModelOperator)
bpy.utils.register_class(ScannedModelOperator)
bpy.utils.register_class(OperatorHolderPanel)
bpy.utils.register_class(IndividualFunctions)
bpy.utils.register_class(DeleteCleanupSubPanel)
bpy.utils.register_class(MeshModifySubPanel)
bpy.utils.register_class(ShadingSubPanel)
bpy.utils.register_class(HierarchySubPanel)
bpy.utils.register_class(MaterialSubPanel)
bpy.utils.register_class(AnimationsSubPanel)
bpy.utils.register_class(OthersSubPanel)
bpy.utils.register_class(ObjectSeparator)
bpy.utils.register_class(ObjectInstancer)
bpy.utils.register_class(VIEW3D_PT_scene_statistics)
bpy.utils.register_class(VIEW3D_PT_classical_scene_statistics_holder)
bpy.utils.register_class(VIEW3D_PT_classical_scene_heatmap_holder)
bpy.utils.register_class(VIEW3D_PT_classical_scene_statistics)
bpy.utils.register_class(VIEW3D_PT_ScanLidar_based_scene_statistics)
bpy.utils.register_class(Decimator_v5Panel)
# bpy.utils.register_class(FloorcutterPanel)
# bpy.utils.register_class(OBJECT_OT_CreatePlanes)
bpy.types.Scene.number_of_floors = bpy.props.IntProperty(name="Number of Floors", default=1, min=1, max=100, update=update_number_of_floors)
bpy.types.Scene.lowest_floor_number = bpy.props.IntProperty(name="Lowest Floor Number", default=0, min=0, max=99)
bpy.types.Scene.default_floor = bpy.props.IntProperty(name="Default Floor", default=1, min=1, max=100, update=update_default_floor)
bpy.utils.register_class(OBJECT_OT_FloorCutter)
bpy.utils.register_class(OBJECT_OT_BakeAnimationData)
bpy.utils.register_class(OBJECT_OT_Delete_non_visible_geometry)
bpy.utils.register_class(ExporterPanel)
bpy.utils.register_class(DocumentationPanel)
bpy.utils.register_class(UpdatePanel)
bpy.utils.register_class(UnsuitabilityMessageItem)
bpy.utils.register_class(SceneStatisticsProperties)
bpy.utils.register_class(SCENE_OT_classical_calculate_statistics)
bpy.utils.register_class(SCENE_OT_scanned_calculate_statistics)
bpy.types.Scene.statistics = bpy.props.PointerProperty(type=SceneStatisticsProperties)
# Unregister the addon
def unregister():
bpy.utils.unregister_class(CheckForUpdateOperator)
bpy.utils.unregister_class(OBJECT_OT_delete_downward_faces)
bpy.utils.unregister_class(OBJECT_OT_tris_to_quads)
bpy.utils.unregister_class(OBJECT_OT_auto_smooth_all)
bpy.utils.unregister_class(OBJECT_OT_delete_custom_normals)
bpy.utils.unregister_class(OBJECT_OT_delete_duplicated_meshes)
bpy.utils.unregister_class(OBJECT_OT_merge_close_vertices)
bpy.utils.unregister_class(OBJECT_OT_limited_dissolve)
bpy.utils.unregister_class(OBJECT_OT_remove_unused_datablocks)
bpy.utils.unregister_class(OBJECT_OT_reparent)
bpy.utils.unregister_class(OBJECT_OT_recalculate_normals)
bpy.utils.unregister_class(OBJECT_OT_open_url_operator)
bpy.utils.unregister_class(OBJECT_OT_rotate_model_to_highest_normal_direction)
bpy.utils.unregister_class(OBJECT_OT_reset_origin)
bpy.utils.unregister_class(OBJECT_OT_reset_scale_to_1)
bpy.utils.unregister_class(OBJECT_OT_reset_to_original_state)
bpy.utils.unregister_class(OBJECT_OT_merge_similar_materials)
bpy.utils.unregister_class(OBJECT_OT_delete_bloat)
bpy.utils.unregister_class(OBJECT_OT_create_instances)
bpy.utils.unregister_class(OBJECT_OT_object_separator)
bpy.utils.unregister_class(OBJECT_OT_delete_armatures_and_bones)
bpy.utils.unregister_class(OBJECT_OT_delete_animations)
bpy.utils.unregister_class(OBJECT_OT_lod_rename)
bpy.utils.unregister_class(OBJECT_OT_export_model)
bpy.utils.unregister_class(OBJECT_OT_decimator_v5)
bpy.utils.unregister_class(OBJECT_OT_pack_external_data_into_blend_file)
bpy.utils.unregister_class(OBJECT_OT_polygon_heatmap)
bpy.utils.unregister_class(OBJECT_OT_clear_heatmap_data)
bpy.utils.unregister_class(OBJECT_OT_face_orientation_heatmap)
bpy.utils.unregister_class(OBJECT_OT_display_heatmap_by_instances)
bpy.utils.unregister_class(OBJECT_OT_display_heatmap_by_meshdensity)
bpy.utils.unregister_class(ClassicModelOperator)
bpy.utils.unregister_class(ScannedModelOperator)
bpy.utils.unregister_class(OperatorHolderPanel)
bpy.utils.unregister_class(IndividualFunctions)
bpy.utils.unregister_class(DeleteCleanupSubPanel)
bpy.utils.unregister_class(MeshModifySubPanel)
bpy.utils.unregister_class(ShadingSubPanel)
bpy.utils.unregister_class(HierarchySubPanel)
bpy.utils.unregister_class(MaterialSubPanel)
bpy.utils.unregister_class(AnimationsSubPanel)
bpy.utils.unregister_class(OthersSubPanel)
bpy.utils.unregister_class(ObjectSeparator)
bpy.utils.unregister_class(ObjectInstancer)
bpy.utils.unregister_class(VIEW3D_PT_scene_statistics)
bpy.utils.unregister_class(VIEW3D_PT_classical_scene_statistics_holder)
bpy.utils.unregister_class(VIEW3D_PT_classical_scene_heatmap_holder)
bpy.utils.unregister_class(VIEW3D_PT_classical_scene_statistics)
bpy.utils.unregister_class(VIEW3D_PT_ScanLidar_based_scene_statistics)
bpy.utils.unregister_class(Decimator_v5Panel)
# bpy.utils.unregister_class(FloorcutterPanel)
# bpy.utils.register_class(OBJECT_OT_CreatePlanes)
# bpy.types.Scene.plane_count = bpy.props.IntProperty(name="Plane Count", default=1, min=1)
bpy.utils.unregister_class(OBJECT_OT_FloorCutter)
bpy.utils.unregister_class(OBJECT_OT_BakeAnimationData)
bpy.utils.unregister_class(OBJECT_OT_Delete_non_visible_geometry)
bpy.utils.unregister_class(ExporterPanel)
bpy.utils.unregister_class(DocumentationPanel)
bpy.utils.unregister_class(UpdatePanel)
bpy.utils.unregister_class(UnsuitabilityMessageItem)
bpy.utils.unregister_class(SceneStatisticsProperties)
bpy.utils.unregister_class(SCENE_OT_classical_calculate_statistics)
bpy.utils.unregister_class(SCENE_OT_scanned_calculate_statistics)
del bpy.types.Scene.number_of_floors
del bpy.types.Scene.lowest_floor_number
del bpy.types.Scene.default_floor
del bpy.types.Scene.statistics
del bpy.types.Scene.export_path
if __name__ == "__main__":
register(), multiple selections available,
Related content
FIGURO - Step by step
FIGURO - Step by step
More like this
Model preparation Guide
Model preparation Guide
More like this
3D FAQ
3D FAQ
Read with this
Welcome to the twinzo documentation!
Welcome to the twinzo documentation!
More like this
How to prepare OSM data for Twinzo
How to prepare OSM data for Twinzo
More like this
How to create online simple 3D model
How to create online simple 3D model
Read with this
If you encounter any issues or need assistance with using this product, please do not hesitate to reach out for support. Our team is here to help you resolve any problems and answer any questions you may have.
To create a support ticket, visit our support portal at https://partner.twinzo.eu/helpdesk/customer-care-1