disp3D 0.2.1 → 1.0.1

data/lib/qt_widget_gl.rb

@@ -1,13 +1,20 @@
+require 'forwardable'
 require 'Qt'
 require 'disp3D'
 
 include Disp3D
 class QtWidgetGL < Qt::GLWidget
+  extend Forwardable
+
   attr_accessor :width
   attr_accessor :height
 
   attr_reader :load_proc
 
+  def_delegators :@view, :camera, :world_scene_graph, :camera_scene_graph
+  def_delegators :@view, :manipulator, :light, :picker
+  def_delegators :@view, :sync_to, :capture, :fit, :centering
+
   def initialize(parent, width = 400, height = 400)
     super(parent)
     @width = width
@@ -21,10 +28,6 @@ class QtWidgetGL < Qt::GLWidget
     super
   end
 
-  def gl_view
-    @view
-  end
-
   def set_load_proc(proc)
     @load_proc = proc
   end
@@ -49,18 +52,17 @@ class QtWidgetGL < Qt::GLWidget
   end
 
   def mouseReleaseEvent(event)
-    @view.mouse_release_proc.call(self, get_GLUT_button(event), event.pos.x, event.pos.y) if( @view.mouse_release_proc != nil)
-    @view.manipulator.mouse(get_GLUT_button(event), GLUT::GLUT_UP, event.pos.x,event.pos.y)
+    glut_button = get_GLUT_button(event)
+    @view.mouse_release_process(glut_button, event.pos.x, event.pos.y)
   end
 
   def mousePressEvent(event)
-    @view.mouse_press_proc.call(self, get_GLUT_button(event), event.pos.x, event.pos.y) if( @view.mouse_press_proc != nil)
-    @view.manipulator.mouse(get_GLUT_button(event), GLUT::GLUT_DOWN, event.pos.x,event.pos.y)
+    glut_button = get_GLUT_button(event)
+    @view.mouse_press_process(glut_button, event.pos.x, event.pos.y)
   end
 
   def mouseMoveEvent(event)
-    @view.mouse_move_proc.call(self, x,y) if( @view.mouse_move_proc != nil)
-    need_update = @view.manipulator.motion(event.pos.x,event.pos.y)
+    need_update = @view.mouse_move_process(event.pos.x,event.pos.y)
     if(need_update)
       updateGL()
     end
@@ -71,7 +73,18 @@ class QtWidgetGL < Qt::GLWidget
   end
 
   def resizeGL(width, height)
-    @view.camera.reshape(width, height)
+    @view.reshape(width, height)
+  end
+
+  def idle_process(wait_msec = nil, &block)
+    @idle_proc = block
+    @idle_process_timer_id = startTimer(wait_msec)
+  end
+
+  def timerEvent(event)
+    if( event.timerId == @idle_process_timer_id)
+      @idle_proc.call
+    end
   end
 end
 

data/lib/scene_graph.rb

@@ -8,9 +8,9 @@ module Disp3D
       @root_node = NodeCollection.new()
     end
 
-    def gl_display()
-      Node.init_path_db
-      @root_node.draw()
+    def gl_display(current_view)
+      NodePathDB.init
+      @root_node.draw(current_view)
     end
 
     def add(node)

data/test/node/test_node.rb

@@ -17,6 +17,236 @@ class NodeTestCase < MiniTest::Unit::TestCase
     assert_equal(nil, node.post_translate)
 
     assert_equal([], node.parents)
