def __init__(self, model: OBJ, controller):
        self._model = model  # type: OBJ
        self._controller = controller  # type: Controller

        # init pattern data
        self._split_factor = 0.2  # type: float
        self.MAX_SEGMENTS = -1  # type: int
        self._pattern_offsets = None  # type: np.array
        self._pattern_indexes = None  # type: np.array
        self._pattern_parameters = None  # type: np.array
        self._need_recompute = True  # type: bool
        self._need_update_split_factor = True  # type: bool
        self._splited_triangle_number = -1  # type: int
        self.init_pattern_data()

        # declare buffer
        self._original_vertex_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 0, None, GL_DYNAMIC_DRAW)
        self._original_normal_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 1, None, GL_DYNAMIC_DRAW)
        self._original_tex_coord_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 22, None, GL_DYNAMIC_DRAW)
        if self._model.from_bezier:
            self._original_uv_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 24, None, GL_DYNAMIC_DRAW)
        self._original_index_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 2, None, GL_DYNAMIC_DRAW)
        self._splited_triangle_counter_acbo = ACVBO(GL_ATOMIC_COUNTER_BUFFER, 0, None, GL_DYNAMIC_DRAW)
        self._adjacency_info_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 3, None, GL_DYNAMIC_DRAW)
        self._share_adjacency_pn_triangle_normal_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 4, None, GL_DYNAMIC_DRAW)
        self._share_adjacency_pn_triangle_position_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 19, None, GL_DYNAMIC_DRAW)
        self._splited_triangle_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 5, None, GL_DYNAMIC_DRAW)

        # init shader
        self._program_gen_pn_triangle = ProgramWrap().add_shader(
            ShaderWrap(GL_COMPUTE_SHADER, add_prefix('previous_compute_shader_pn_oo.glsl')))
        self._program = ProgramWrap().add_shader(
            PreviousComputeShader(GL_COMPUTE_SHADER, add_prefix('previous_compute_shader_oo.glsl'),
                                  self))  # type: ProgramWrap
Exemplo n.º 2
0
 def __init__(self, controller):
     super().__init__()
     self._controller = controller  # type: DeformAndDrawController
     if conf.IS_FAST_MODE:
         self._tessellation_parameter = ACVBO(GL_SHADER_STORAGE_BUFFER, 16, None, GL_STATIC_DRAW)  # type: ACVBO
         self._tessellation_indexes = ACVBO(GL_SHADER_STORAGE_BUFFER, 13, None, GL_STATIC_DRAW)  # type: ACVBO
         self._tessellation_aux = ACVBO(GL_UNIFORM_BUFFER, 4, None, GL_STATIC_DRAW)  # type: ACVBO
     else:
         self._tessellation_parameter = ACVBO(GL_UNIFORM_BUFFER, 2, None, GL_STATIC_DRAW)  # type: ACVBO
         self._tessellation_indexes = ACVBO(GL_UNIFORM_BUFFER, 3, None, GL_STATIC_DRAW)  # type: ACVBO
Exemplo n.º 3
0
    def comparison_helper(vbo1: ACVBO, vbo2: ACVBO, fun):
        point_number = int(vbo1.capacity / 16)
        acc = 0
        max_e = -1
        es = []
        for i, j in zip(vbo1.get_value(ctypes.c_float, (point_number, 4)),
                        vbo2.get_value(ctypes.c_float, (point_number, 4))):
            e = fun(i, j)
            max_e = max(e, max_e)
            acc += e
            es.append(e)

        average = acc / point_number
        acc = 0
        for e in es:
            acc += ((e - average) ** 2)
        standard_deviation = (acc / point_number) ** 0.5
        return average, max_e, standard_deviation
Exemplo n.º 4
0
    def gl_init_global(self):
        glClearColor(1, 1, 1, 1)
        self._aux_controller.gl_init()

        self._debug_buffer = ACVBO(GL_SHADER_STORAGE_BUFFER, 14, None, GL_DYNAMIC_READ)  # type: ACVBO
        self._debug_buffer.capacity = 4096
        self._debug_buffer.gl_sync()

        # init previous compute shader
        self._previous_compute_controller_AC.gl_init()
        self._previous_compute_controller_CYM.gl_init()

        self.previous_compute_controller.gl_compute(self._aux_controller.gl_sync_buffer_for_previous_computer)
        glFinish()

        # alloc memory in gpu for tessellated vertex
        self._deform_and_renderer_controller = DeformAndDrawController(
            self._model.has_texture,
            self.previous_compute_controller,
            self._model,
            self._aux_controller,
            self._controller)
        self._deform_and_renderer_controller.gl_init()
Exemplo n.º 5
0
    def __init__(self, size: list):
        # check input
        if len(size) != 3:
            raise Exception('b spline body size number error')
        if any(i < 0 for i in size):
            raise Exception('b spline body size < 0, error')

        # init b-spline body
        self._b_spline_body = BSplineBody(*size)  # type: BSplineBody

        # init shader program
        self._renderer_program = ProgramWrap().add_shader(ShaderWrap(GL_VERTEX_SHADER, add_prefix('aux.v.glsl'))) \
            .add_shader(ShaderWrap(GL_FRAGMENT_SHADER, add_prefix('aux.f.glsl')))  # type: ProgramWrap

        # init buffer
        self._control_point_position_vbo = ACVBO(GL_ARRAY_BUFFER, -1, None, GL_DYNAMIC_DRAW)  # type: ACVBO
        if conf.IS_FAST_MODE:
            self._control_point_for_sample_ubo = ACVBO(GL_SHADER_STORAGE_BUFFER, 15, None,
                                                       GL_DYNAMIC_DRAW)  # type: ACVBO
        else:
            self._control_point_for_sample_ubo = ACVBO(GL_UNIFORM_BUFFER, 1, None, GL_DYNAMIC_DRAW)  # type: ACVBO
        self._b_spline_body_info_ubo = ACVBO(GL_UNIFORM_BUFFER, 0, None, GL_STATIC_DRAW)  # type: ACVBO
        self._selected_counter_acbo = ACVBO(GL_ATOMIC_COUNTER_BUFFER, 1, None, GL_DYNAMIC_DRAW)
        self._vao_control_point = -1  # type: int
        self._normal_control_mode = False  # type: bool
        self._pick_region = None  # type: ACRect
        self._control_points_changed = True  # type: bool
        self._direct_control_point = []  # type:  list
        self._intersect_point_parameter = None

        # init compute select point shader program
        self._select_point_program = ProgramWrap() \
            .add_shader(ShaderWrap(GL_COMPUTE_SHADER, add_compute_prefix('select_point.glsl')))
        self._intersect_result_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 20, None, GL_DYNAMIC_DRAW)  # type: ACVBO
        self._need_select_point = False
        self._select_argument = None

        self._delta_for_dffd = [0, 0, 0]
