nklein software » rt

Lisp Package Dependencies

pat — Tue, 21 Oct 2008 23:36:26 +0000

Some time back, xach posted information about all of the interdependcies amongst the Lisp packages available on Cliki. He had toyed with a few visualization techniques.

Me, I tweaked some old code visualization stuff I had written to output where everything was after it stabilized. Then, I tweaked my ray tracer to read that input and render the output.

So, start with Xach’s dependency listing which is a list of lists. Each sublist is a package name followed by all of the packages it depends upon.

Plop that in my code visualization stuff. It creates a node for each package and a spring from package A to package B if package A depends upon package B. Every node repels every other node. The springs want to keep nodes one unit apart. Every node is attracted to the origin. Damp the motion a bit and eventually it all finds a steady state. Output where all of the springs and all of the nodes are.

Pull this information into the ray tracer. Draw red spheres at each node. Draw yellow cylinders for each spring. Put green bands around the parent’s end of the spring. Sit the camera in the thick of it all. Render it with full 360-degree fish eye.

I’m not too happy with the color scheme here. But, I’m done futzing with it for the time being.

Top matter sorts of stuff…

(require :asdf)
(asdf:operate 'asdf:load-op 'cl-openmpi :verbose nil)
(asdf:operate 'asdf:load-op 'portable-threads :verbose nil)
(asdf:operate 'asdf:load-op 'com.nklein.rt :verbose nil)
 
(defvar dpd 5.0)
 
(defvar spring-color (rt:v 1.0 1.0 0.0 1.0))
(defvar band-color (rt:v 0.0 1.0 0.0 1.0))

Springs and points