+
+    assert_equal(nil, node.name)
+    assert(node.instance_id.kind_of?(Integer))
+
+    node_with_name = Disp3D::Node.new(:node00)
+    assert_equal(:node00, node_with_name.name)
+  end
+
+  def test_ancestor
+    node_group = Disp3D::NodeCollection.new()
+    node_group.open do
+      add_new :type => :Points, :geom => Vector3.new(), :name => :node01
+      add_new :type => :TeaPod, :name => :node02
+      add_new :type => :Text, :geom => Vector3.new(), :name => :node03
+      add_new :name => :node04 do
+        add_new :type => :Coord, :name => :node05
+        add_new :name => :node06 do
+          add_new :type => :Points, :geom => Vector3.new(), :name => :node07
+          add :node01
+        end
+      end
+
+      add_new :name => :node08 do
+        add :node02
+        add :node07
+      end
+    end
+
+    root_id = node_group.instance_id
+    node04_id = Disp3D::NodeDB.find_by_name(:node04).instance_id
+    node06_id = Disp3D::NodeDB.find_by_name(:node06).instance_id
+    node08_id = Disp3D::NodeDB.find_by_name(:node08).instance_id
+
+    assert_equal([root_id, node04_id, node06_id].sort           , Disp3D::NodeDB.find_by_name(:node01).ancestors.sort)
+    assert_equal([root_id, node08_id].sort                      , Disp3D::NodeDB.find_by_name(:node02).ancestors.sort)
+    assert_equal([root_id].sort                                 , Disp3D::NodeDB.find_by_name(:node03).ancestors.sort)
+    assert_equal([root_id, node04_id].sort                      , Disp3D::NodeDB.find_by_name(:node05).ancestors.sort)
+    assert_equal([root_id, node04_id, node06_id, node08_id].sort, Disp3D::NodeDB.find_by_name(:node07).ancestors.sort)
+  end
+
+  def test_create_and_update
+    node_group = Disp3D::NodeCollection.new()
+# create test
+    node_group.open do
+      create :type => :TeaPod,
+             :size => 0.5,
+             :name => :node10
+
+      create :type => :Points,
+             :geom => Vector3.new(),
+             :size => 10.0,
+             :name => :node11,
+             :pre_translate => Vector3.new(1,0,1),
+             :post_translate => Vector3.new(1,0,1),
+             :rotate => Quat.from_axis(Vector3.new(1,0,0), Math::PI)
+
+      create :type => :Text,
+             :geom => Vector3.new(),
+             :name => :node12,
+             :text => "this is node12"
+
+      create :type => :Collection,
+             :name => :node13,
+             :pre_translate => Vector3.new(1,0,1),
+             :post_translate => Vector3.new(1,0,1),
+             :rotate => Quat.from_axis(Vector3.new(1,0,0), Math::PI)
+
+      create :type => :Points,
+             :geom => Vector3.new,
+             :name => :node14,
+             :colors => [1,1,0,1]
+
+      create :type => :Lines,
+             :geom => FiniteLine.new,
+             :name => :node14,
+             :colors => [1,1,0,1]
+    end
+
+    node10 = Disp3D::NodeDB.find_by_name(:node10)
+    assert_equal( Disp3D::NodeTeaPod, node10.class)
+    assert_equal( 0.5, node10.size)
+
+    node11 = Disp3D::NodeDB.find_by_name(:node11)
+    assert_equal( Disp3D::NodePoints, node11.class)
+#    assert_equal( Vector3.new, node11.geom)
+    assert_equal( 10.0, node11.size)
+    assert_equal( Vector3.new(1,0,1), node11.pre_translate)
+    assert_equal( Vector3.new(1,0,1), node11.post_translate)
+    assert_equal( Quat.from_axis(Vector3.new(1,0,0), Math::PI), node11.rotate)
+
+    node12 = Disp3D::NodeDB.find_by_name(:node12)
+    assert_equal( Disp3D::NodeText, node12.class)
+    assert_equal( "this is node12", node12.text )
+
+    node13 = Disp3D::NodeDB.find_by_name(:node13)
+    assert_equal( Disp3D::NodeCollection, node13.class)
+    assert_equal( Vector3.new(1,0,1), node13.pre_translate)
+    assert_equal( Vector3.new(1,0,1), node13.post_translate)
+    assert_equal( Quat.from_axis(Vector3.new(1,0,0), Math::PI), node13.rotate)
+
+    node14 = Disp3D::NodeDB.find_by_name(:node14)
+    assert_equal( Array, node14.class)
+    node14.each do |node|
+      assert_equal( :node14, node.name)
+      assert_equal( [1,1,0,1], node.colors)
+      assert( [Disp3D::NodePoints, Disp3D::NodeLines].include?(node.class) )
+    end
+
+# update test
+    node_group.open do
+      update :name => :node10,
+             :size => 2.0
+
+      update :name => :node11,
+             :size => 4.0,
+             :geom => Vector3.new(3,2,1),
+             :pre_translate => Vector3.new(1,2,3),
+             :post_translate => Vector3.new(1,2,3),
+             :rotate => Quat.from_axis(Vector3.new(0,1,0), Math::PI/2.0)
+
+      update :name => :node12,
+             :geom => Vector3.new(),
+             :text => "this is node12 updated"
+
+      update :name => :node13,
+             :pre_translate => Vector3.new(3,2,1),
+             :post_translate => Vector3.new(3,2,-1),
+             :rotate => Quat.from_axis(Vector3.new(0,0,1), Math::PI)
+
+     update :name => :node14,
+             :colors => [0,1,1,1]
+    end
+
+    node10 = Disp3D::NodeDB.find_by_name(:node10)
+    assert_equal( Disp3D::NodeTeaPod, node10.class)
+    assert_equal( 2.0, node10.size)
+
+    node11 = Disp3D::NodeDB.find_by_name(:node11)
+    assert_equal( Disp3D::NodePoints, node11.class)
+    assert_equal( 4.0, node11.size)
+    assert_equal( Vector3.new(1,2,3), node11.pre_translate)
+    assert_equal( Vector3.new(1,2,3), node11.post_translate)
+    assert_equal( Quat.from_axis(Vector3.new(0,1,0), Math::PI/2.0), node11.rotate)
+
+    node12 = Disp3D::NodeDB.find_by_name(:node12)
+    assert_equal( Disp3D::NodeText, node12.class)
+    assert_equal( "this is node12 updated", node12.text )
+
+    node13 = Disp3D::NodeDB.find_by_name(:node13)
+    assert_equal( Disp3D::NodeCollection, node13.class)
+    assert_equal( Vector3.new(3,2,1), node13.pre_translate)
+    assert_equal( Vector3.new(3,2,-1), node13.post_translate)
+    assert_equal( Quat.from_axis(Vector3.new(0,0,1), Math::PI), node13.rotate)
+
+    node14 = Disp3D::NodeDB.find_by_name(:node14)
+    assert_equal( Array, node14.class)
+    node14.each do |node|
+      assert_equal( :node14, node.name)
+      assert_equal( [0,1,1,1], node.colors)
+      assert( [Disp3D::NodePoints, Disp3D::NodeLines].include?(node.class) )
+    end
   end
 