Exemplo n.º 6
0
class GLProxy:
    def __init__(self, controller=None):
        self._controller = controller
        self._aux_controller = None  # type: AuxController
        self._deform_and_renderer_controller = None  # type: DeformAndDrawController
        self._debug_buffer = None  # type: ACVBO
        self._model = None  # type: OBJ
        self._previous_compute_controller_CYM = None
        self._previous_compute_controller_AC = None

        if len(sys.argv) > 1 and sys.argv[1] == 'cpu':
            self._algorithm = ALGORITHM_CYM
        else:
            self._algorithm = ALGORITHM_AC

    def change_model(self, model: OBJ):
        self._model = model
        if self._aux_controller is None:
            self._aux_controller = AuxController(model.get_length_xyz())  # type: AuxController
        else:
            self._aux_controller.change_size(model.get_length_xyz())

        if conf.REMOVE_UN_SPLIT_TRIANGLE:
            self._model.remove_un_split_triangle(self._aux_controller.b_spline_body)

        if self.previous_compute_controller is None:
            self._previous_compute_controller_AC = \
                PreviousComputeControllerGPU(model, self._controller)
            self._previous_compute_controller_CYM = \
                PreviousComputeControllerCPU(model, self._aux_controller.b_spline_body,
                                             self._previous_compute_controller_AC, self._controller)
            if self._algorithm == ALGORITHM_AC:
                self._previous_compute_controller_CYM.need_upload_control_points = False
        else:
            self.previous_compute_controller.change_model(model)
            self.previous_compute_controller.b_spline_body = self._aux_controller.b_spline_body

    def draw(self, model_view_matrix, perspective_matrix):
        number, need_deform = self.previous_compute_controller.gl_compute(
            self._aux_controller.gl_sync_buffer_for_previous_computer)
        glFinish()
        self._deform_and_renderer_controller.set_number_and_need_deform(number, need_deform)
        self._deform_and_renderer_controller.gl_renderer(model_view_matrix, perspective_matrix,
                                                         self._aux_controller.gl_sync_buffer_for_deformation)
        # for i in self._debug_buffer.get_value(ctypes.c_float, (10, 4)):
        #     print(i)
        self._aux_controller.gl_draw(model_view_matrix, perspective_matrix)

    def gl_init_global(self):
        glClearColor(1, 1, 1, 1)
        self._aux_controller.gl_init()

        self._debug_buffer = ACVBO(GL_SHADER_STORAGE_BUFFER, 14, None, GL_DYNAMIC_READ)  # type: ACVBO
        self._debug_buffer.capacity = 4096
        self._debug_buffer.gl_sync()

        # init previous compute shader
        self._previous_compute_controller_AC.gl_init()
        self._previous_compute_controller_CYM.gl_init()

        self.previous_compute_controller.gl_compute(self._aux_controller.gl_sync_buffer_for_previous_computer)
        glFinish()

        # alloc memory in gpu for tessellated vertex
        self._deform_and_renderer_controller = DeformAndDrawController(
            self._model.has_texture,
            self.previous_compute_controller,
            self._model,
            self._aux_controller,
            self._controller)
        self._deform_and_renderer_controller.gl_init()

    def set_select_region(self, x1, y1, x2, y2):
        if self._aux_controller.is_normal_control_point_mode:
            region = ACRect(x1, y1, x2 - x1, y2 - y1)
            self._aux_controller.pick_control_point(region)

    def set_select_point(self, start_point, direction):
        self._aux_controller.select_point_gpu(start_point, direction,
                                              self.previous_compute_controller.splited_triangle_number *
                                              self._deform_and_renderer_controller.tessellated_triangle_number_pre_splited_triangle)

    def move_control_points(self, x, y, z):
        self._aux_controller.move_selected_control_points([x, y, z])
        self._deform_and_renderer_controller.need_deform = True

    def rotate_control_points(self, m):
        self._aux_controller.rotate_selected_control_points(m)
        self._deform_and_renderer_controller.need_deform = True

    def change_tessellation_level(self, level):
        self._deform_and_renderer_controller.set_tessellation_factor(level)  # type: DeformAndDrawController
        self._deform_and_renderer_controller.need_deform = True
        self.aux_controller.b_spline_body.modify_range_flag = True

    def change_control_point_number(self, u, v, w):
        self._aux_controller.change_control_point_number(u, v, w)
        self.previous_compute_controller.need_compute = True
        self._deform_and_renderer_controller.need_deform = True

    def change_control_point_order(self, order):
        self._aux_controller.change_control_point_order(order)
        self.previous_compute_controller.need_compute = True
        self._deform_and_renderer_controller.need_deform = True

    def change_split_factor(self, factor):
        if self._algorithm == ALGORITHM_AC:
            self.previous_compute_controller.split_factor = factor
            if conf.IS_UNIFORM_ADAPTIVE_TESSELLATION_FACTOR:
                self.change_tessellation_level(
                    self.previous_compute_controller.split_factor / self._deform_and_renderer_controller.final_tessellation_level)
            self.aux_controller.b_spline_body.modify_range_flag = True

    def set_control_point_visibility(self, v):
        self._aux_controller.is_normal_control_point_mode = v

    def set_splited_edge_visibility(self, v):
        self._deform_and_renderer_controller.set_splited_edge_visibility(v)

    def set_show_triangle_quality(self, is_show):
        self._deform_and_renderer_controller.set_show_triangle_quality(is_show)

    def set_show_normal_diff(self, is_show):
        self._deform_and_renderer_controller.set_show_normal_diff(is_show)

    def set_show_position_diff(self, is_show):
        self._deform_and_renderer_controller.set_show_position_diff(is_show)

    def set_adjust_control_point(self, is_adjust):
        self._deform_and_renderer_controller.set_adjust_control_point(is_adjust)
        self._aux_controller.b_spline_body.modify_range_flag = True

    def set_show_control_point(self, is_show):
        self._deform_and_renderer_controller.show_control_point = is_show

    def set_show_normal(self, is_show):
        self._deform_and_renderer_controller.show_normal = is_show

    @property
    def aux_controller(self):
        return self._aux_controller

    @property
    def normal_control_mode(self):
        return self._aux_controller.normal_control_mode

    def clear_direct_control_point(self):
        self._aux_controller.clear_dst_direct_control_point()

    def move_direct_control_point(self, direction):
        self._aux_controller.move_direct_control_point(direction)
        self._deform_and_renderer_controller.need_deform = True

    def move_direct_control_point_delta(self, direction):
        self._aux_controller.move_direct_control_point_delta(direction)
        self._deform_and_renderer_controller.need_deform = True

    def direct_control_point_selected(self):
        return self._aux_controller.is_direct_control_point_selected()

    def set_show_real(self, is_show):
        self._deform_and_renderer_controller.set_show_real(is_show)

    def set_show_original(self, is_show):
        self._deform_and_renderer_controller.set_show_original(is_show)
        self.previous_compute_controller.gl_update_index(is_show)

    def set_need_comparison(self):
        self._deform_and_renderer_controller.set_need_comparison()

    @property
    def algorithm(self):
        return self._algorithm

    @algorithm.setter
    def algorithm(self, algorithm):
        self._algorithm = algorithm
        self.previous_compute_controller.need_compute = True
        self.previous_compute_controller.gl_async_update_buffer_about_output()
        self.aux_controller.b_spline_body.modify_range_flag = True

    @property
    def previous_compute_controller(self):
        if self._algorithm == ALGORITHM_AC:
            return self._previous_compute_controller_AC
        else:
            return self._previous_compute_controller_CYM

    def control_points(self):
        return self._aux_controller.get_normal_control_point_data()

    def set_control_points(self, control_points):
        self._aux_controller.set_control_points(control_points)
        self._deform_and_renderer_controller.need_deform = True

    def get_parameter_str(self):
        return '%s_%.2f_%d' % (self.aux_controller.get_control_point_str(),
                               self._previous_compute_controller_AC.split_factor,
                               self._deform_and_renderer_controller.tessellation_level)

    def set_use_pn_normal(self, use):
        self._deform_and_renderer_controller.use_pn_normal_for_renderer = use

    def clear_director_control_points(self):
        self.aux_controller.clear_all_direct_control_point()

    def save_image(self):
        self._deform_and_renderer_controller.save_screen(self._controller.window_size.w,
                                                         self._controller.window_size.h)

    def use_texture(self, b):
        self._deform_and_renderer_controller.use_texture(b)

    def export_obj(self):
        self._deform_and_renderer_controller.export_obj()
