From: Dema Date: 2006-12-06T13:00:09+09:00 Subject: Re: Turtle Graphics (#104) - Java/Swing Viewer using JRuby Hi folks, Just for fun I implemented a quick and dirty version of turtle_viewer.rb using Java/Swing. It must be run using JRuby 0.9.1. Just put the file alongside turtle_viewer.rb and call: jruby jturtle_viewer.rb Here it is: # jturtle_viewer.rb require 'java' require "lib/turtle" class TurtleView DEFAULT_FRAME = [[-200.0, 200.0], [200.0, -200.0]] attr_accessor :frame def initialize(turtle, canvas, frame=DEFAULT_FRAME) @turtle = turtle @canvas = canvas @frame = frame @turtles = [] end def handle_map_event(w, h) top_lf, btm_rt = frame x0, y0 = top_lf x1, y1 = btm_rt @x_xform = make_xform(x0, x1, w) @y_xform = make_xform(y0, y1, h) end def draw g = @canvas.graphics @turtle.track.each do |seqment| if seqment.size > 1 pts = seqment.collect { |pt| transform(pt) } g.drawLine(pts[0][0], pts[0][1], pts[1][0], pts[1][1]) end end end def transform(turtle_pt) x, y = turtle_pt [@x_xform.call(x), @y_xform.call(y)] end private def make_xform(u_min, u_max, v_max) lambda { |u| v_max * (u - u_min) / (u_max - u_min) } end end JFrame = javax.swing.JFrame JPanel = javax.swing.JPanel Dimension = java.awt.Dimension BorderLayout = java.awt.BorderLayout class TurtleViewer def initialize(code) @code = code root = JFrame.new "Turtle Graphics Viewer" @canvas = JPanel.new root.get_content_pane.add @canvas, BorderLayout::CENTER root.set_default_close_operation(JFrame::EXIT_ON_CLOSE) root.set_preferred_size Dimension.new(440, 440) root.set_resizable false root.pack root.set_visible true run_code end def run_code turtle = Turtle.new view = TurtleView.new(turtle, @canvas) view.handle_map_event(@canvas.width, @canvas.height) turtle.run(@code) view.draw end end # Commands to be run if no command line argument is given. CIRCLE_DESIGN = < 0 code = open(ARGV[0]) { |f| f.read } else code = CIRCLE_DESIGN end TurtleViewer.new(code) Ruby Quiz wrote: > The three rules of Ruby Quiz: > > 1. Please do not post any solutions or spoiler discussion for this quiz until > 48 hours have passed from the time on this message. > > 2. Support Ruby Quiz by submitting ideas as often as you can: > > http://www.rubyquiz.com/ > > 3. Enjoy! > > Suggestion: A [QUIZ] in the subject of emails about the problem helps everyone > on Ruby Talk follow the discussion. Please reply to the original quiz message, > if you can. > > -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= > > by Morton Goldberg > > [Editor's Note: You can download the files for this quiz at: > > http://rubyquiz.com/turtle.zip > > --JEG2] > > Turtle Graphics > =============== > > Turtle graphics is a form of computer graphics based on the ideas of turtle > geometry, a formulation of local (coordinate-free) geometry. As a brief > introduction to turtle graphics, I quote from [1]: > > Imagine that you have control of a little creature called a turtle > that exists in a mathematical plane or, better yet, on a computer > display screen. The turtle can respond to a few simple commands: > FORWARD moves the turtle in the direction it is facing some > number of units. RIGHT rotates it clockwise in its place some > number of degrees. BACK and LEFT cause the opposite movements. ... > The turtle can leave a trace of the places it has been: [its > movements] can cause lines to appear on the screen. This is > controlled by the commands PENUP and PENDOWN. When the pen is > down, the turtle draws lines. > > For example, the turtle commands to draw a square, 100 units on a side, can be > written (in a Ruby-ized form) as: > > pen_down > 4.times { forward 100; right 90 } > > For more information, see [2] and [3]. > > This quiz is a bit different from most. If the usual Ruby quiz can be likened to > an essay exam, this one is a fill-in-the-blanks test. I'm supplying you with a > complete turtle graphics package, except -- to give you something to do -- I've > removed the method bodies from the key file, lib/turtle.rb. Your job is to > repair the damage I've done and make the package work again. > > Turtle Commands > =============== > > There are quite a few turtle commands, but that doesn't mean you have to write a > lot of code to solve this quiz. Most of the commands can be implemented in a > couple of lines. It took me a lot longer to write a description of the commands > than it did for me to implement and test all of them. > > I use the following format to describe turtle commands: > > long_name | short_name > description ... > Example: ... > > All turtle commands take either one argument or none, and not all turtle > commands have both a long name and a short name. > > Required Commands > ----------------- > > These commands are required in the sense that they are needed to reproduce the > sample designs. Actually, you could get away without implementing 'back' and > 'left', but implementing them is far easier than trying to write turtle code > without them. > > pen_up | pu > Raises the turtle's pen. The turtle doesn't draw (lay down a visible > track) when its pen is up. > > pen_down | pd > Lowers the turtle's pen. The turtle draws (lays down a visible track) > when its pen is down. > > forward | fd > Moves the turtle forwards in the direction it is facing. > Example: forward(100) advances the turtle by 100 steps. > > back | bk > Moves the turtle backwards along its line of motion. > back == forward - > Example: back(100) backs up the turtle by 100 steps. > > right | rt > Turns the turtle clockwise by degrees. > Example: right(90) turns the turtle clockwise by a right angle. > > left | lt > Turns the turtle counterclockwise by degrees. > left == right - > Example: left(45) turns the turtle counterclockwise by 45 degrees. > > Traditional Commands > -------------------- > > These commands are not needed to reproduce any of the sample designs, but they > are found in all implementations of turtle graphics that I know of. > > home > Places the turtle at the origin, facing north, with its pen up. The > turtle does not draw when it goes home. > > clear > Homes the turtle and empties out it's track. Sending a turtle a clear > message essentially reinitializes it. > > xy > Reports the turtle's location. > Example: Suppose the turtle is 10 turtle steps north and 15 turtle steps > west of the origin, then xy will return [-15.0, 10.0]. > > set_xy | xy= > Places the turtle at . The turtle does not draw when this command > is executed, not even if its pen is down. Returns . > Example: Suppose the turtle is at [10.0, 20.0], then self.xy = [50, 80] > moves the turtle to [50.0, 80.0], but no line will drawn between the [10, > 20] and [50, 80]. > > heading > Reports the direction in which the turtle is facing. Heading is measured > in degrees, clockwise from north. > Example: Suppose the turtle is at the origin facing the point [100, 200], > then heading will return 26.565 (approximately). > > heading= | set_h > Sets the turtle's heading to . should be given in degrees, > measured clockwise from north. Returns . > Example: After self.heading = 135 (or set_h(135) which is easier to > write), the turtle will be facing southeast. > > pen_up? | pu? > Reports true if the turtle's pen is up and false otherwise. > > pen_down? | pd? > Reports true if the turtle's pen is down and false otherwise. > > Optional Commands > ----------------- > > These commands are only found in some implementations of turtle graphics. When > they are implemented, they make the turtle capable of doing global (coordinate) > geometry in addition to local (coordinate-free) geometry. > > I used one of these commands, go, to draw the mandala design (see > designs/mandala.tiff and samples/mandala.rb). If you choose not to implement the > optional commands, you might try writing a turtle program for drawing the > mandala design without using go. But, believe me, it is much easier to implement > go than to write such a program. > > go > Moves the turtle to . > Example: Suppose the turtle is home (at the origin facing north). After > go([100, 200]), the turtle will be located at [100.0, 200.0] but will > still be facing north. If its pen was down, it will have drawn a line > from [0, 0] to [100, 200]. > > toward | face > Turns the turtle to face . > Example: Suppose the turtle is at the origin. After toward([100, 200]), > its heading will be 26.565 (approximately). > > distance | dist > Reports the distance between the turtle and . > Example: Suppose the turtle is at the origin, then distance([400, 300]) > will return 500.0 (approximately). > > Interfacing to the Turtle Graphics Viewer > ========================================= > > Implementing turtle graphics without being able to view what the turtle draws > isn't much fun, so I'm providing a simple turtle graphics viewer. To interface > with the viewer, turtle instances must respond to the message track by returning > an array which the viewer can use to generate a line drawing. > > The viewer expects the array returned by track to take the following form: > > track ::= [segment, segment, ...] # drawing data > segment ::= [point, point, ...] # points to be joined by line segments > point ::= [x, y] # pair of floats > > Example: [[[0.0, 0.0], [200.0, 200.0]], [[200.0, 0.0], [0.0, 200.0]]] > > This represents an X located in the upper-right quadrant of the viewer; i.e., > two line segments, one running from the center of the viewer up to its > upper-right corner and the other running from the center of the top edge down to > the center of the right edge. > > [Editor's Note: I added a script to dump your turtle graphics output to PPM > image files, for those that don't have TK up and running. It works identically > to Morton's turtle_viewer.rb, save that it writes output to a PPM image file in > the current directory. For example, to output the included tree image, use > `ruby turtle_ppm_writer.rb samples/tree.rb`. --JEG2] > > Unit Tests > ========== > > I'm including the unit tests which I developed to test turtle commands. For the > purposes of the quiz, you can ignore tests/turtle_view_test.rb. But I hope you > will find the other test suite, tests/turtle_test.rb, helpful. It tests every > one of the turtle commands described above as well as argument checking by the > commands. Don't hesitate to modify any of the unit tests to meet the needs of > your quiz solution. > > References > ========== > > [1] Abelson, H. & A. diSessa, "Turtle Geometry", MIT Press, 1981. > [2] Harvey, B., "Computer Science Logo Style", Chapter 10. > http://www.cs.berkeley.edu/~bh/pdf/v1ch10.pdf > [3] Wikipedia, http://en.wikipedia.org/wiki/LOGO_programming_language