+  def test_box_trans_form
+    node = Disp3D::Node.new
+    box = Box.new
+    box_org = box.clone
+
+    node_group = Disp3D::NodeCollection.new
+    node_group.pre_translate = Vector3.new(1,1,1)
+    node_group.open do
+      box = box_transform(box_org)
+    end
+    assert_equal(box_org.translate(Vector3.new(1,1,1)), box)
+
+    rotate_quat = Quat.from_axis( Vector3.new(1,0,0), 45.0/180.0*Math::PI )
+    node_group.rotate = rotate_quat
+    node_group.open do
+      box = box_transform(box_org)
+    end
+    assert_equal(box_org.translate(Vector3.new(1,1,1)).rotate(rotate_quat), box)
+
+    node_group.post_translate = Vector3.new(-1,-1,-1)
+    node_group.open do
+      box = box_transform(box_org)
+    end
+    assert_equal(box_org.translate(Vector3.new(1,1,1)).rotate(rotate_quat).translate(Vector3.new(-1,-1,-1)), box)
+  end
+
+  def test_delete
+    node_group = Disp3D::NodeCollection.new()
+    node_group.open do
+      create :type => :TeaPod,
+             :name => :node20
+
+      create :type => :Points,
+             :geom => Vector3.new(),
+             :name => :node21
+
+      create :type => :Text,
+             :geom => Vector3.new(),
+             :name => :node22
+
+      create :type => :Collection,
+             :name => :node23
+
+      create :type => :Coord,
+             :name => :node23 # same name
+
+      add :node20
+      add :node21
+      add :node23
+    end
+    assert_equal( 4, node_group.child_nodes.size)
+    assert_equal( Disp3D::NodeTeaPod, Disp3D::NodeDB.find_by_name(:node20).class)
+    node_ary = Disp3D::NodeDB.find_by_name(:node23)
+    assert_equal( Array, node_ary.class)
+    assert( node_ary.find { |node| node.class == Disp3D::NodeCollection })
+    assert( node_ary.find { |node| node.class == Disp3D::NodeCoord })
+
+    node_group.open do
+      delete :node20
+    end
+    assert_equal( 3, node_group.child_nodes.size)
+    assert_equal( nil, Disp3D::NodeDB.find_by_name(:node20))
+
+    node_group.open do
+      delete :node23
+    end
+    assert_equal( 1, node_group.child_nodes.size)
+    assert_equal( nil, Disp3D::NodeDB.find_by_name(:node23))
+  end
 end

data/test/node/test_node_collection.rb

