Blender: segmentation, fault core dumped?

问题:

Here is an add-on I'm trying to create:

import bpy
import os
import sys
import subprocess
import time
from threading import * 


class Repeat(Thread):
    def __init__(self,delay,function,*args,**kwargs):
        Thread.__init__(self)
        self.abort = Event()
        self.delay = delay
        self.args = args
        self.kwargs = kwargs
        self.function = function
    def stop(self):
        self.abort.set()
    def run(self):
        while not self.abort.isSet():
            self.function(*self.args,**self.kwargs)
            self.abort.wait(self.delay)

class ExportToGIMP(bpy.types.Operator):
    bl_idname = "uv.exporttogimp"
    bl_label = "Export to GIMP"

    def execute(self, context):
        f = open("/home/antoni4040/blender.txt", "w").close() 
        self.filepath = os.path.join(os.path.dirname(bpy.data.filepath), "Layout")
        bpy.ops.uv.export_layout(filepath=self.filepath, check_existing=True, export_all=False, modified=False, mode='PNG', size=(1024, 1024), opacity=0.25, tessellated=False)
        self.files = os.path.dirname(bpy.data.filepath)
        cmd = " (python-fu-bgsync RUN-NONINTERACTIVE)"
        subprocess.Popen(['gimp', '-b', cmd])
        file = Repeat(3, self.up)
        file.start()
        return {'FINISHED'};

    def doit(self):
        r = Repeat(3, self.update)
        r.start()

    def up(self):
        f = open("/home/antoni4040/blender.txt", "r")
        string = f.read()
        if "ok" in string:
            self.materialize()
            self.doit()
            file.stop()
        else:
            pass     

    def update(self):
        self.layout_texture.image.reload()
        for area in bpy.data.screens['Default'].areas:
            if area.type in ['IMAGE_EDITOR', 'VIEW_3D']:
                area.tag_redraw()

    def materialize(self):
        self.layout_texture = bpy.data.textures.new(name = "Layout_Texture", type = "IMAGE")
        self.material = bpy.data.materials.new(name="Layout")
        self.object = bpy.context.active_object
        self.material_texture = self.material.texture_slots.add()
        self.material_texture.texture = self.layout_texture
        self.material_texture.texture_coords = "UV"
        self.filepath2 = "/home/antoni4040/Έγγραφα/Layout1.png"
        self.texture_image = bpy.data.images.load(self.filepath2)                       
        self.layout_texture.image = self.texture_image
        self.con_obj = self.object.data
        self.con_obj.materials.append(self.material)
        bpy.data.screens['UV Editing'].areas[1].spaces[0].image = self.texture_image

def exporttogimp_menu(self, context):
    self.layout.operator(ExportToGIMP.bl_idname, text="Export To GIMP")

bpy.utils.register_class(ExportToGIMP)
bpy.types.IMAGE_MT_uvs.append(exporttogimp_menu)

Which works along with this:

#!/usr/bin/env python
# -*- coding: utf-8 -*-


from gimpfu import *
import time
import sys  

def blender_gimp_sync():
    im_dir = "/home/antoni4040/Έγγραφα/Layout.png"
    image = gimp.pdb.gimp_file_load(im_dir, im_dir)
    gimp.Display(image)
    layer = gimp.pdb.gimp_layer_new(image, 1024, 1024, RGBA_IMAGE, "PaintHere", 100.0, NORMAL_MODE) 
    image.add_layer(layer)
    drawable = pdb.gimp_image_get_active_layer(image)
    num = 1
    while True:
        time.sleep(3.0)
        if image is not None:  
            ims_dir = "/home/antoni4040/Έγγραφα/Layout1.png"
            gimp.pdb.file_png_save(image, drawable, ims_dir, ims_dir, 0, 0, 0, 0, 0, 0, 0)
            f = open("/home/antoni4040/blender.txt", "w")
            f.write("ok")
        else:
            pass

register(
    "python_fu_bgsync",
    "Blender-Gimp Sync",
    "Syncronize Gimp with Blender for texturing",
    "Antonis Karvelas",
    "Antonis Karvelas",
    "2012",
    "Sync",
    "",
    [],
    [],
    blender_gimp_sync,
    menu="<Image>/Image/Blender-Gimp"
)   
main()

But, I always get a segmentation fault error... Why is that happening? What I'm doing wrong?

回答1:

Well, you can find this in the code Templates as "Operator Modal Timer", that shows how to do things continuously in Blender:

import bpy


class ModalTimerOperator(bpy.types.Operator):
    """Operator which runs its self from a timer"""
    bl_idname = "wm.modal_timer_operator"
    bl_label = "Modal Timer Operator"

    _timer = None

    def modal(self, context, event):
        if event.type == 'ESC':
            return self.cancel(context)

        if event.type == 'TIMER':
            # change theme color, silly!
            color = context.user_preferences.themes[0].view_3d.space.back
            color.s = 1.0
            color.h += 0.01

        return {'PASS_THROUGH'}

    def execute(self, context):
        self._timer = context.window_manager.event_timer_add(0.1, context.window)
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        context.window_manager.event_timer_remove(self._timer)
        return {'CANCELLED'}


def register():
    bpy.utils.register_class(ModalTimerOperator)


def unregister():
    bpy.utils.unregister_class(ModalTimerOperator)


if __name__ == "__main__":
    register()

    # test call
    bpy.ops.wm.modal_timer_operator()