rtreevisualizer.java

r_tree原代码

		textGroup.setTransform(t3d);
		textGroup.addChild(textShape);
		g.addChild(textGroup);
	}

	public BufferedImage getCanvasImage()
	{
  	GraphicsContext3D  ctx = m_canvas3D.getGraphicsContext3D();
    Raster ras = new Raster();
    ras.setType (Raster.RASTER_COLOR);
    ras.setCapability (Raster.ALLOW_IMAGE_READ);
    Dimension d = getSize();
    ras.setSize (d);
    ras.setImage (new ImageComponent2D(ImageComponent2D.FORMAT_RGB, d.width, d.height));
		ctx.readRaster(ras);
    // Now strip out the image info
    ImageComponent2D img_src = ras.getImage();
		//DepthComponent depth = ras.getDepthComponent();
    return img_src.getImage();
  }

	public void writeImage (String fileName)
	{
  	try
  	{
  		BufferedImage bi = getCanvasImage();
      File file = new File(fileName);
      FileOutputStream out = new FileOutputStream(file);
      JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
      JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
      param.setQuality(1.0f, false);
      encoder.setJPEGEncodeParam(param);
      encoder.encode(bi);
      out.close();
    }
    catch (Exception ex)
    {
    	System.out.println ("Error writing image to file " + fileName + ": " + ex.toString());
      ex.printStackTrace();
    }
  }

	class MyQueryStrategy implements IQueryStrategy
	{
		ArrayList m_entries = new ArrayList();
		ArrayList m_remainingNodes = new ArrayList();
		Data m_root;
		boolean m_found = true;
		boolean m_firstCall = true;
		double[] m_max;
		double[] m_min;

	  public void getNextEntry(IEntry entry, int[] nextEntry, boolean[] hasNext)
  	{
			if (m_found)
			{
				m_found = false;
				m_entries.clear();

		    if (entry instanceof INode)
  	  	{
    			INode n = (INode) entry;
  				if (m_firstCall)
  				{
  					m_root = new Data((Region) n.getShape(), n.getIdentifier(), n.getLevel());
						m_max = new double[m_root.m_region.m_pLow.length];
						m_min = new double[m_root.m_region.m_pLow.length];
						for (int cDim = 0; cDim < m_root.m_region.m_pLow.length; cDim++)
						{
							m_max[cDim] = m_root.m_region.m_pHigh[cDim];
							m_min[cDim] = m_root.m_region.m_pLow[cDim];
  	 					m_root.m_region.m_pHigh[cDim] = (m_root.m_region.m_pHigh[cDim] - m_min[cDim]) / (m_max[cDim] - m_min[cDim]);
   						m_root.m_region.m_pLow[cDim] = (m_root.m_region.m_pLow[cDim] - m_min[cDim]) / (m_max[cDim] - m_min[cDim]);
						}

  					m_firstCall = false;
  				}

   				Data r = new Data((Region) n.getShape(), n.getIdentifier(), n.getLevel());
   				for (int cDim = 0; cDim < r.m_region.m_pLow.length; cDim++)
   				{
   					r.m_region.m_pLow[cDim] = (r.m_region.m_pLow[cDim] - m_min[cDim]) / (m_max[cDim] - m_min[cDim]);
   					r.m_region.m_pHigh[cDim] = (r.m_region.m_pHigh[cDim] - m_min[cDim]) / (m_max[cDim] - m_min[cDim]);
   				}
   				m_entries.add(r);

					//System.err.println(n.getIdentifier() + ":");
					for (int cChild = 0; cChild < n.getChildrenCount(); cChild++)
    			{
    				//System.err.println(" " + n.getChildIdentifier(cChild));
   					if (n.getLevel() > 0)	m_remainingNodes.add(new Integer(n.getChildIdentifier(cChild)));

	   				r = new Data((Region) n.getChildShape(cChild), n.getChildIdentifier(cChild), n.getLevel() - 1);
	   				for (int cDim = 0; cDim < r.m_region.m_pLow.length; cDim++)
  	 				{
   						r.m_region.m_pLow[cDim] = (r.m_region.m_pLow[cDim] - m_min[cDim]) / (m_max[cDim] - m_min[cDim]);
   						r.m_region.m_pHigh[cDim] = (r.m_region.m_pHigh[cDim] - m_min[cDim]) / (m_max[cDim] - m_min[cDim]);
   					}
						m_entries.add(r);
	    		}
  			}
			}
			else
			{
				m_found = true;

				if (! m_remainingNodes.isEmpty())
				{
		   		nextEntry[0] = ((Integer) m_remainingNodes.get(0)).intValue(); m_remainingNodes.remove(0);
		    	hasNext[0] = true;
		  	}
		  	else
		  	{
					m_entries.clear();
					hasNext[0] = false;
		  	}
			}
		}
	}

  class KeyboardDriver extends Behavior
	{
		private TransformGroup m_targetTG;

		// create SimpleBehavior
    KeyboardDriver(TransformGroup targetTG)
    {
    	m_targetTG = targetTG;
    }

    public void initialize()
    {
			this.wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));
    }

    public void processStimulus(Enumeration criteria)
    {
			Transform3D rotation = new Transform3D();
			m_targetTG.getTransform(rotation);

	    while (criteria.hasMoreElements())
      {
        WakeupCriterion wakeup = (WakeupCriterion) criteria.nextElement();
        if (wakeup instanceof WakeupOnAWTEvent)
        {
        	AWTEvent[] events = ((WakeupOnAWTEvent) wakeup).getAWTEvent();
          
          for (int cIndex = 0; cIndex < events.length; cIndex++)
          {
          	if (events[cIndex] instanceof KeyEvent)
          	{
							KeyEvent event = (KeyEvent) events[events.length-1];
							Transform3D tmp = new Transform3D();

    	        if (event.getKeyCode() == KeyEvent.VK_PAGE_UP)
      	      {
        	    	tmp.rotX((event.isShiftDown()) ? 0.01 : 0.05);
          	  	rotation.mul(tmp);
	            }
  	          else if (event.getKeyCode() == KeyEvent.VK_PAGE_DOWN)
    	        {
      	       	tmp.rotX((event.isShiftDown()) ? -0.01 : -0.05);
        	    	rotation.mul(tmp);
          	  }
	            else if (event.getKeyCode() == KeyEvent.VK_HOME)
  	          {
    	         	tmp.rotZ((event.isShiftDown()) ? 0.01 : 0.05);
      	      	rotation.mul(tmp);
        	    }
          	  else if (event.getKeyCode() == KeyEvent.VK_END)
	            {
  	           	tmp.rotZ((event.isShiftDown()) ? -0.01 : -0.05);
    	        	rotation.mul(tmp);
      	      }
	            else if (event.getKeyCode() == KeyEvent.VK_INSERT)
  	          {
    	         	tmp.rotY((event.isShiftDown()) ? 0.01 : 0.05);
      	      	rotation.mul(tmp);
        	    }
          	  else if (event.getKeyCode() == KeyEvent.VK_DELETE)
            	{
	             	tmp.rotY((event.isShiftDown()) ? -0.01 : -0.05);
  	          	rotation.mul(tmp);
    	        }
          	  else if (event.getKeyCode() == KeyEvent.VK_A)
            	{
								System.err.println(rotation);
    	        }
          	  else if (event.getKeyCode() == KeyEvent.VK_R)
            	{
								rotation.set(new Transform3D(m_initialView));
    	        }
          	  else if (event.getKeyCode() == KeyEvent.VK_S)
            	{
            		m_scaleFactor += 1.0f;
            		createSceneGraph();
    					}
          	  else if (event.getKeyCode() == KeyEvent.VK_D)
            	{
            		m_scaleFactor -= 1.0f;
            		if (m_scaleFactor < 1.0f) m_scaleFactor = 1.0f;
            		createSceneGraph();            		
    					}
          	  else if (event.getKeyCode() == KeyEvent.VK_LEFT)
            	{
            		Matrix4d m = new Matrix4d();
            		rotation.get(m);
								m.m03 += (event.isShiftDown()) ? 0.05 : 0.1;
								rotation.set(m);
							}
          	  else if (event.getKeyCode() == KeyEvent.VK_RIGHT)
            	{
            		Matrix4d m = new Matrix4d();
            		rotation.get(m);
								m.m03 += (event.isShiftDown()) ? -0.05 : -0.1;
								rotation.set(m);
							}
          	  else if (event.getKeyCode() == KeyEvent.VK_UP)
            	{
            		Matrix4d m = new Matrix4d();
            		rotation.get(m);
								m.m13 += (event.isShiftDown()) ? 0.05 : 0.1;
								rotation.set(m);
							}
          	  else if (event.getKeyCode() == KeyEvent.VK_DOWN)
            	{
            		Matrix4d m = new Matrix4d();
            		rotation.get(m);
								m.m13 += (event.isShiftDown()) ? -0.05 : -0.1;
								rotation.set(m);
							}
          	  else if (event.getKeyCode() == KeyEvent.VK_COMMA)
            	{
            		Matrix4d m = new Matrix4d();
            		rotation.get(m);
								m.m23 += (event.isShiftDown()) ? 0.1 : 0.5;
								rotation.set(m);
							}
          	  else if (event.getKeyCode() == KeyEvent.VK_PERIOD)
            	{
            		Matrix4d m = new Matrix4d();
            		rotation.get(m);
								m.m23 += (event.isShiftDown()) ? -0.1 : -0.5;
								rotation.set(m);
							}
          	  else if (event.getKeyCode() == KeyEvent.VK_I)
            	{
								writeImage("snap.jpg");
							}
       	    }
      	  }
        }
      }

      m_targetTG.setTransform(rotation);
      this.wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));      
    }
  }

	class Data
	{
		Region m_region;
		int m_identifier;
		int m_level;

		public Data(Region region, int id, int level)
		{
			m_region = region;
			m_identifier = id;
			m_level = level;
		}
	}

	public static void main(String[] args)
	{
		if (args.length != 1)
		{
			System.err.println("Usage: RTreeVisualizer tree_file (without the extension).");
			System.exit(-1);
		}

		System.out.println(
			"The visualizer scales the dataset to the unit square, thus it might destort the actual\n" +
			"tree characteristics, if the original dimensions do not adhere to the usual 1/1 ratio.\n" +
			"Use:\n" +
			" Arrows to pan left, right, up, down\n" +
			" <,> to zoom in/out\n" +
			" Insert, Delete, Home, End, Page-up, Page-down to rotate\n" +
			" r to reset to initial view\n" +
			" s,d to rescale objects\n" +
			" i to take a jpg snapshot\n" +
			"Hold down:\n" +
			" Left mouse button for free rotation\n" +
			" Middle mouse button to zoom in/out\n" +
			" Right mouse button pan."
		);

		try
		{
			// Create a disk based storage manager.
			PropertySet ps = new PropertySet();

			ps.setProperty("FileName", args[0]);
				// .idx and .dat extensions will be added.

			IStorageManager diskfile = new DiskStorageManager(ps);

			IBuffer file = new RandomEvictionsBuffer(diskfile, 50, false);
				// applies a main memory random buffer on top of the persistent storage manager
				// (LRU buffer, etc can be created the same way).

			PropertySet ps2 = new PropertySet();

			// If we need to open an existing tree stored in the storage manager, we only
			// have to specify the index identifier as follows
			Integer i = new Integer(1); // INDEX_IDENTIFIER_GOES_HERE (suppose I know that in this case it is equal to 1);
			ps2.setProperty("IndexIdentifier", i);
				// this will try to locate and open an already existing r-tree index from file manager file.

			RTree tree = new RTree(ps2, file);

			Frame frame = new MainFrame(new RTreeVisualizer(tree), 700, 700);
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}