@@ -11,100 +11,120 @@ class NodeCollectionTestCase < MiniTest::Unit::TestCase
     @gl_view = Disp3D::GLUTWindow.new(300, 300)
   end
 
-  def test_add_include
-    node_collection = Disp3D::NodeCollection.new()
-    node_point = Disp3D::NodePoints.new(Vector3.new())
-    added_id = node_collection.add(node_point)
+  def test_add
+    node_group = Disp3D::NodeCollection.new()
+
     node_ary = Array.new()
-    node_ary[0] = Disp3D::NodeTeaPod.new(4)
+    node_ary[0] = Disp3D::NodeTeaPod.new()
     node_ary[1] = Disp3D::NodeLines.new(FiniteLine.new(Vector3.new(0,0,0),Vector3.new(1,1,1)))
-    added_id_ary = node_collection.add(node_ary)
 
-    assert(node_collection.include?(added_id))
-    assert_equal(node_point, node_collection.child(added_id))
-    assert_equal(2, added_id_ary.size)
-    added_id_ary.each do |item|
-      assert(node_collection.include?(item))
+    path_id = -1
+    path_id_ary = -1
+    node_group.open do
+      create :type => :Points,
+             :geom => Vector3.new(),
+             :name => :node100
+
+      path_id = add :node100
+      path_id_ary = add node_ary
     end
-    assert_equal(node_ary[0], node_collection.child(added_id_ary[0]))
-    assert_equal(node_ary[1], node_collection.child(added_id_ary[1]))
-    assert_equal(nil, node_collection.child(-1))
-  end
 
-  def test_ancestor
-    node_root = Disp3D::NodeCollection.new()
-    node_child = Disp3D::NodeCollection.new()
-    node_g_child = Disp3D::NodeCollection.new()
-    node_root.add(node_child)
-    node_child.add(node_g_child)
-    ancestors = node_child.ancestors
-    assert_equal(1,ancestors.size)
-    assert(ancestors.include?(node_root.instance_id))
-
-    ancestors = node_g_child.ancestors
-    assert_equal(2,ancestors.size)
-    assert(ancestors.include?(node_root.instance_id))
-    assert(ancestors.include?(node_child.instance_id))
-
-    node_root.add(node_g_child)
-    ancestors = node_g_child.ancestors
-    assert_equal(2,ancestors.size)
-    assert(ancestors.include?(node_root.instance_id))
-    assert(ancestors.include?(node_child.instance_id))
-
-    node_root.add(node_child)
-    ancestors = node_g_child.ancestors
-    assert_equal(2,ancestors.size)
-    assert(ancestors.include?(node_root.instance_id))
-    assert(ancestors.include?(node_child.instance_id))
-
-    node_g_child2 = Disp3D::NodeCollection.new()
-    node_child.add(node_g_child2)
-    ancestors = node_g_child2.ancestors
-    assert_equal(2,ancestors.size)
-    assert(ancestors.include?(node_root.instance_id))
-    assert(ancestors.include?(node_child.instance_id))
-
-    node_gg_child = Disp3D::NodeCollection.new()
-    node_g_child.add(node_gg_child)
-    ancestors = node_gg_child.ancestors
-    assert_equal(3,ancestors.size)
-    assert(ancestors.include?(node_root.instance_id))
-    assert(ancestors.include?(node_child.instance_id))
-    assert(ancestors.include?(node_g_child.instance_id))
-
-    node_g_child2.add(node_gg_child)
-    ancestors = node_gg_child.ancestors
-    assert_equal(4,ancestors.size)
-    assert(ancestors.include?(node_root.instance_id))
-    assert(ancestors.include?(node_child.instance_id))
-    assert(ancestors.include?(node_g_child.instance_id))
-    assert(ancestors.include?(node_g_child2.instance_id))
+    assert(node_group.include?(path_id))
+    assert_equal(Disp3D::NodeDB.find_by_name(:node100), node_group.child(path_id))
+    assert_equal(2, path_id_ary.size)
+    path_id_ary.each do |item|
+      assert(node_group.include?(item))
+    end
+    assert_equal(node_ary[0], node_group.child(path_id_ary[0]))
+    assert_equal(node_ary[1], node_group.child(path_id_ary[1]))
+    assert_equal(nil, node_group.child(-1))
   end
 
-  def test_circular_reference
-    node_collection1 = Disp3D::NodeCollection.new()
-    node_collection2 = Disp3D::NodeCollection.new()
-    node_collection3 = Disp3D::NodeCollection.new()
-    node_collection1.add(node_collection2)
-    node_collection2.add(node_collection3)
 