class PreviousComputeControllerGPU:
    def __init__(self, model: OBJ, controller):
        self._model = model  # type: OBJ
        self._controller = controller  # type: Controller

        # init pattern data
        self._split_factor = 0.2  # type: float
        self.MAX_SEGMENTS = -1  # type: int
        self._pattern_offsets = None  # type: np.array
        self._pattern_indexes = None  # type: np.array
        self._pattern_parameters = None  # type: np.array
        self._need_recompute = True  # type: bool
        self._need_update_split_factor = True  # type: bool
        self._splited_triangle_number = -1  # type: int
        self.init_pattern_data()

        # declare buffer
        self._original_vertex_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 0, None, GL_DYNAMIC_DRAW)
        self._original_normal_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 1, None, GL_DYNAMIC_DRAW)
        self._original_tex_coord_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 22, None, GL_DYNAMIC_DRAW)
        if self._model.from_bezier:
            self._original_uv_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 24, None, GL_DYNAMIC_DRAW)
        self._original_index_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 2, None, GL_DYNAMIC_DRAW)
        self._splited_triangle_counter_acbo = ACVBO(GL_ATOMIC_COUNTER_BUFFER, 0, None, GL_DYNAMIC_DRAW)
        self._adjacency_info_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 3, None, GL_DYNAMIC_DRAW)
        self._share_adjacency_pn_triangle_normal_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 4, None, GL_DYNAMIC_DRAW)
        self._share_adjacency_pn_triangle_position_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 19, None, GL_DYNAMIC_DRAW)
        self._splited_triangle_ssbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 5, None, GL_DYNAMIC_DRAW)

        # init shader
        self._program_gen_pn_triangle = ProgramWrap().add_shader(
            ShaderWrap(GL_COMPUTE_SHADER, add_prefix('previous_compute_shader_pn_oo.glsl')))
        self._program = ProgramWrap().add_shader(
            PreviousComputeShader(GL_COMPUTE_SHADER, add_prefix('previous_compute_shader_oo.glsl'),
                                  self))  # type: ProgramWrap

    @staticmethod
    def compute_triangle_quality(p1, p2, p3):
        points = [np.array(p) for p in (p1, p2, p3)]
        vecs = [points[0] - points[1], points[1] - points[2], points[2] - points[0]]
        area = np.linalg.norm(np.cross(vecs[0], vecs[1]) / 2)
        lens = [np.linalg.norm(v) for v in vecs]
        perimeter = sum(lens)
        return (2 * area / perimeter) / max(lens) * 2 * (3 ** 0.5)

    @staticmethod
    def compute_triangle_area(p1, p2, p3):
        def len(v1, v2):
            return sum([(x - y) ** 2 for x, y in zip(v1, v2)]) ** 0.5

        ls = [len(p1, p2), len(p2, p3), len(p3, p1)]
        s = sum(ls) / 2
        temp = [s - x for x in ls]
        return (temp[0] * temp[1] * temp[2] * s) ** 0.5

    def get_average_area_and_triangle_quality(self):
        triangles = self._splited_triangle_ssbo.get_value(ctypes.c_float, shape=(self._splited_triangle_number, 100))
        temp = 0
        temp_quality = 0
        for t in triangles:
            three_points = [x[:3] for x in zip(*[iter(t[:12])] * 4)]
            temp += PreviousComputeControllerGPU.compute_triangle_area(*three_points)
            # temp_quality += PreviousComputeControllerGPU.compute_triangle_quality(*three_points)
            temp_quality += t[-1]
        return temp / self.splited_triangle_number, temp_quality / self.splited_triangle_number

    def change_model(self, model):
        self._model = model
        self.gl_async_update_buffer_for_self_about_model()
        self._need_recompute = True  # type: bool

    def gl_init(self):
        self._program_gen_pn_triangle.link()
        self._program.link()
        self.gl_set_split_factor()
        # async update vbo
        self.gl_async_update_buffer_for_self()

    def gl_init_split_counter(self):
        self._splited_triangle_counter_acbo.async_update(np.array([0], dtype=np.uint32))
        self._splited_triangle_counter_acbo.gl_sync()

    def gl_async_update_buffer_for_self(self):
        indexes_size = self._pattern_indexes.size * self._pattern_indexes.itemsize
        parameter_size = self._pattern_parameters.size * self._pattern_parameters.itemsize
        offset_size = self._pattern_offsets.size * self._pattern_offsets.itemsize
        split_info_buffer = glGenBuffers(1)
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, split_info_buffer)
        glBufferData(GL_SHADER_STORAGE_BUFFER, offset_size + indexes_size + parameter_size,
                     None,
                     usage=GL_DYNAMIC_DRAW)
        glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, indexes_size, self._pattern_indexes)
        glBufferSubData(GL_SHADER_STORAGE_BUFFER, indexes_size, parameter_size, self._pattern_parameters)
        glBufferSubData(GL_SHADER_STORAGE_BUFFER, indexes_size + parameter_size, offset_size, self._pattern_offsets)
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 9, split_info_buffer)
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)

        self.gl_async_update_buffer_for_self_about_model()

    def gl_async_update_buffer_for_self_about_model(self):
        self._original_vertex_ssbo.async_update(self._model.vertex)
        self._original_normal_ssbo.async_update(self._model.normal)
        self._original_tex_coord_ssbo.async_update(self._model.tex_coord)
        if self._model.from_bezier:
            self._original_uv_ssbo.async_update(self._model.bezier_uv)
        self._original_index_ssbo.async_update(self._model.index)
        self._adjacency_info_ssbo.async_update(self._model.adjacency)
        self.gl_async_update_buffer_about_output()

    def gl_update_index(self, is_original):
        if not is_original:
            self._original_index_ssbo.async_update(self._model.index)
        else:
            print('update index for original')
            self._original_index_ssbo.async_update(self._model.index_without_mark)

    def gl_async_update_buffer_about_output(self):
        self._share_adjacency_pn_triangle_normal_ssbo.capacity = self._model._original_triangle_number \
                                                                 * PER_TRIANGLE_PN_NORMAL_TRIANGLE_SIZE

        self._share_adjacency_pn_triangle_position_ssbo.capacity = self._model._original_triangle_number \
                                                                   * PER_TRIANGLE_PN_POSITION_TRIANGLE_SIZE

        # 用于储存原始三角面片的PN-triangle
        self._splited_triangle_ssbo.capacity = self._model._original_triangle_number \
                                               * MAX_SPLITED_TRIANGLE_PRE_ORIGINAL_TRIANGLE \
                                               * SPLITED_TRIANGLE_SIZE

    def gl_sync(self):
        self._original_vertex_ssbo.gl_sync()
        self._original_normal_ssbo.gl_sync()
        self._original_tex_coord_ssbo.gl_sync()
        if self._model.from_bezier:
            self._original_uv_ssbo.gl_sync()
        self._original_index_ssbo.gl_sync()
        self._adjacency_info_ssbo.gl_sync()
        self._share_adjacency_pn_triangle_normal_ssbo.gl_sync()
        self._share_adjacency_pn_triangle_position_ssbo.gl_sync()
        self._splited_triangle_ssbo.gl_sync()

    def gl_compute(self, op) -> (int, bool):
        if not self._need_recompute:
            return self._splited_triangle_number, False
        self.gl_sync()
        op()
        if self._need_update_split_factor:
            self.gl_set_split_factor()
            self._need_update_split_factor = False
        self._program_gen_pn_triangle.use()

        gl_timing(lambda: glDispatchCompute(*self.group_size), 'gen PN triangle time')
        glFinish()

        self._program.use()
        self.gl_init_split_counter()

        self._controller.add_time(gl_timing(lambda: glDispatchCompute(*self.group_size), 'pre compute time'))

        glUseProgram(0)

        self._splited_triangle_number = self.get_splited_triangles_number()
        glFinish()

        self._need_recompute = False
        # print('gl_compute:', 'gpu splited triangle number: %d' % self._splited_triangle_number)
        self._controller.add_splited_number(self.splited_triangle_number)
        area, quality = self.get_average_area_and_triangle_quality()
        self._controller.add_area(area)
        self._controller.add_quality(quality)
        return self._splited_triangle_number, True

    @property
    def need_compute(self):
        return self._need_recompute

    @need_compute.setter
    def need_compute(self, b):
        self._need_recompute = b

    @property
    def split_factor(self):
        return self._split_factor

    @property
    def model(self):
        return self._model

    @property
    def group_size(self):
        return [int(self._model._original_triangle_number / 512 + 1), 1, 1]

    @split_factor.setter
    def split_factor(self, split_factor):
        self._split_factor = split_factor
        self._need_recompute = True
        self._need_update_split_factor = True

    def gl_set_split_factor(self):
        glProgramUniform1f(self._program.program, 0, self._split_factor)

    @property
    def pattern_offsets(self):
        return self._pattern_offsets

    @property
    def pattern_indexes(self):
        return self._pattern_indexes

    @property
    def pattern_parameters(self):
        return self._pattern_parameters

    def init_pattern_data(self):
        with open(PATTERN_FILE_PATH) as file:
            max_factor, offset_line, indexes_line, parameter_line = file
        print('read pattern file ok')
        self.MAX_SEGMENTS = int(max_factor)
        self._pattern_offsets = np.asarray([int(x) for x in offset_line.strip().split(" ")], dtype=np.uint32)
        self._pattern_indexes = np.asarray([int(x) for x in indexes_line.strip().split(" ")], dtype=np.uint32)
        self._pattern_parameters = np.asarray([abs(float(x)) for x in parameter_line.strip().split(" ")],
                                              dtype=np.float32)
        print('translate to np array ok')
        indexes_size = self._pattern_indexes.size * self._pattern_indexes.itemsize
        parameter_size = self._pattern_parameters.size * self._pattern_parameters.itemsize
        offset_size = self._pattern_offsets.size * self._pattern_offsets.itemsize
        print('pattern size ', (offset_size + indexes_size + parameter_size) / 1024 / 1024, "mb")

    def get_offset_for_i(self) -> str:
        look_up_table_for_i = [0]
        for i in range(1, self.MAX_SEGMENTS):
            ii = min(self.MAX_SEGMENTS - i, i)
            look_up_table_for_i.append(
                int(look_up_table_for_i[-1] + (1 + ii) * ii / 2 + max(0, (i + 1) * (self.MAX_SEGMENTS - 2 * i))))
        return '{' + ','.join([str(i) for i in look_up_table_for_i]) + '}'

    def get_splited_triangles_number(self) -> int:
        return self._splited_triangle_counter_acbo.get_value(ctypes.c_uint32)[0]

    @property
    def splited_triangle_number(self):
        return self._splited_triangle_number

    @property
    def share_adjacency_pn_triangle_normal_ssbo(self):
        return self._share_adjacency_pn_triangle_normal_ssbo

    @property
    def share_adjacency_pn_triangle_position_ssbo(self):
        return self._share_adjacency_pn_triangle_position_ssbo

    @property
    def splited_triangle_ssbo(self):
        return self._splited_triangle_ssbo

    @property
    def original_vertex_ssbo(self):
        return self._original_vertex_ssbo

    @property
    def original_normal_ssbo(self):
        return self._original_normal_ssbo

    @property
    def original_tex_coord_ssbo(self):
        return self._original_tex_coord_ssbo

    @property
    def original_index_ssbo(self):
        return self._original_index_ssbo