(defun spring-color-banding (&key position)
  (if (plusp (cos (coerce (* 8.0 pi (max (aref position 0) 0.0))
			  '(single-float -10000.0 10000.0))))
      spring-color
      band-color))
 
(defun draw-spring (spring)
  (let ((start (first spring))
	(end (second spring)))
    (let ((length (* 0.5 (rt:magnitude (rt:v- start end)))))
      (rt:with-translation (rt:v* (rt:v+ start end) 0.5)
	(rt:with-look-at start
	  (rt:with-scaling (rt:v length 0.125 0.125)
	    (rt:with-color (rt:c #'spring-color-banding
				 :diffuseness 0.8
				 :specularity 0.2)
	      (rt:cylinder :round-dimensions '(1 2)))))))))
 
(defun draw-point (point)
  (rt:with-translation point
    (rt:with-scaling (rt:v 0.25 0.25 0.25)
      (rt:with-color (rt:c (rt:v 1.0 0.0 0.0)
			   :diffuseness 1.0
			   :specularity 0.1)
	(rt:sphere)))))

The universe in which these springs sit…

(defun my-universe (springs points)
  (rt:universe (:spatial-dimensions 3
		:color-dimensions 4
		:ambient-light (rt:v 0.3 0.3 0.3)
		:sky-color (rt:v 0.3 0.5 0.9))
 
    ;; put some lights out there
    (rt:with-translation (rt:v 0.0 -5.0 -2.0)
      (rt:light :color (rt:v 0.7 0.7 0.7)))
    (rt:with-translation (rt:v 0.0 5.0 4.0)
      (rt:light :color (rt:v 0.7 0.7 0.7)))
 
    ;; put the springs and points out there
    (mapc #'draw-spring springs)
    (mapc #'draw-point points)
 
    ;; put some cameras and a backdrop out there
    (let ((eye-position (rt:v -1.0 0.25 0.75))
	  (eye-offset (rt:v 0.0 0.25 0.0))
	  (aspect (rt:v 1.0 1.0))
	  (field-of-view 360.0))
      (rt:with-translation eye-position
	(rt:with-look-at (rt:v 0 0 0)
	  (rt:with-translation (rt:v* eye-offset -1.0)
	    (rt:camera :name :main-camera-l
			     :aspect aspect
			     :field-of-view field-of-view))
	  (rt:with-translation (rt:v* eye-offset 1.0)
	    (rt:camera :name :main-camera-r
			     :aspect aspect
			     :field-of-view field-of-view)))))))

Actually rendering the universe…

(defun render-viewpoint (base-name extension camera-name universe)
  (let ((name (make-pathname :name (concatenate 'string base-name extension)
			     :type "png")))
    (format t "NAME: ~A~%" name)
    (rt:render-png :dots-per-degree (rt:v dpd dpd)
		   :border 1
		   :border-color (rt:v 0.0 0.0 0.0 0.0)
		   :universe universe
		   :filename name
		   :camera-name camera-name)))
 
(defun render-universe (base-name universe)
  (render-viewpoint base-name "-l" :main-camera-l universe)
  (render-viewpoint base-name "-r" :main-camera-r universe))
 
(defun render-files (files)
  (rt:with-workers (1)
    (dolist (filename files)
      (unwind-protect
	   (with-open-file (in filename :direction :input)
	     (let ((springs (read in nil))
		   (points (read in nil))
		   (name (pathname-name filename)))
	       (let ((uu (my-universe springs points)))
		 (render-universe name uu))))))))
 
(render-files (rest sb-ext:*posix-argv*))
 
(sb-ext:quit)

First decent images from my new raytracer

pat — Thu, 25 Sep 2008 23:13:40 +0000

Some time ago, I wrote an n-dimensional raytracer in C++. It does a fair number of things, none of them efficiently, most of the rigidly.

There are a bunch of things that I wanted to do with it for a long time, but it’s been too slow and rigid to make any of those things fun.

Enter Lisp. As soon as it made it through my skull that Lisp is actually compiled (honest-to-goodness your-CPU instructions), I wanted to rewrite the whole thing in Lisp. I have finally gotten started on doing that. And, I just made it to the point where I’m actually tracing rays. Here is a stereo pair of a three-dimensional scene:

It use’s xach‘s ZPNG library for output, my OpenMPI library for sharing work across machines, and a thin layer that I wrote on top of Portable Threads for threading within a machine.

It doesn’t yet do reflections and refractions, directional lights, or most of the shapes that my old raytracer does.
But, it’s already got multithreading, MPI, more meaningful camera parameters, and functional color characteristics.

So, here’s the source code that generated the above images. Note that the one sphere has checkboarded diffuseness and the other has gradated phong-exponent and positional coloring.

(defun make-checkerboard-func (a b)
  #'(lambda (&amp;key position)
      (let ((sum (reduce #'+
			 position
			 :key #'(lambda (vv)
				  (if (&lt; 1.0 (mod vv 2.0)) 1 0)))))
	(if (evenp sum) a b))))
 
(defun my-universe ()
  (rt:universe (:spatial-dimensions 3
		:color-dimensions 3)
    (let ((look-at (rt:v 18.0 0.0 0.0))
	  (eye-offset (rt:v 0.0 0.25 0.0))
	  (aspect (rt:v 16.0 9.0))
	  (field-of-view 120.0)
	  (object-scale (rt:v 3.0 3.0 3.0))
	  (x-axis (rt:v 1.0 0.0 0.0))
	  (y-axis (rt:v 0.0 1.0 0.0))
	  (z-axis (rt:v 0.0 0.0 1.0))
	  (angle 10.0))
      (rt:with-transforms (:translation (rt:v* eye-offset -1.0)
			   :look-at look-at)
	(rt:camera :name :main-camera-l
		   :aspect aspect
		   :field-of-view field-of-view))
      (rt:with-transforms (:translation (rt:v* eye-offset 1.0)
			   :look-at look-at)
	(rt:camera :name :main-camera-r
		   :aspect aspect
		   :field-of-view field-of-view))
      (rt:with-translation (rt:v 0.0 -5.0 -2.0)
	(rt:light :color (rt:v 0.7 0.7 0.7)))
      (rt:with-translation (rt:v -10.0 -5.0 8.0)
	(rt:light :color (rt:v 0.7 0.7 1.0)))
      (rt:with-transforms (:translation look-at
			   :scaling object-scale
			   :look-at (rt:v 0.0 0.0 0.0)
			   :translation (rt:v 0.0 0.0 -1.0)
			   :rotation (x-axis y-axis angle))
	(rt:with-transforms (:translation (rt:v 0.0 -1.5 0.0)
			     :color-scaling (rt:v 0.75 0.75 0.75)
			     :color-rotation (y-axis z-axis angle))
	  (rt:with-color (rt:c (rt:v 0.2 0.8 0.2)
			       :diffuseness (make-checkerboard-func 0.2 0.6)
			       :specularity 0.4)
	    (rt:sphere)))
	(rt:with-transforms (:translation (rt:v 2.0 2.0 1.5)
			     :scaling (rt:v 1.5 1.5 1.5)
			     :color-translation (rt:v 0.0 0.2 0.0))
	  (rt:with-color (rt:c #'(lambda (&amp;key position)
				   (map 'vector #'abs position))
			       :diffuseness 0.6
			       :specularity 0.4
			       :phong-exponent #'(lambda (&amp;key position)
						   (+ 10
						      (abs (* 100
							     (aref position 2)
							     )))))
	      (rt:sphere)))
	(rt:with-rotation (x-axis y-axis angle)
	  (rt:with-translation (rt:v -15.0 0.0 0.0)
	    (rt:with-color (rt:c (rt:v 0.8 0.2 0.2))
	      (rt:halfspace :name :hspace1))))))))
 
#+:openmpi
(mpi:init)
 
(rt:with-workers (1)
   (let ((uu (my-universe))
	 (dpd (rt:v 2.0 2.0)))
     (rt:render-png :dots-per-degree dpd
		    :universe uu
		    :filename #P"output-l.png"
		    :camera-name :main-camera-l)
     (rt:render-png :dots-per-degree dpd
		    :universe uu
		    :filename #P"output-r.png"
		    :camera-name :main-camera-r)))
 
#+:openmpi
(mpi:finalize)

And, here are the same images swapped for those of you who prefer cross-eyed stereo pairs:

rt v2.7.2007.05.17

pat — Thu, 17 May 2007 15:45:04 +0000

The documentation
The source code
The feature set now includes:
- Phong shading, reflection, refraction
- Functional textures (including textures generated by
  raytracing other scenes)
- Cylinders (including spheres and cubes)
- Quadratic surfaces
- Regular polytopes
- Halfspaces
- Convex hulls of a sets of points
- Extrusions of lower-dimensional objects
- Intersections, unions, and complements
- Different colors for k-dimensional subfacets
  of convex hulls and coxeter polytopes
Here are some sample images:
- A stereo pair of slices of some 24-cells along with the input file. The vertexes (0-facets) are pink, the edges (1-facets) are dark gray, the faces (2-facets) are yellowish, and the facets (3-facets) are green.
- Some 3-D polytopes with edges and vertexes colored differently and the input file.