-    # circular reference occures!
+  def test_circular_reference
     assert_raises Disp3D::CircularReferenceException do
-      node_collection3.add(node_collection1)
+      Disp3D::NodeCollection.new().open do
+        add_new :name => :node101 do
+          add_new :name => :node102 do
+            add :node101
+          end
+        end
+      end
     end
-#    @gl_view.world_scene_graph.add(node_collection1)
-#    @gl_view.gl_display()
   end
 
   def test_self_reference
-    node_collection1 = Disp3D::NodeCollection.new()
     assert_raises Disp3D::CircularReferenceException do
-      node_collection1.add(node_collection1)
+      Disp3D::NodeCollection.new().open do
+        add_new :name => :node111 do
+          add :node111
+        end
+      end
     end
   end
 
-  def test_box_boundary
+  def test_add_new
+    # test add_new
+    node_group = Disp3D::NodeCollection.new()
+    node_group.open do
+      add_new :type => :TeaPod,
+              :size => 0.5,
+              :name => :node120
+
+      add_new :type => :Points,
+              :geom => Vector3.new(),
+              :size => 10.0,
+              :name => :node121,
+              :pre_translate => Vector3.new(1,0,1),
+              :post_translate => Vector3.new(1,0,1),
+              :rotate => Quat.from_axis(Vector3.new(1,0,0), Math::PI)
+
+      add_new :type => :Text,
+              :geom => Vector3.new(),
+              :name => :node122,
+              :text => "this is node12"
+
+      add_new :name => :node123, :post_translate => Vector3.new(1,0,1) do
+        add :node120
+        add_new :type => :Arrows,
+                :geom => FiniteLine.new(Vector3.new(), Vector3.new(1,2,3)),
+                :name => :node124
+      end
+    end
+    assert_equal(4, node_group.child_nodes.size)
+    childe_nodes_name_ary = node_group.child_nodes.collect{ |node| node.name }
+    assert_equal([:node120, :node121, :node122, :node123].sort,childe_nodes_name_ary.sort)
+    child_group_node = node_group.child_nodes.find{ |node| node.class == Disp3D::NodeCollection }
+    assert_equal(2, child_group_node.child_nodes.size)
+    childe_nodes_name_ary = child_group_node.child_nodes.collect{ |node| node.name }
+    assert_equal([:node120, :node124].sort,childe_nodes_name_ary.sort)
+
+    # remove test
+
+    # path id DB is created by drawing
+    @gl_view.world_scene_graph.add(node_group)
+    @gl_view.world_scene_graph.gl_display @gl_view
+
+    path_id_120_1 = node_group.child_path_id.find{ |path_id| node_group.child(path_id).name == :node120}
+    path_id_120_2 = child_group_node.child_path_id.find{ |path_id| child_group_node.child(path_id).name == :node120}
+    node_group.open do
+      remove path_id_120_1
+    end
+    assert_equal(3, node_group.child_nodes.size)
+    assert_equal(2, child_group_node.child_nodes.size)
+
+    node_group.open do
+      remove path_id_120_2
+    end
+    assert_equal(3, node_group.child_nodes.size)
+    assert_equal(1, child_group_node.child_nodes.size)
+
+    node = Disp3D::NodeDB.find_by_name(:node120)
+    assert_equal(Disp3D::NodeTeaPod, node.class)
+    assert_equal(0.5,  node.size)
+  end
+
+  def test_boundary_box
     box_geom = Box.new(Vector3.new(-1,-1,-1), Vector3.new(1,1,1))
     box_node = Disp3D::NodeTris.new(TriMesh.from_box(box_geom))
     bb = box_node.box
@@ -138,7 +158,7 @@ class NodeCollectionTestCase < MiniTest::Unit::TestCase
 
     node_collection.rotate = Quat.from_axis(Vector3.new(1,0,0), angle_45)
     bb = node_collection.box
-    assert_equal(Vector3.new(0, 0,            -Math.sqrt(2)), bb.min_point)
-    assert_equal(Vector3.new(2, 2*Math.sqrt(2),Math.sqrt(2)), bb.max_point)
+    assert_equal(Vector3.new(0, -Math.sqrt(2), 0), bb.min_point)
+    assert_equal(Vector3.new(2, Math.sqrt(2), 2*Math.sqrt(2),), bb.max_point)
   end
 end