Exemplo n.º 8
0
class DeformComputeProgram(ProgramWrap):
    def __init__(self, controller):
        super().__init__()
        self._controller = controller  # type: DeformAndDrawController
        if conf.IS_FAST_MODE:
            self._tessellation_parameter = ACVBO(GL_SHADER_STORAGE_BUFFER, 16, None, GL_STATIC_DRAW)  # type: ACVBO
            self._tessellation_indexes = ACVBO(GL_SHADER_STORAGE_BUFFER, 13, None, GL_STATIC_DRAW)  # type: ACVBO
            self._tessellation_aux = ACVBO(GL_UNIFORM_BUFFER, 4, None, GL_STATIC_DRAW)  # type: ACVBO
        else:
            self._tessellation_parameter = ACVBO(GL_UNIFORM_BUFFER, 2, None, GL_STATIC_DRAW)  # type: ACVBO
            self._tessellation_indexes = ACVBO(GL_UNIFORM_BUFFER, 3, None, GL_STATIC_DRAW)  # type: ACVBO

    def init_uniform(self):
        self.update_uniform_triangle_number()
        self.update_uniform_about_tessellation()
        self.update_uniform_about_adjust_control_point_flag()

    def update_uniform_triangle_number(self):
        glProgramUniform1ui(self._gl_program_name, 0, int(self._controller.splited_triangle_number))

    def update_uniform_about_tessellation(self):
        glProgramUniform1ui(self._gl_program_name, 4,
                            int(self._controller.tessellated_point_number_pre_splited_triangle))
        glProgramUniform1ui(self._gl_program_name, 5,
                            int(self._controller.tessellated_triangle_number_pre_splited_triangle))
        if conf.IS_FAST_MODE:
            self._tessellation_aux.async_update(self._controller.tessellation_aux)
            self._tessellation_aux.gl_sync()
        self._tessellation_parameter.async_update(self._controller.tessellation_parameter)
        self._tessellation_parameter.gl_sync()
        self._tessellation_indexes.async_update(self._controller.tessellation_index)
        self._tessellation_indexes.gl_sync()

    def update_uniform_about_adjust_control_point_flag(self):
        if not conf.IS_FAST_MODE:
            glProgramUniform1i(self._gl_program_name, 6, 1 if self._controller.adjust_control_point else -1)

    def update_uniform_about_use_pn_triangle(self):
        if not conf.IS_FAST_MODE:
            glProgramUniform1i(self._gl_program_name, 1, 1 if self._controller.use_pn_normal_for_renderer else -1)

    def update_uniform_about_modify_range(self):
        modify_range = self._controller.get_modify_range().reshape((-1,))
        for i in range(len(modify_range)):
            glProgramUniform1i(self._gl_program_name, 7 + i, modify_range[i])
Exemplo n.º 9
0
    def __init__(self, has_texture, previous_controller, model, aux_controller: AuxController, controller=None):
        self.need_export_obj = False
        self._screen_shot = False
        self._screen_width = 0
        self._screen_height = 0
        self._time_number = -3
        self._time_total = 0
        self._aux_controller = aux_controller  # type: AuxController
        self.model = model
        self._previous_controller = previous_controller  # type: PreviousComputeControllerGPU
        self._controller = controller
        self._splited_triangle_number = -1

        self._tessellation_level = -1  # type: int
        self._final_tessellation_level = 0.02  # type: int
        self._tessellated_point_number_pre_splited_triangle = -1  # type: int
        self._tessellated_triangle_number_pre_splited_triangle = -1  # type: int
        self._tessellation_parameter = None  # type: list
        self._tessellation_index = None  # type: list
        self._tessellation_factor_changed = False  # type: bool
        self._splited_triangle_number_changed = False  # type: bool
        self._tessellation_aux = None

        if config.IS_UNIFORM_ADAPTIVE_TESSELLATION_FACTOR:
            self.init_tessellation_pattern_data(
                int(self._previous_controller.split_factor / self._final_tessellation_level))
        else:
            self.init_tessellation_pattern_data(10)

        self._need_deform = True  # type: bool
        self._need_update_uniform_about_b_spline = False

        self._need_update_show_splited_edge_flag = True
        self._splited_edge_visibility = False

        self._need_update_triangle_quality_flag = True
        self._show_quality = False

        self._need_update_normal_diff_flag = True
        self._show_normal_diff = False

        self._need_update_position_diff_flag = True
        self._show_position_diff = False

        self._need_update_adjust_control_point_flag = True
        self._adjust_control_point = True

        self._need_comparison = False

        self._need_update_show_original = True
        self._show_original = False

        self._need_update_use_pn_normal_for_renderer = True
        self._use_pn_normal_for_renderer = False

        self._need_update_show_real_flag = True
        self._show_real = False

        self._need_update_use_texture_flag = False
        self._has_texture = has_texture

        # vbo
        self._vertex_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 6, None, GL_DYNAMIC_COPY)  # type: ACVBO
        self._normal_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 7, None, GL_DYNAMIC_COPY)  # type: ACVBO
        self._index_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 8, None, GL_DYNAMIC_COPY)  # type: ACVBO
        if self.model.from_bezier:
            self._bezier_control_point_buffer = ACVBO(GL_SHADER_STORAGE_BUFFER, 25, None, GL_DYNAMIC_DRAW)
        self._model_vao = -1  # type: int
        self._original_model_vao = -1  # type: int

        self._parameter_in_BSpline_body_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 21, None, GL_DYNAMIC_DRAW)  # type: ACVBO

        if not conf.IS_FAST_MODE:
            self._tex_coord_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 23, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._parameter_in_splited_triangle_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 10, None,
                                                            GL_DYNAMIC_DRAW)  # type: ACVBO
            self._parameter_in_original_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 11, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._real_position_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 12, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._real_normal_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 13, None, GL_DYNAMIC_DRAW)  # type: ACVBO

            self._show_control_point = False
            self._control_point_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 15, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._control_point_index_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 16, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._control_point_vao = -1  # type: int

            self._show_normal = False
            self._show_normal_position_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 17, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._show_normal_normal_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 18, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._show_normal_vao = -1  # type: int

        # program
        self._deform_program = DeformComputeProgram(self) \
            .add_shader(
            DeformComputeShader(GL_COMPUTE_SHADER, add_compute_prefix('deform_compute_shader_oo.glsl'), self))

        self._renderer_program = ModelRendererShader(self) \
            .add_shader(ShaderWrap(GL_VERTEX_SHADER, add_renderer_prefix('vertex.glsl'))) \
            .add_shader(ShaderWrap(GL_FRAGMENT_SHADER, add_renderer_prefix('fragment.glsl')))  # type: ProgramWrap

        if not conf.IS_FAST_MODE:
            self._renderer_control_point_program = ProgramWrap() \
                .add_shader(ShaderWrap(GL_VERTEX_SHADER, add_renderer_prefix('control_points.v.glsl'))) \
                .add_shader(
                ShaderWrap(GL_FRAGMENT_SHADER, add_renderer_prefix('control_points.f.glsl')))  # type: ProgramWrap

            self._renderer_normal_program = ProgramWrap() \
                .add_shader(ShaderWrap(GL_VERTEX_SHADER, add_renderer_prefix('normal.v.glsl'))) \
                .add_shader(ShaderWrap(GL_FRAGMENT_SHADER, add_renderer_prefix('normal.f.glsl'))) \
                .add_shader(ShaderWrap(GL_GEOMETRY_SHADER, add_renderer_prefix('normal.g.glsl')))  # type: ProgramWrap
