q3dviewer 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

q3dviewer/glwidget.py

@@ -0,0 +1,131 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from PySide6 import QtCore
+from PySide6.QtWidgets import QWidget, QComboBox, QVBoxLayout, QHBoxLayout, QSizePolicy, QSpacerItem, QLabel, QLineEdit, QCheckBox
+from PySide6.QtGui import QKeyEvent, QVector3D, QRegularExpressionValidator
+from PySide6.QtCore import QRegularExpression
+from OpenGL.GL import *
+import numpy as np
+from q3dviewer.base_glwidget import BaseGLWidget
+
+class SettingWindow(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.combo_items = QComboBox()
+        self.combo_items.currentIndexChanged.connect(self.on_combo_selection)
+        main_layout = QVBoxLayout()
+        self.stretch = QSpacerItem(
+            10, 10, QSizePolicy.Minimum, QSizePolicy.Expanding)
+        main_layout.addWidget(self.combo_items)
+        self.layout = QVBoxLayout()
+        self.layout.addItem(self.stretch)
+        main_layout.addLayout(self.layout)
+        self.setLayout(main_layout)
+        self.setWindowTitle("Setting Window")
+        self.setGeometry(200, 200, 300, 200)
+        self.items = {}
+
+    def add_setting(self, name, item):
+        self.items.update({name: item})
+        self.combo_items.addItem("%s(%s)" % (name, item.__class__.__name__))
+
+    def clear_setting(self):
+        while self.layout.count():
+            child = self.layout.takeAt(0)
+            if child.widget():
+                child.widget().deleteLater()
+
+    def on_combo_selection(self, index):
+        self.layout.removeItem(self.stretch)
+        # remove all setting of previous widget
+        self.clear_setting()
+
+        key = list(self.items.keys())
+        item = self.items[key[index]]
+        if hasattr(item, "add_setting"):
+            item.add_setting(self.layout)
+            self.layout.addItem(self.stretch)
+        else:
+            print("%s: No setting." % (item.__class__.__name__))
+
+
+class GLWidget(BaseGLWidget):
+    def __init__(self):
+        self.followed_name = 'none'
+        self.named_items = {}
+        self.color_str = '#000000'
+        self.followable_item_name = ['none']
+        self.setting_window = SettingWindow()
+        self.enable_show_center = True
+        super(GLWidget, self).__init__()
+
+    def keyPressEvent(self, ev: QKeyEvent):
+        if ev.key() == QtCore.Qt.Key_M:  # setting meun
+            print("Open setting windows")
+            self.open_setting_window()
+        super().keyPressEvent(ev)
+
+    def on_followable_selection(self, index):
+        self.followed_name = self.followable_item_name[index]
+
+    def update(self):
+        if self.followed_name != 'none':
+            pos = self.named_items[self.followed_name].T[:3, 3]
+            self.opts['center'] = QVector3D(pos[0], pos[1], pos[2])
+        super().update()
+
+    def add_setting(self, layout):
+        label_color = QLabel("Set background color:")
+        layout.addWidget(label_color)
+        color_edit = QLineEdit()
+        color_edit.setToolTip("'using hex color, i.e. #FF4500")
+        color_edit.setText(self.color_str)
+        color_edit.textChanged.connect(self.set_bg_color)
+        regex = QRegularExpression(r"^#[0-9A-Fa-f]{6}$")
+        validator = QRegularExpressionValidator(regex)
+        color_edit.setValidator(validator)
+        layout.addWidget(color_edit)
+        
+        label_focus = QLabel("Set Focus:")
+        combo_focus = QComboBox()
+        for name in self.followable_item_name:
+            combo_focus.addItem(name)
+        combo_focus.currentIndexChanged.connect(self.on_followable_selection)
+        layout.addWidget(label_focus)
+        layout.addWidget(combo_focus)
+
+        checkbox_show_center = QCheckBox("Show Center Point")
+        checkbox_show_center.setChecked(self.enable_show_center)
+        checkbox_show_center.stateChanged.connect(self.change_show_center)
+        layout.addWidget(checkbox_show_center)
+
+    def set_bg_color(self, color_str):
+        try:
+            color_flat = int(color_str[1:], 16)
+            red = (color_flat >> 16) & 0xFF
+            green = (color_flat >> 8) & 0xFF
+            blue = color_flat & 0xFF
+            self.color_str = color_str
+            self.set_color([red, green, blue, 0])
+        except ValueError:
+            return
+
+    def add_item_with_name(self, name, item):
+        self.named_items.update({name: item})
+        if (item.__class__.__name__ == 'AxisItem'):
+            self.followable_item_name.append(name)
+        self.setting_window.add_setting(name, item)
+        super().add_item(item)
+
+    def open_setting_window(self):
+        if self.setting_window.isVisible():
+            self.setting_window.raise_()
+
+        else:
+            self.setting_window.show()
+
+    def change_show_center(self, state):
+        self.enable_show_center = state

q3dviewer/shaders/cloud_frag.glsl

@@ -0,0 +1,28 @@
+/*
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+*/
+
+#version 330 core
+
+uniform int point_type;
+
+in vec4 color;
+
+out vec4 finalColor;
+
+void main()
+{
+    // only do this when point_type is sphere
+    if (point_type == 2)
+    {
+        vec2 coord = gl_PointCoord * 2.0 - vec2(1.0); // Map [0,1] to [-1,1]
+        float distance = dot(coord, coord); // Squared distance
+
+        // Discard fragments outside the circle (radius = 1.0)
+        if (distance > 1.0)
+            discard;
+    }
+
+    finalColor = color;
+}

q3dviewer/shaders/cloud_vert.glsl

@@ -0,0 +1,72 @@
+/*
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+*/
+
+#version 330 core
+
+layout (location = 0) in vec3 position;
+layout (location = 1) in uint value;
+
+uniform mat4 view_matrix;
+uniform mat4 projection_matrix;
+uniform float alpha = 1;
+uniform int color_mode = 0;
+uniform int flat_rgb = 0;
+uniform float vmin = 0;
+uniform float vmax = 255;
+uniform float focal = 1000;
+uniform int point_type = 0; // 0 pixel, 1 flat square, 2 sphere
+uniform float point_size = 0.01;  // World size for each point (meter)
+out vec4 color;
+
+vec3 getRainbowColor(uint value_raw) {
+    float range = vmax - vmin;
+    float value = 1.0 - (float(value_raw) - vmin) / range;
+    value = clamp(value, 0.0, 1.0);
+    float hue = value * 5.0 + 1.0;
+    int i = int(floor(hue));
+    float f = hue - float(i);
+    if (mod(i, 2) == 0) f = 1.0 - f;
+    float n = 1.0 - f;
+
+    vec3 color;
+    if (i <= 1) color = vec3(n, 0.0, 1.0);
+    else if (i == 2) color = vec3(0.0, n, 1.0);
+    else if (i == 3) color = vec3(0.0, 1.0, n);
+    else if (i == 4) color = vec3(n, 1.0, 0.0);
+    else color = vec3(1.0, n, 0.0);
+    return color;
+}
+
+void main()
+{
+    vec4 pw = vec4(position, 1.0);
+    vec4 pc = view_matrix * pw;
+    gl_Position = projection_matrix * pc;
+
+    // Calculate point size in pixels based on distance
+    if (point_type == 0)
+        gl_PointSize = int(point_size);
+    else
+        gl_PointSize = point_size / gl_Position.w * focal;
+    vec3 c = vec3(1.0, 1.0, 1.0);
+    if (color_mode == 1)
+    {
+        uint intensity = value >> 24;
+        c = getRainbowColor(intensity);
+    }
+    else if(color_mode == 2)
+    {
+        c.z = float(value & uint(0x000000FF))/255.;
+        c.y = float((value & uint(0x0000FF00)) >> 8)/255.;
+        c.x = float((value & uint(0x00FF0000)) >> 16)/255.;
+    }
+    else
+    {
+        c.z = float( uint(flat_rgb) & uint(0x000000FF))/255.;
+        c.y = float((uint(flat_rgb) & uint(0x0000FF00)) >> 8)/255.;
+        c.x = float((uint(flat_rgb) & uint(0x00FF0000)) >> 16)/255.;
+    }
+    color = vec4(c, alpha);
+}

q3dviewer/shaders/gau_frag.glsl

@@ -0,0 +1,42 @@
+/*
+this file is modified from GaussianSplattingViewer licensed under the MIT License.
+see https://github.com/limacv/GaussianSplattingViewer/blob/main/shaders/gau_frag.glsl
+*/
+
+#version 430 core
+
+in vec3 color;
+in float alpha;
+in vec3 cinv2d;
+in vec2 d_pix;  // u - pix
+
+uniform int  render_mod = 1;
+
+out vec4 final_color;
+
+void main()
+{
+    if (alpha < 0.001)
+        discard;
+    float maha_dist = cinv2d.x * d_pix.x * d_pix.x + cinv2d.z * d_pix.y * d_pix.y + 2 * cinv2d.y * d_pix.x * d_pix.y;
+    if (maha_dist < 0.f)
+        discard;
+
+    float g = exp(- 0.5 * maha_dist);
+    float alpha_prime = min(0.99f, alpha * g);
+    if (alpha_prime < 1.f / 255.f)
+        discard;
+    final_color = vec4(color, alpha_prime);
+
+    if (render_mod == 1)
+    {
+        final_color.a = final_color.a > 0.3 ? 1 : 0;
+        final_color.rgb = final_color.rgb * g;
+    }
+    else if (render_mod == 2)
+    {
+        final_color.a = final_color.a > 0.3 ? 1 - final_color.a: 0;
+    }
+    
+
+}

q3dviewer/shaders/gau_prep.glsl

@@ -0,0 +1,249 @@
+/*
+We proprocess gaussian using compute shader.
+this file is modified from GaussianSplattingViewer licensed under the MIT License.
+see https://github.com/limacv/GaussianSplattingViewer/blob/main/shaders/gau_vert.glsl
+*/
+
+#version 430 core
+
+layout(local_size_x = 256, local_size_y = 1, local_size_z = 1) in;
+
+
+//https://en.wikipedia.org/wiki/Table_of_spherical_harmonics
+#define SH_C0_0  0.28209479177387814  // Y0,0:  1/2*sqrt(1/pi)       plus
+#define SH_C1_0  -0.4886025119029199  // Y1,-1: sqrt(3/(4*pi))       minus
+#define SH_C1_1  0.4886025119029199   // Y1,0:  sqrt(3/(4*pi))       plus
+#define SH_C1_2  -0.4886025119029199  // Y1,1:  sqrt(3/(4*pi))       minus
+#define SH_C2_0  1.0925484305920792   // Y2,-2: 1/2 * sqrt(15/pi)    plus
+#define SH_C2_1  -1.0925484305920792  // Y2,-1: 1/2 * sqrt(15/pi)    minus
+#define SH_C2_2  0.31539156525252005  // Y2,0:  1/4*sqrt(5/pi)       plus
+#define SH_C2_3  -1.0925484305920792  // Y2,1:  1/2*sqrt(15/pi)      minus
+#define SH_C2_4  0.5462742152960396   // Y2,2:  1/4*sqrt(15/pi)      plus
+#define SH_C3_0  -0.5900435899266435  // Y3,-3: 1/4*sqrt(35/(2*pi))  minus
+#define SH_C3_1  2.890611442640554    // Y3,-2: 1/2*sqrt(105/pi)     plus
+#define SH_C3_2  -0.4570457994644658  // Y3,-1: 1/4*sqrt(21/(2*pi))  minus
+#define SH_C3_3  0.3731763325901154   // Y3,0:  1/4*sqrt(7/pi)       plus
+#define SH_C3_4  -0.4570457994644658  // Y3,1:  1/4*sqrt(21/(2*pi))  minus
+#define SH_C3_5  1.445305721320277    // Y3,2:  1/4*sqrt(105/pi)     plus
+#define SH_C3_6  -0.5900435899266435  // Y3,3:  1/4*sqrt(35/(2*pi))  minus
+
+
+#define OFFSET_DATA_POS 0
+#define OFFSET_DATA_ROT 3
+#define OFFSET_DATA_SCALE 7
+#define OFFSET_DATA_ALPHA 10
+#define OFFSET_DATA_SH 11
+
+#define OFFSET_PREP_U 0
+#define OFFSET_PREP_COVINV 3
+#define OFFSET_PREP_COLOR 6
+#define OFFSET_PREP_AREA 9
+#define OFFSET_PREP_ALPHA 11
+#define DIM_PREP 12
+
+// 12 float
+
+layout (std430, binding=0) buffer GaussianData {
+	float gs_data[];
+};
+
+layout (std430, binding=2) buffer GaussianDepth {
+	float depth[];
+};
+
+layout (std430, binding=3) buffer GaussianPrep {
+	float gs_prep[];
+};
+
+uniform mat4 view_matrix;
+uniform mat4 projection_matrix;
+uniform vec2 focal;
+uniform int  sh_dim;
+uniform int  gs_num;
+
+mat3 computeCov3D(vec3 scale, vec4 q)
+{
+    mat3 S = mat3(0.f);
+    S[0][0] = scale.x;
+	S[1][1] = scale.y;
+	S[2][2] = scale.z;
+	float w = q.x;
+	float x = q.y;
+	float y = q.z;
+	float z = q.w;
+
+	// In GLSL (OpenGL Shading Language), matrices are generally represented in column-major order
+	mat3 R = mat3(
+		1.f - 2.f * (y * y + z * z), 2.f * (x * y + w * z), 2.f * (x * z - w * y),
+		2.f * (x * y - w * z), 1.f - 2.f * (x * x + z * z), 2.f * (y * z + w * x),
+		2.f * (x * z + w * y), 2.f * (y * z - w * x), 1.f - 2.f * (x * x + y * y)
+	);
+
+    mat3 M = R * S;
+    mat3 Sigma = M * transpose(M);
+    return Sigma;
+}
+
+vec3 computeCov2D(vec4 pc, float focal_x, float focal_y, mat3 cov3D, mat4 viewmatrix)
+{
+	float z2 = pc.z * pc.z;
+    mat3 J = mat3(
+        focal_x/pc.z,      0.0f,                   0,
+		0.0f,              focal_y / pc.z,         0,
+		-(focal_x*pc.x)/z2,-(focal_y * pc.y) / z2, 0);
+    mat3 W = mat3(viewmatrix);
+    mat3 T = J * W;
+
+    mat3 cov = T * cov3D * transpose(T);
+
+	cov[0][0] += 0.3f;
+	cov[1][1] += 0.3f;
+    return vec3(cov[0][0], cov[0][1], cov[1][1]);
+}
+
+vec3 get_vec3(int offset)
+{
+	return vec3(gs_data[offset], gs_data[offset + 1], gs_data[offset + 2]);
+}
+
+vec4 get_vec4(int offset)
+{
+	return vec4(gs_data[offset], gs_data[offset + 1], gs_data[offset + 2], gs_data[offset + 3]);
+}
+
+void set_prep_vec3(int offset, vec3 d)
+{
+	gs_prep[offset] = d.x;
+	gs_prep[offset + 1] = d.y;
+	gs_prep[offset + 2] = d.z;
+}
+
+void set_prep_vec2(int offset, vec2 d)
+{
+	gs_prep[offset] = d.x;
+	gs_prep[offset + 1] = d.y;
+}
+
+void set_prep_vec1(int offset, float d)
+{
+	gs_prep[offset] = d.x;
+}
+
+vec3 computeColor(int sh_offset, vec3 ray_dir)
+{
+	vec3 c = SH_C0_0 * get_vec3(sh_offset);
+	
+	if (sh_dim > 3)  // 1 * 3
+	{
+		float x = ray_dir.x;
+		float y = ray_dir.y;
+		float z = ray_dir.z;
+		c = c +
+			SH_C1_0 * y * get_vec3(sh_offset + 1 * 3) +
+			SH_C1_1 * z * get_vec3(sh_offset + 2 * 3) +
+			SH_C1_2 * x * get_vec3(sh_offset + 3 * 3);
+
+		if (sh_dim > 12)  // (1 + 3) * 3
+		{
+			float xx = x * x, yy = y * y, zz = z * z;
+			float xy = x * y, yz = y * z, xz = x * z;
+			c = c +
+				SH_C2_0 * xy * get_vec3(sh_offset + 4 * 3) +
+				SH_C2_1 * yz * get_vec3(sh_offset + 5 * 3) +
+				SH_C2_2 * (2.0f * zz - xx - yy) * get_vec3(sh_offset + 6 * 3) +
+				SH_C2_3 * xz * get_vec3(sh_offset + 7 * 3) +
+				SH_C2_4 * (xx - yy) * get_vec3(sh_offset + 8 * 3);
+
+			if (sh_dim > 27)  // (1 + 3 + 5) * 3
+			{
+				c = c +
+					SH_C3_0 * y * (3.0f * xx - yy) * get_vec3(sh_offset + 9 * 3) +
+					SH_C3_1 * xy * z * get_vec3(sh_offset + 10 * 3) +
+					SH_C3_2 * y * (4.0f * zz - xx - yy) * get_vec3(sh_offset + 11 * 3) +
+					SH_C3_3 * z * (2.0f * zz - 3.0f * xx - 3.0f * yy) * get_vec3(sh_offset + 12 * 3) +
+					SH_C3_4 * x * (4.0f * zz - xx - yy) * get_vec3(sh_offset + 13 * 3) +
+					SH_C3_5 * z * (xx - yy) * get_vec3(sh_offset + 14 * 3) +
+					SH_C3_6 * x * (xx - 3.0f * yy) * get_vec3(sh_offset + 15 * 3);
+			}
+		}
+	}
+	c += 0.5f;
+	
+	return c;
+}
+
+void main() 
+{
+	int gs_id = int(gl_GlobalInvocationID.x);
+
+	if (gs_id > gs_num)
+		return;
+
+	int dim_gs = 3 + 4 + 3 + 1 + sh_dim;
+	int base_gs = gs_id * dim_gs;
+	int base_prep = DIM_PREP * gs_id;
+	vec4 pw = vec4(get_vec3(base_gs + OFFSET_DATA_POS), 1.f);
+    vec4 pc = view_matrix * pw;
+    vec4 u = projection_matrix * pc;
+
+	// set depth for sorter.
+	depth[gs_id] = pc.z;
+
+	u = u / u.w;
+
+	if (any(greaterThan(abs(u.xy), vec2(1.3))))
+	{
+		set_prep_vec3(base_prep + OFFSET_PREP_U, vec3(-100));
+		return;
+	}
+
+	// check the depth
+	if (abs(u.z) > 1.f)
+	{
+		set_prep_vec3(base_prep + OFFSET_PREP_U, vec3(-100));
+		return;
+	}
+
+
+	vec4 rot = get_vec4(base_gs + OFFSET_DATA_ROT);
+	vec3 scale = get_vec3(base_gs + OFFSET_DATA_SCALE);
+
+    mat3 cov3d = computeCov3D(scale, rot);
+    vec3 cov2d = computeCov2D(pc, 
+                              focal.x, 
+                              focal.y, 
+                              cov3d, 
+                              view_matrix);
+
+    // Invert covariance (EWA algorithm)
+	float det = (cov2d.x * cov2d.z - cov2d.y * cov2d.y);
+
+	if (det == 0.0f)
+	{
+		set_prep_vec3(DIM_PREP * gs_id + OFFSET_PREP_U, vec3(-100., -100., -100.));
+		return;
+	}
+
+    float det_inv = 1.f / det;
+	vec3 cinv2d = vec3(cov2d.z * det_inv, -cov2d.y * det_inv, cov2d.x * det_inv);
+    
+	vec2 area = 3.f * sqrt(vec2(cov2d.x, cov2d.z));  // drawing area, 3 sigma of x and y
+    
+	// Covert SH to color
+	vec3 cam_pos = inverse(view_matrix)[3].xyz;
+	int sh_offset = base_gs + OFFSET_DATA_SH;
+	vec3 ray_dir = pw.xyz - cam_pos;
+
+    ray_dir = normalize(ray_dir);
+	vec3 color = computeColor(sh_offset, ray_dir);
+	float alpha = gs_data[base_gs + OFFSET_DATA_ALPHA];
+
+	vec3 covinv = vec3(cov2d.z * det_inv, -cov2d.y * det_inv, cov2d.x * det_inv);
+
+	set_prep_vec3(base_prep + OFFSET_PREP_U, u.xyz);  //set u
+	set_prep_vec3(base_prep + OFFSET_PREP_COVINV, covinv);  //set cov_int
+	set_prep_vec3(base_prep + OFFSET_PREP_COLOR, color);  //set color
+	set_prep_vec2(base_prep + OFFSET_PREP_AREA, area);  //set area
+	set_prep_vec1(base_prep + OFFSET_PREP_ALPHA, alpha);  //set area
+
+}

q3dviewer/shaders/gau_vert.glsl

@@ -0,0 +1,77 @@
+/*
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+*/
+
+//draw 2d gaussian using proprocess data.
+
+#version 430 core
+
+#define OFFSET_PREP_U 0
+#define OFFSET_PREP_COVINV 3
+#define OFFSET_PREP_COLOR 6
+#define OFFSET_PREP_AREA 9
+#define OFFSET_PREP_ALPHA 11
+#define DIM_PREP 12
+
+layout(location = 0) in vec2 vert;
+
+
+layout (std430, binding=0) buffer GaussianData {
+	float gs_data[];
+};
+layout (std430, binding=1) buffer GaussianOrder {
+	int gs_index[];
+};
+layout (std430, binding=3) buffer GaussianPrep {
+	float gs_prep[];
+};
+
+uniform vec2 win_size;
+
+out vec3 color;
+out float alpha;
+out vec3 cinv2d;
+out vec2 d_pix;  // local coordinate in quad, unit in pixel
+
+vec3 get_prep_vec3(int offset)
+{
+	return vec3(gs_prep[offset], gs_prep[offset + 1], gs_prep[offset + 2]);
+}
+
+vec2 get_prep_vec2(int offset)
+{
+	return vec2(gs_prep[offset], gs_prep[offset + 1]);
+}
+
+float get_prep_vec1(int offset)
+{
+	return float(gs_prep[offset]);
+}
+
+void main()
+{
+	int gs_id = gs_index[gl_InstanceID];
+	int base_prep = gs_id * DIM_PREP;
+	gl_Position = vec4(-100);
+
+	vec3 u = get_prep_vec3(base_prep + OFFSET_PREP_U);
+
+	if (u == vec3(-100))
+	{
+		return;
+	}
+
+	vec2 area = get_prep_vec2(base_prep + OFFSET_PREP_AREA);
+
+    vec2 area_ndc = area / win_size * 2;  // in ndc space
+    vec2 pix = u.xy + vert * area_ndc;
+    gl_Position = vec4(pix, u.z , 1.0f);
+    
+	//color = computeColor(sh_offset, ray_dir);
+	color = get_prep_vec3(base_prep + OFFSET_PREP_COLOR);
+	alpha = get_prep_vec1(base_prep + OFFSET_PREP_ALPHA);
+	cinv2d = get_prep_vec3(base_prep + OFFSET_PREP_COVINV);
+    d_pix = vert * area;
+
+}

q3dviewer/shaders/sort_by_key.glsl

@@ -0,0 +1,56 @@
+/*
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+*/
+
+/*
+opengl compute shader.
+sort guassian by depth using bitonic sorter
+*/
+
+#version 430 core
+
+layout(local_size_x = 256, local_size_y = 1, local_size_z = 1) in;
+
+
+uniform int  level;
+uniform int  stage;
+
+
+layout(std430, binding = 1) buffer index_buffer {
+    uint index[];
+};
+
+layout(std430, binding = 2) buffer key_buffer {
+    float data[];
+};
+
+
+// bitonic sort 
+// https://en.wikipedia.org/wiki/Bitonic_sorter
+
+void main() {
+    uint a = (gl_GlobalInvocationID.x / stage) * (stage * 2) + gl_GlobalInvocationID.x % stage;
+    uint b = a ^ stage;
+    uint idx_a = index[a];
+    uint idx_b = index[b];
+    float data_a = data[idx_a];
+    float data_b = data[idx_b];
+
+    if ((a & level) == 0) 
+    {
+        if (data_a > data_b) 
+        {
+            index[a] = idx_b;
+            index[b] = idx_a;
+        }
+    } 
+    else
+    {
+        if(data_a < data_b) 
+        {
+            index[a] = idx_b;
+            index[b] = idx_a;
+        }
+    }
+}

q3dviewer/tools/__init__.py

@@ -0,0 +1 @@
+# tools/__init__.py