cubester.py

            box.separator()

            if scene.cubester_audio_image == "image":
                box.prop(scene, "cubester_use_image_color", icon="COLOR")

            if not scene.cubester_use_image_color or scene.cubester_audio_image == "audio":
                box.label("Image To Use For Colors:")
                box.prop_search(scene, "cubester_color_image", bpy.data, "images")
                box.prop(scene, "cubester_load_color_image")

            if scene.cubester_image in bpy.data.images:
                rows = int(bpy.data.images[scene.cubester_image].size[1] / (scene.cubester_skip_pixels + 1))
                columns = int(bpy.data.images[scene.cubester_image].size[0] / (scene.cubester_skip_pixels + 1))

        layout.separator()
        box = layout.box()

        if scene.cubester_mesh_style == "blocks":
            box.label("Approximate Cube Count: " + str(rows * columns))
            box.label("Expected # Verts/Faces: " + str(rows * columns * 8) + " / " + str(rows * columns * 6))
        else:
            box.label("Approximate Point Count: " + str(rows * columns))
            box.label("Expected # Verts/Faces: " + str(rows * columns) + " / " + str(rows * (columns - 1)))

        # blocks and plane generation time values
        if scene.cubester_mesh_style == "blocks":
            slope = 0.0000876958
            intercept = 0.02501
            block_infl, frame_infl, intercept2 = 0.0025934, 0.38507, -0.5840189

        else:
            slope = 0.000017753
            intercept = 0.04201
            block_infl, frame_infl, intercept2 = 0.000619, 0.344636, -0.272759

        # if creating image based mesh
        points = rows * columns
        if scene.cubester_audio_image == "image":
            if scene.cubester_load_type == "single":
                time = rows * columns * slope + intercept  # approximate time count for mesh
            else:
                time = (points * slope) + intercept + (points * block_infl) + \
                       (images_found / scene.cubester_skip_images * frame_infl) + intercept2

                box.label("Images To Be Used: " + str(int(images_found / scene.cubester_skip_images)))

        # audio based mesh
        else:
            box.label("Audio Track Length: " + scene.cubester_audio_file_length + " frames")

            block_infl, frame_infl, intercept = 0.0948, 0.0687566, -25.85985
            time = (points * block_infl) + (int(scene.cubester_audio_file_length) * frame_infl) + intercept

        time_mod = "s"
        if time > 60:  # convert to minutes if needed
            time /= 60
            time_mod = "min"
        time = round(time, 3)

        box.label("Expected Time: " + str(time) + " " + time_mod)

        # advanced
        if scene.cubester_audio_image == "image":
            layout.separator()
            box = layout.box()
            box.prop(scene, "cubester_advanced", icon="TRIA_DOWN")
            if bpy.context.scene.cubester_advanced:
                box.prop(scene, "cubester_random_weights", icon="RNDCURVE")
                box.separator()

                if not bpy.context.scene.cubester_random_weights:
                    box.label("RGBA Channel Weights", icon="COLOR")
                    box.prop(scene, "cubester_weight_r")
                    box.prop(scene, "cubester_weight_g")
                    box.prop(scene, "cubester_weight_b")
                    box.prop(scene, "cubester_weight_a")

        # generate mesh
        layout.separator()
        layout.operator("mesh.cubester", icon="OBJECT_DATA")


class CubeSter(Operator):
    bl_idname = "mesh.cubester"
    bl_label = "Generate Mesh"
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
        verts, faces = [], []

        start = timeit.default_timer()
        scene = bpy.context.scene

        if scene.cubester_audio_image == "image":
            create_mesh_from_image(self, scene, verts, faces)
            frames = find_sequence_images(self, context)
            created = len(frames[0])
        else:
            create_mesh_from_audio(self, scene, verts, faces)
            created = int(scene.cubester_audio_file_length)

        stop = timeit.default_timer()

        if scene.cubester_mesh_style == "blocks" or scene.cubester_audio_image == "audio":
            self.report({"INFO"},
                        "CubeSter: {} blocks and {} frame(s) "
                        "in {}s".format(str(int(len(verts) / 8)),
                                        str(created),
                                        str(round(stop - start, 4)))
                        )
        else:
            self.report({"INFO"},
                        "CubeSter: {} points and {} frame(s) "
                        "in {}s" .format(str(len(verts)),
                                         str(created),
                                         str(round(stop - start, 4)))
                        )

        return {"FINISHED"}


def register():
    bpy.utils.register_module(__name__)
    bpy.app.handlers.frame_change_pre.append(material_frame_handler)


def unregister():
    bpy.utils.unregister_module(__name__)
    bpy.app.handlers.frame_change_pre.remove(material_frame_handler)


if __name__ == "__main__":
    register()