Exemplo n.º 10
0
class DeformAndDrawController:
    @property
    def final_tessellation_level(self):
        return self._final_tessellation_level

    def __init__(self, has_texture, previous_controller, model, aux_controller: AuxController, controller=None):
        self.need_export_obj = False
        self._screen_shot = False
        self._screen_width = 0
        self._screen_height = 0
        self._time_number = -3
        self._time_total = 0
        self._aux_controller = aux_controller  # type: AuxController
        self.model = model
        self._previous_controller = previous_controller  # type: PreviousComputeControllerGPU
        self._controller = controller
        self._splited_triangle_number = -1

        self._tessellation_level = -1  # type: int
        self._final_tessellation_level = 0.02  # type: int
        self._tessellated_point_number_pre_splited_triangle = -1  # type: int
        self._tessellated_triangle_number_pre_splited_triangle = -1  # type: int
        self._tessellation_parameter = None  # type: list
        self._tessellation_index = None  # type: list
        self._tessellation_factor_changed = False  # type: bool
        self._splited_triangle_number_changed = False  # type: bool
        self._tessellation_aux = None

        if config.IS_UNIFORM_ADAPTIVE_TESSELLATION_FACTOR:
            self.init_tessellation_pattern_data(
                int(self._previous_controller.split_factor / self._final_tessellation_level))
        else:
            self.init_tessellation_pattern_data(10)

        self._need_deform = True  # type: bool
        self._need_update_uniform_about_b_spline = False

        self._need_update_show_splited_edge_flag = True
        self._splited_edge_visibility = False

        self._need_update_triangle_quality_flag = True
        self._show_quality = False

        self._need_update_normal_diff_flag = True
        self._show_normal_diff = False

        self._need_update_position_diff_flag = True
        self._show_position_diff = False

        self._need_update_adjust_control_point_flag = True
        self._adjust_control_point = True

        self._need_comparison = False

        self._need_update_show_original = True
        self._show_original = False

        self._need_update_use_pn_normal_for_renderer = True
        self._use_pn_normal_for_renderer = False

        self._need_update_show_real_flag = True
        self._show_real = False

        self._need_update_use_texture_flag = False
        self._has_texture = has_texture

        # vbo
        self._vertex_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 6, None, GL_DYNAMIC_COPY)  # type: ACVBO
        self._normal_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 7, None, GL_DYNAMIC_COPY)  # type: ACVBO
        self._index_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 8, None, GL_DYNAMIC_COPY)  # type: ACVBO
        if self.model.from_bezier:
            self._bezier_control_point_buffer = ACVBO(GL_SHADER_STORAGE_BUFFER, 25, None, GL_DYNAMIC_DRAW)
        self._model_vao = -1  # type: int
        self._original_model_vao = -1  # type: int

        self._parameter_in_BSpline_body_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 21, None, GL_DYNAMIC_DRAW)  # type: ACVBO

        if not conf.IS_FAST_MODE:
            self._tex_coord_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 23, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._parameter_in_splited_triangle_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 10, None,
                                                            GL_DYNAMIC_DRAW)  # type: ACVBO
            self._parameter_in_original_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 11, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._real_position_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 12, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._real_normal_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 13, None, GL_DYNAMIC_DRAW)  # type: ACVBO

            self._show_control_point = False
            self._control_point_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 15, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._control_point_index_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 16, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._control_point_vao = -1  # type: int

            self._show_normal = False
            self._show_normal_position_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 17, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._show_normal_normal_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 18, None, GL_DYNAMIC_DRAW)  # type: ACVBO
            self._show_normal_vao = -1  # type: int

        # program
        self._deform_program = DeformComputeProgram(self) \
            .add_shader(
            DeformComputeShader(GL_COMPUTE_SHADER, add_compute_prefix('deform_compute_shader_oo.glsl'), self))

        self._renderer_program = ModelRendererShader(self) \
            .add_shader(ShaderWrap(GL_VERTEX_SHADER, add_renderer_prefix('vertex.glsl'))) \
            .add_shader(ShaderWrap(GL_FRAGMENT_SHADER, add_renderer_prefix('fragment.glsl')))  # type: ProgramWrap

        if not conf.IS_FAST_MODE:
            self._renderer_control_point_program = ProgramWrap() \
                .add_shader(ShaderWrap(GL_VERTEX_SHADER, add_renderer_prefix('control_points.v.glsl'))) \
                .add_shader(
                ShaderWrap(GL_FRAGMENT_SHADER, add_renderer_prefix('control_points.f.glsl')))  # type: ProgramWrap

            self._renderer_normal_program = ProgramWrap() \
                .add_shader(ShaderWrap(GL_VERTEX_SHADER, add_renderer_prefix('normal.v.glsl'))) \
                .add_shader(ShaderWrap(GL_FRAGMENT_SHADER, add_renderer_prefix('normal.f.glsl'))) \
                .add_shader(ShaderWrap(GL_GEOMETRY_SHADER, add_renderer_prefix('normal.g.glsl')))  # type: ProgramWrap

    def gl_init(self):
        self._model_vao = glGenVertexArrays(1)
        glBindVertexArray(self._model_vao)
        # set vertice attribute
        self._vertex_vbo.as_array_buffer(0, 4, GL_FLOAT)
        # set normal attribute
        self._normal_vbo.as_array_buffer(1, 4, GL_FLOAT)
        # specific index buffer
        self._index_vbo.as_element_array_buffer()

        if not conf.IS_FAST_MODE:
            self._tex_coord_vbo.as_array_buffer(6, 2, GL_FLOAT)
            # set tessellate parameter attribute
            self._parameter_in_splited_triangle_vbo.as_array_buffer(2, 4, GL_FLOAT)
            # set split parameter attribute
            self._parameter_in_original_vbo.as_array_buffer(3, 4, GL_FLOAT)
            self._real_normal_vbo.as_array_buffer(4, 4, GL_FLOAT)
            self._real_position_vbo.as_array_buffer(5, 4, GL_FLOAT)
        # unbind program
        glBindVertexArray(0)

        if not conf.IS_FAST_MODE:
            self._original_model_vao = glGenVertexArrays(1)  # type: int
            glBindVertexArray(self._original_model_vao)
            self._previous_controller.original_vertex_ssbo.as_array_buffer(0, 4, GL_FLOAT)
            self._previous_controller.original_normal_ssbo.as_array_buffer(1, 4, GL_FLOAT)
            self._previous_controller.original_tex_coord_ssbo.as_array_buffer(6, 2, GL_FLOAT)
            self._previous_controller.original_index_ssbo.as_element_array_buffer()
            glBindVertexArray(0)

            self._control_point_vao = glGenVertexArrays(1)
            glBindVertexArray(self._control_point_vao)
            self._control_point_vbo.as_array_buffer(0, 4, GL_FLOAT)
            self._control_point_index_vbo.as_element_array_buffer()
            glBindVertexArray(0)

            self._show_normal_vao = glGenVertexArrays(1)
            glBindVertexArray(self._show_normal_vao)
            self._show_normal_position_vbo.as_array_buffer(0, 4, GL_FLOAT)
            self._show_normal_normal_vbo.as_array_buffer(1, 4, GL_FLOAT)
            glBindVertexArray(0)

        self.gl_async_update_buffer_for_self()

        # init for texture
        texture_name = glGenTextures(1)

        glActiveTexture(GL_TEXTURE1)
        glEnable(GL_TEXTURE_2D)

        # "Bind" the newly created texture : all future texture functions will modify this texture
        glBindTexture(GL_TEXTURE_2D, texture_name)

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

        # image = DeformAndDrawController.load_texture_data('res/3d_model/rabbit_real/rabbit256.png')
        # image = DeformAndDrawController.load_texture_data('res/3d_model/ship/ship_texture.png')
        image = DeformAndDrawController.load_texture_data('res/colormap.png')
        # Give the image to OpenGL
        image_data = np.array(list(image.getdata()), dtype=np.uint8)
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.size[0], image.size[1],
                     0, GL_RGBA, GL_UNSIGNED_BYTE, image_data)
        glActiveTexture(GL_TEXTURE0)

    @staticmethod
    def load_texture_data(filename):
        return Image.open(filename)

    def gl_async_update_buffer_for_self(self):
        if self._vertex_vbo is not None:
            self._vertex_vbo.capacity = self.splited_triangle_number \
                                        * self.tessellated_point_number_pre_splited_triangle * VERTEX_SIZE
        if self._normal_vbo is not None:
            self._normal_vbo.capacity = self.splited_triangle_number \
                                        * self.tessellated_point_number_pre_splited_triangle * NORMAL_SIZE

        if self._index_vbo is not None:
            self._index_vbo.capacity = self.splited_triangle_number \
                                       * self.tessellated_triangle_number_pre_splited_triangle * PER_TRIANGLE_INDEX_SIZE

        if self._parameter_in_BSpline_body_vbo is not None:
            self._parameter_in_BSpline_body_vbo.capacity = self.splited_triangle_number \
                                                           * self.tessellated_point_number_pre_splited_triangle * VERTEX_SIZE

        if not conf.IS_FAST_MODE:
            if self._tex_coord_vbo is not None:
                self._tex_coord_vbo.capacity = self.splited_triangle_number \
                                               * self.tessellated_point_number_pre_splited_triangle * TEX_COORD_SIZE
            if self._parameter_in_splited_triangle_vbo is not None:
                self._parameter_in_splited_triangle_vbo.capacity = self.splited_triangle_number \
                                                                   * self.tessellated_point_number_pre_splited_triangle * VERTEX_SIZE
            if self._parameter_in_original_vbo is not None:
                self._parameter_in_original_vbo.capacity = self.splited_triangle_number \
                                                           * self.tessellated_point_number_pre_splited_triangle * VERTEX_SIZE
            if self._real_normal_vbo is not None:
                self._real_normal_vbo.capacity = self.splited_triangle_number \
                                                 * self.tessellated_point_number_pre_splited_triangle * NORMAL_SIZE
            if self._real_position_vbo is not None:
                self._real_position_vbo.capacity = self.splited_triangle_number \
                                                   * self.tessellated_point_number_pre_splited_triangle * VERTEX_SIZE

            if self._control_point_vbo is not None:
                self._control_point_vbo.capacity = self.splited_triangle_number * CONTROL_POINT_NUMBER * VERTEX_SIZE

            if self._control_point_index_vbo is not None:
                self._control_point_index_vbo.capacity = self.splited_triangle_number * CONTROL_POINT_TRIANGLE_NUMBER * PER_TRIANGLE_INDEX_SIZE

            if self._show_normal_position_vbo is not None:
                self._show_normal_position_vbo.capacity = self.splited_triangle_number * SHOW_NORMAL_POINT_NUMBER_PER_TRIANGLE * VERTEX_SIZE

            if self._show_normal_normal_vbo is not None:
                self._show_normal_normal_vbo.capacity = self.splited_triangle_number * SHOW_NORMAL_POINT_NUMBER_PER_TRIANGLE * NORMAL_SIZE

            if self.model.from_bezier and self._bezier_control_point_buffer is not None:
                self._bezier_control_point_buffer.async_update(self.model.bezier_control_points)

    def gl_sync_buffer(self):
        self._vertex_vbo.gl_sync()
        self._normal_vbo.gl_sync()
        self._index_vbo.gl_sync()
        self._parameter_in_BSpline_body_vbo.gl_sync()
        if not conf.IS_FAST_MODE:
            self._tex_coord_vbo.gl_sync()
            self._parameter_in_splited_triangle_vbo.gl_sync()
            self._parameter_in_original_vbo.gl_sync()
            self._real_normal_vbo.gl_sync()
            self._real_position_vbo.gl_sync()
            self._control_point_vbo.gl_sync()
            self._control_point_index_vbo.gl_sync()
            self._show_normal_position_vbo.gl_sync()
            self._show_normal_normal_vbo.gl_sync()
            self._previous_controller.original_index_ssbo.gl_sync()
            if self.model.from_bezier:
                self._bezier_control_point_buffer.gl_sync()

    def gl_deform(self, operator):
        if not self.need_deform:
            return
        operator()
        self._deform_program.use()
        if self._tessellation_factor_changed:
            self._deform_program.update_uniform_about_tessellation()
            self._tessellation_factor_changed = False
        if self._splited_triangle_number_changed:
            self._deform_program.update_uniform_triangle_number()
            self._splited_triangle_number_changed = False
        if self._need_update_adjust_control_point_flag:
            self._deform_program.update_uniform_about_adjust_control_point_flag()
            self._need_update_adjust_control_point_flag = False
        if self._need_update_use_pn_normal_for_renderer:
            self._deform_program.update_uniform_about_use_pn_triangle()
            self._need_update_use_pn_normal_for_renderer = False

        self._deform_program.update_uniform_about_modify_range()

        self._controller.add_time(GLUtil.gl_timing(lambda: glDispatchCompute(*self.group_size), "deformation", 3))

        self._need_deform = False
        glUseProgram(0)

    def gl_renderer(self, model_view_matrix: np.array, perspective_matrix: np.array, operator):
        self.gl_sync_buffer()
        self.gl_deform(operator)
        self._renderer_program.use()
        if self._need_update_show_splited_edge_flag:
            self._renderer_program.update_uniform_about_split_edge()
            self._need_update_show_splited_edge_flag = False

        if self._need_update_use_texture_flag:
            self._renderer_program.update_uniform_about_texture()
            self._need_update_use_texture_flag = False

        if self._need_update_show_original:
            self._renderer_program.update_uniform_about_show_original()
            self._need_update_show_original = False

        if self._need_update_triangle_quality_flag:
            self._renderer_program.update_uniform_about_triangle_quality()
            self._need_update_triangle_quality_flag = False

        if self._need_update_normal_diff_flag:
            self._renderer_program.update_uniform_about_normal_diff()
            self._need_update_normal_diff_flag = False

        if self._need_update_position_diff_flag:
            self._renderer_program.update_uniform_about_position_diff()
            self._need_update_position_diff_flag = False

        if self._need_update_show_real_flag:
            self._renderer_program.update_uniform_about_real()
            self._need_update_show_real_flag = False

        if self.need_export_obj:
            self.gl_export_obj()
            self.need_export_obj = False

        glEnable(GL_DEPTH_TEST)
        glEnable(GL_BLEND)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
        # common bind
        wvp_matrix = multiply(model_view_matrix, perspective_matrix)
        glUniformMatrix4fv(0, 1, GL_FALSE, wvp_matrix)
        glUniformMatrix4fv(1, 1, GL_FALSE, model_view_matrix)

        glActiveTexture(GL_TEXTURE1)
        if conf.IS_FAST_MODE:
            glBindVertexArray(self._model_vao)
        else:
            if self._show_original:
                glBindVertexArray(self._original_model_vao)
            else:
                glBindVertexArray(self._model_vao)

        if conf.IS_FAST_MODE or not self._show_control_point:
            number = int(self.splited_triangle_number * self.tessellated_triangle_number_pre_splited_triangle * 3)
            glDrawElements(GL_TRIANGLES, number, GL_UNSIGNED_INT, None)
        glActiveTexture(GL_TEXTURE0)
        glBindVertexArray(0)
        glUseProgram(0)

        if not conf.IS_FAST_MODE:
            if self._show_control_point:
                glBindVertexArray(self._control_point_vao)
                self._renderer_control_point_program.use()
                glUniformMatrix4fv(0, 1, GL_FALSE, wvp_matrix)
                number = int(self.splited_triangle_number * CONTROL_POINT_TRIANGLE_NUMBER * 3)
                glDrawElements(GL_TRIANGLES, number, GL_UNSIGNED_INT, None)
                glFinish()
                glBindVertexArray(0)
                glUseProgram(0)

            if self._show_normal:
                glBindVertexArray(self._show_normal_vao)
                self._renderer_normal_program.use()
                glUniformMatrix4fv(0, 1, GL_FALSE, wvp_matrix)
                glUniformMatrix4fv(1, 1, GL_FALSE, model_view_matrix)
                number = int(self.splited_triangle_number * 3)
                glDrawArrays(GL_TRIANGLES, 0, number)
                glFinish()
                glUseProgram(0)
                glBindVertexArray(0)
            if self._screen_shot:
                if self._screen_height > self._screen_width:
                    x = 0
                    y = (self._screen_height - self._screen_width) / 2
                    w = self._screen_width
                    h = self._screen_width
                else:
                    x = (self._screen_width - self._screen_height) / 2
                    y = 0
                    w = self._screen_height
                    h = self._screen_height
                image_data = glReadPixels(x, y, w, h, GL_RGB, GL_FLOAT)
                shape = image_data.shape
                print('save size', shape)
                i = 0
                while os.path.exists('sc%d.png' % i):
                    i += 1

                mpimg.imsave('sc%d.png' % i, image_data.reshape((shape[1], shape[0], shape[2])), origin='lower')
                self._screen_shot = False

        glDisable(GL_DEPTH_TEST)
        glDisable(GL_BLEND)
        if self._vertex_vbo.capacity == 0:
            return

        if not self._need_comparison:
            return
        self._need_comparison = False
        self.comparison()
        # self.compute_area(self._vertex_vbo, self._index_vbo)

    def gl_export_obj(self):
        positions = self._vertex_vbo.get_value(ctypes.c_float, (int(self._vertex_vbo.capacity / 4 / 4), 4))
        positions = [(round(x, 5) for x in y) for y in positions]
        aux = {}
        index_map = {}
        counter = 0
        new_position = []
        for i in range(len(positions)):
            l = tuple(positions[i])
            positions[i] = l
            if l not in aux:
                aux[l] = counter
                new_position.append(l)
                counter += 1
            index_map[i] = aux[l]
        indices = self._index_vbo.get_value(ctypes.c_int, (int(self._index_vbo.capacity / 4 / 3), 3))
        with open('volume.obj', mode='w') as f:
            for p in new_position:
                f.write('v ' + ' '.join([str(x) for x in p[:3]]) + '\n')

            for i in indices:
                points = [np.array(positions[x][:3]) for x in i]

                v01 = points[1] - points[0]
                v02 = points[2] - points[0]
                if np.dot(np.cross(v01, v02), points[0]) < 0:
                    i[0], i[1] = i[1], i[0]
                f.write('f ' + ' '.join([str(index_map[x] + 1) + '//' for x in i]) + '\n')
        copyfile('volume.obj', '/home/ac/volume.obj')

    def save_screen(self, w, h):
        self._screen_shot = True
        self._screen_width = w
        self._screen_height = h

    @property
    def splited_triangle_number(self):
        return self._splited_triangle_number

    def set_number_and_need_deform(self, number: int, need_deform: bool):
        self._need_deform = (self._need_deform or need_deform or number != self._splited_triangle_number)
        if number != self._splited_triangle_number:
            self._splited_triangle_number = number
            self.gl_async_update_buffer_for_self()
            self._splited_triangle_number_changed = True

    @property
    def splited_triangle_number_changed(self):
        return self._splited_triangle_number_changed

    @property
    def group_size(self):
        return [int(self.splited_triangle_number / 64) + 1, 1, 1]

    @property
    def tessellation_level(self):
        return self._tessellation_level

    def init_tessellation_pattern_data(self, tessellation_level):
        self._tessellation_level = int(tessellation_level)
        self._tessellated_point_number_pre_splited_triangle = (self._tessellation_level + 1) \
                                                              * (self._tessellation_level + 2) / 2
        self._tessellated_triangle_number_pre_splited_triangle = self._tessellation_level * self._tessellation_level
        self._tessellation_parameter = []  # type: list
        u = self._tessellation_level
        for i in range(self._tessellation_level + 1):
            v = self._tessellation_level - u
            for j in range(i + 1):
                self._tessellation_parameter.append([u / self._tessellation_level, v / self._tessellation_level,
                                                     (self._tessellation_level - u - v) / self._tessellation_level, 0])
                v -= 1
            u -= 1

        rfactorialt = [0.166666666,
                       0.5, 0.5,
                       0.5, 1, 0.5,
                       0.166666666, 0.5, 0.5, 0.166666666]

        self._tessellation_aux = []
        for p in self._tessellation_parameter:
            index = 0
            for i in range(3, -1, -1):
                for j in range(3 - i, -1, -1):
                    k = 3 - i - j
                    t = 6 * rfactorialt[index] * power(p[0], i) * power(p[1], j) * power(p[2], k)
                    index += 1
                    self._tessellation_aux.append(t)
            self._tessellation_aux.append(0)
            self._tessellation_aux.append(0)

        self._tessellation_index = []  # type: list
        for i in range(self._tessellation_level):
            start = int((i + 1) * (i + 2) / 2)
            prev = [start, start + 1, start - 1 - i]
            self._tessellation_index.append(prev)
            for j in range(i * 2):
                next_index = [prev[2], prev[2] + 1, prev[1]]
                if j % 2 == 0:
                    self._tessellation_index.append([next_index[1], next_index[0], next_index[2]])
                else:
                    self._tessellation_index.append(next_index)
                prev = next_index
        self._tessellation_index = [x + [0] for x in self._tessellation_index]
        self._tessellation_factor_changed = True

    @property
    def tessellated_point_number_pre_splited_triangle(self):
        return self._tessellated_point_number_pre_splited_triangle

    @property
    def tessellated_triangle_number_pre_splited_triangle(self):
        return self._tessellated_triangle_number_pre_splited_triangle

    @property
    def tessellation_parameter(self):
        return np.array(self._tessellation_parameter, dtype=np.float32)

    @property
    def tessellation_aux(self):
        return np.array(self._tessellation_aux, dtype=np.float32)

    @property
    def tessellation_index(self):
        return np.array(self._tessellation_index, dtype=np.uint32)

    @property
    def need_deform(self):
        return self._need_deform

    @property
    def splited_edge_visibility(self):
        return self._splited_edge_visibility

    @property
    def show_quality(self):
        return self._show_quality

    @property
    def show_normal_diff(self):
        return self._show_normal_diff

    @property
    def show_position_diff(self):
        return self._show_position_diff

    @property
    def adjust_control_point(self):
        return self._adjust_control_point

    def set_show_normal_diff(self, v):
        self._show_normal_diff = v
        self._need_update_normal_diff_flag = True

    def set_show_position_diff(self, v):
        self._show_position_diff = v
        self._need_update_position_diff_flag = True

    def set_splited_edge_visibility(self, v):
        self._splited_edge_visibility = v
        self._need_update_show_splited_edge_flag = True

    def set_show_triangle_quality(self, v):
        self._show_quality = v
        self._need_update_triangle_quality_flag = True

    def set_show_real(self, is_show):
        self._show_real = is_show
        self._need_update_show_real_flag = True

    def set_show_original(self, is_show):
        self._show_original = is_show
        self._need_update_show_original = True

    def use_texture(self, b):
        self._has_texture = b
        self._need_update_use_texture_flag = True

    def set_adjust_control_point(self, v):
        self._adjust_control_point = v
        self._need_update_adjust_control_point_flag = True
        self._need_deform = True

    @need_deform.setter
    def need_deform(self, value):
        self._need_deform = value

    def set_tessellation_factor(self, tessellation_factor):
        self.init_tessellation_pattern_data(tessellation_factor)
        self.gl_async_update_buffer_for_self()
        self._need_deform = True

    @property
    def show_control_point(self):
        return self._show_control_point

    @show_control_point.setter
    def show_control_point(self, is_show):
        self._show_control_point = is_show

    @property
    def show_normal(self):
        return self._show_normal

    @show_normal.setter
    def show_normal(self, is_show):
        self._show_normal = is_show

    @property
    def show_real(self):
        return self._show_real

    def set_need_comparison(self):
        self._need_comparison = True

    @staticmethod
    def comparison_helper(vbo1: ACVBO, vbo2: ACVBO, fun):
        point_number = int(vbo1.capacity / 16)
        acc = 0
        max_e = -1
        es = []
        for i, j in zip(vbo1.get_value(ctypes.c_float, (point_number, 4)),
                        vbo2.get_value(ctypes.c_float, (point_number, 4))):
            e = fun(i, j)
            max_e = max(e, max_e)
            acc += e
            es.append(e)

        average = acc / point_number
        acc = 0
        for e in es:
            acc += ((e - average) ** 2)
        standard_deviation = (acc / point_number) ** 0.5
        return average, max_e, standard_deviation

    def comparison(self):
        dr1 = DeformAndDrawController.comparison_helper(self._vertex_vbo, self._real_position_vbo,
                                                        lambda i, j: sqrt(
                                                            reduce(lambda p, x: p + x,
                                                                   [e * e for e in (i - j)[:3]],
                                                                   0)))

        def fun(i, j):
            cos_value = np.dot(i[:3], j[:3])
            if cos_value > 1:
                cos_value = 1
            elif cos_value < -1:
                cos_value = -1
            return acos(cos_value) / pi * 180

        dr2 = DeformAndDrawController.comparison_helper(self._normal_vbo, self._real_normal_vbo, fun)
        self._controller.add_diff_result((dr1, dr2))

    @property
    def has_texture(self):
        return self._has_texture

    @property
    def show_original(self):
        return self._show_original

    @property
    def use_pn_normal_for_renderer(self):
        return self._use_pn_normal_for_renderer

    @use_pn_normal_for_renderer.setter
    def use_pn_normal_for_renderer(self, use):
        self._use_pn_normal_for_renderer = use
        self._need_update_use_pn_normal_for_renderer = True
        self._need_deform = True

    def get_modify_range(self):
        return self._aux_controller.get_modify_range()

    def get_tessed_triangles_number(self) -> int:
        res = self._tessed_triangle_counter_acbo.get_value(ctypes.c_uint32)[0]
        return res

    def export_obj(self):
        self.need_export_obj = True
Exemplo n.º 11
0
class AuxController:
    def __init__(self, size: list):
        # check input
        if len(size) != 3:
            raise Exception('b spline body size number error')
        if any(i < 0 for i in size):
            raise Exception('b spline body size < 0, error')

        # init b-spline body
        self._b_spline_body = BSplineBody(*size)  # type: BSplineBody

        # init shader program
        self._renderer_program = ProgramWrap().add_shader(ShaderWrap(GL_VERTEX_SHADER, add_prefix('aux.v.glsl'))) \
            .add_shader(ShaderWrap(GL_FRAGMENT_SHADER, add_prefix('aux.f.glsl')))  # type: ProgramWrap

        # init buffer
        self._control_point_position_vbo = ACVBO(GL_ARRAY_BUFFER, -1, None, GL_DYNAMIC_DRAW)  # type: ACVBO
        if conf.IS_FAST_MODE:
            self._control_point_for_sample_ubo = ACVBO(GL_SHADER_STORAGE_BUFFER, 15, None,
                                                       GL_DYNAMIC_DRAW)  # type: ACVBO
        else:
            self._control_point_for_sample_ubo = ACVBO(GL_UNIFORM_BUFFER, 1, None, GL_DYNAMIC_DRAW)  # type: ACVBO
        self._b_spline_body_info_ubo = ACVBO(GL_UNIFORM_BUFFER, 0, None, GL_STATIC_DRAW)  # type: ACVBO
        self._selected_counter_acbo = ACVBO(GL_ATOMIC_COUNTER_BUFFER, 1, None, GL_DYNAMIC_DRAW)
        self._vao_control_point = -1  # type: int
        self._normal_control_mode = False  # type: bool
        self._pick_region = None  # type: ACRect
        self._control_points_changed = True  # type: bool
        self._direct_control_point = []  # type:  list
        self._intersect_point_parameter = None

        # init compute select point shader program
        self._select_point_program = ProgramWrap() \
            .add_shader(ShaderWrap(GL_COMPUTE_SHADER, add_compute_prefix('select_point.glsl')))
        self._intersect_result_vbo = ACVBO(GL_SHADER_STORAGE_BUFFER, 20, None, GL_DYNAMIC_DRAW)  # type: ACVBO
        self._need_select_point = False
        self._select_argument = None

        self._delta_for_dffd = [0, 0, 0]

    def change_size(self, size):
        # check input
        if len(size) != 3:
            raise Exception('b spline body size number error')
        if any(i < 0 for i in size):
            raise Exception('b spline body size < 0, error')
        self._b_spline_body = BSplineBody(*size)  # type: BSplineBody
        self.async_upload_to_gpu()

    def gl_init(self):
        # init vao
        self._vao_control_point = glGenVertexArrays(1)
        glBindVertexArray(self._vao_control_point)
        self._control_point_position_vbo.as_array_buffer(0, 4, GL_FLOAT)
        glBindVertexArray(0)

        # upload_to_gpu
        self.async_upload_to_gpu()

    def async_upload_to_gpu(self):
        self._control_point_position_vbo.async_update(self.get_control_point_data())
        self._control_point_for_sample_ubo.async_update(self._b_spline_body.get_control_point_for_sample())
        self._b_spline_body_info_ubo.async_update(self._b_spline_body.get_info())

    def gl_sync_buffer_for_self(self):
        self._control_point_position_vbo.gl_sync()

    def gl_sync_buffer_for_previous_computer(self):
        self._b_spline_body_info_ubo.gl_sync()

    def gl_sync_buffer_for_deformation(self):
        def op():
            self._control_point_for_sample_ubo.gl_sync()
            self._b_spline_body_info_ubo.gl_sync()

        GLUtil.gl_timing(op, 'copy control to gpu', 3)

    def gl_draw(self, model_view_matrix: np.array, perspective_matrix: np.array):
        glEnable(GL_DEPTH_TEST)
        glEnable(GL_PROGRAM_POINT_SIZE)
        self._renderer_program.use()
        glBindVertexArray(self._vao_control_point)
        self.gl_pick_control_point(model_view_matrix, perspective_matrix)
        glFinish()
        self.gl_sync_buffer_for_self()
        self.gl_draw_control_points(model_view_matrix, perspective_matrix)
        glFinish()
        glBindVertexArray(0)
        glUseProgram(0)
        self.gl_select_point_gpu()
        glFinish()

    def gl_draw_control_points(self, model_view_matrix, perspective_matrix):
        glUniformMatrix4fv(0, 1, GL_FALSE, multiply(model_view_matrix, perspective_matrix))
        glDrawArrays(GL_POINTS, 0, self.get_control_point_number())

    def gl_pick_control_point(self, model_view_matrix, perspective_matrix):
        if not self._pick_region:
            return
        self._b_spline_body.reset_hit_record()
        glSelectBuffer(1024)
        glRenderMode(GL_SELECT)
        glInitNames()
        glPushName(0)
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        w = max(10, self._pick_region.w)
        h = max(10, self._pick_region.h)
        gluPickMatrix((self._pick_region.x1 + self._pick_region.x2) / 2,
                      (self._pick_region.y1 + self._pick_region.y2) / 2,
                      w, h,
                      glGetDoublev(GL_VIEWPORT))
        glUniformMatrix4fv(0, 1, GL_FALSE, multiply(model_view_matrix,
                                                    multiply(perspective_matrix,
                                                             glGetDoublev(GL_PROJECTION_MATRIX))))
        for i in range(self._b_spline_body.get_control_point_number()):
            glLoadName(i)
            glDrawArrays(GL_POINTS, i, 1)
        hit_info = glRenderMode(GL_RENDER)
        for r in hit_info:
            for select_name in r.names:
                self._b_spline_body.hit_point(select_name)
        self._control_point_position_vbo.async_update(self.get_control_point_data())
        self._pick_region = None

    def pick_control_point(self, region: ACRect):
        self._pick_region = region

    def move_selected_control_points(self, xyz):
        self._b_spline_body.move([d / 10 for d in xyz])
        self._control_point_position_vbo.async_update(self.get_control_point_data())
        self._control_point_for_sample_ubo.async_update(self._b_spline_body.get_control_point_for_sample())
        self._control_points_changed = True

    def rotate_selected_control_points(self, m):
        self._b_spline_body.rotate(m)
        self._control_point_position_vbo.async_update(self.get_control_point_data())
        self._control_point_for_sample_ubo.async_update(self._b_spline_body.get_control_point_for_sample())
        self._control_points_changed = True

    def get_control_point_data(self):
        if self._normal_control_mode:
            return self._b_spline_body.control_points
        else:
            return np.array(self._direct_control_point, dtype='f4')

    def get_normal_control_point_data(self):
        return self._b_spline_body.normal_control_points

    def get_control_point_number(self):
        if self._normal_control_mode:
            return self._b_spline_body.get_control_point_number()
        else:
            return len(self._direct_control_point)

    def get_control_point_for_sample(self):
        return self._b_spline_body.get_control_point_for_sample()

    def get_cage_size(self) -> list:
        return self._b_spline_body.get_cage_size()

    def change_control_point_number(self, u, v, w):
        self._b_spline_body.change_control_point_number(u, v, w)
        self.async_upload_to_gpu()

    def change_control_point_order(self, order):
        self._b_spline_body.change_control_point_order(order)
        self.async_upload_to_gpu()

    @property
    def b_spline_body(self):
        return self._b_spline_body

    @property
    def is_normal_control_point_mode(self):
        return self._normal_control_mode

    @is_normal_control_point_mode.setter
    def is_normal_control_point_mode(self, v):
        self._normal_control_mode = v
        if self._normal_control_mode:
            self.clear_all_direct_control_point()
        self._control_point_position_vbo.async_update(self.get_control_point_data())

    def add_direct_control_point(self, intersect_point):
        if intersect_point is not None:
            self._direct_control_point = [np.append(intersect_point, 0)]
            self._control_point_position_vbo.async_update(self.get_control_point_data())

    def clear_dst_direct_control_point(self):
        self._direct_control_point = self._direct_control_point[:1]
        self._b_spline_body.save_control_point_position()
        self._control_point_position_vbo.async_update(self.get_control_point_data())

    def clear_all_direct_control_point(self):
        self._direct_control_point.clear()
        self._delta_for_dffd = [0, 0, 0]
        self._b_spline_body.save_control_point_position()
        self._control_point_position_vbo.async_update(self.get_control_point_data())

    @property
    def normal_control_mode(self):
        return self._normal_control_mode

    def move_direct_control_point(self, direction):
        self._b_spline_body.move_dffd(self._intersect_point_parameter, direction)
        target_point = np.append(self._direct_control_point[0][:3] + direction, 1)
        if len(self._direct_control_point) <= 1:
            self._direct_control_point.append(target_point)
        else:
            self._direct_control_point[1] = target_point
        self._control_point_position_vbo.async_update(self.get_control_point_data())
        self._control_point_for_sample_ubo.async_update(self._b_spline_body.get_control_point_for_sample())
        self._control_points_changed = True

    def move_direct_control_point_delta(self, direction):
        self._delta_for_dffd = [x + y for x, y in zip(self._delta_for_dffd, direction)]
        self._b_spline_body.move_dffd(self._intersect_point_parameter, self._delta_for_dffd)
        target_point = np.append(self._direct_control_point[0][:3] + self._delta_for_dffd, 1)
        if len(self._direct_control_point) <= 1:
            self._direct_control_point.append(target_point)
        else:
            self._direct_control_point[1] = target_point
        self._control_point_position_vbo.async_update(self.get_control_point_data())
        self._control_point_for_sample_ubo.async_update(self._b_spline_body.get_control_point_for_sample())
        self._control_points_changed = True

    def is_direct_control_point_selected(self):
        return len(self._direct_control_point) != 0

    def gl_select_point_gpu(self):
        if not self._need_select_point:
            return
        self._selected_counter_acbo.async_update(np.array([0], dtype=np.uint32))
        self._selected_counter_acbo.gl_sync()
        start_point, direction, triangle_number = self._select_argument
        self._intersect_result_vbo.gl_sync()
        self._select_point_program.use()
        glUniform1ui(0, int(triangle_number))
        glUniform3f(1, start_point[0], start_point[1], start_point[2])
        glUniform3f(2, direction[0], direction[1], direction[2])
        glDispatchCompute(*self.group_size)
        selected_triangle_number = self._selected_counter_acbo.get_value(ctypes.c_uint32)[0]
        res = self._intersect_result_vbo.get_value(ctypes.c_float, (selected_triangle_number, 4))
        closet = [0, 0, 0, 9999999]
        for r in res:
            if r[3] < closet[3]:
                closet = r
        self._need_select_point = False
        if closet[3] != 9999999 and closet[3] > 0:
            self.add_direct_control_point(start_point + closet[3] * direction)
            self._intersect_point_parameter = np.array(closet[:3], dtype='f4')

    def select_point_gpu(self, start_point, direction, triangle_number):
        self._need_select_point = True
        self._intersect_result_vbo.capacity = triangle_number * 16
        self._select_argument = [np.array(start_point).reshape((4,))[:3], np.array(direction).reshape((4,))[:3],
                                 triangle_number]

    @property
    def group_size(self):
        return [int(self._select_argument[2] / 512 + 1), 1, 1]

    def set_control_points(self, control_points):
        self._b_spline_body.change_control_points(control_points)
        self._control_point_position_vbo.async_update(self.get_control_point_data())
        self._control_point_for_sample_ubo.async_update(self._b_spline_body.get_control_point_for_sample())
        self._control_points_changed = True

    def get_control_point_str(self):
        return '_'.join([str(x) for x in self._b_spline_body.control_point_number])

    def get_bspline_body_size(self):
        return self._b_spline_body.step

    def get_modify_range(self):
        return self._b_spline_body.modify_range