Ron Paul is a tool. This is one politician that I really don't agree with on anything. To start things off, he is socially conservative. I'm pretty socially liberal. I want women to control whether or not they have to go through bringing a child into this world, and I would love it if more people would help gays adopt children. etc. etc. This isn't really the point of what I am writing, however. What really bugs me about Ron Paul is that it seems to me that he believes that this country was perfect about 100 years ago, and all we need to do is roll back everything and we will be good to go.

I don't think this is real conservatism. This kind of thinking is about idealizing the past, and being comfortable with going back to how things used to be. True conservatism is about keeping the status quo. As opposed to liberalism which is about change, and doing things that probably have never been done before. 

We can think of these three paradigms as past, present, and future: radical conservatism, conservatism, and liberalism. I think Ron Paul's kind of conservatism is easy to dismiss. The fact is that we have tried it before, and what we are doing now is probably better. Almost every generation of Americans has had a better standard of living than the generation before them. It didn't get like that from us moving radically backwards every time we have a problem. Radically is an important modifier there, because people like Ron Paul are quite radical. Instead of adjusting and fixing what we have, they want us to throw it all out.

Conservatism, on the other hand, is probably the most natural of viewpoints for most people. We can handle the status quo pretty easily, even if we know it isn't ideal. The unknown is scary to most people. Change is feared. It makes us uncomfortable. It gives us anxiety. Our conservatism has probably worked very well for us in many situations throughout human history. The problem comes when people irrationally hold onto the status quo. When people irrationally fear change. Subsequently, those who hold onto the title of conservative are more likely to be intellectually lazy and reason from a more emotional perspective. Conservatives do not need to be rigorous and objective, they have powerful emotional tools at their disposal, which many of them use indiscriminantly and sometimes despicably.

Liberalism, has its own set of problems. Because we are exploring the unexplored, there is of course the possibility of going astray, of making things worse. Even if you don't make things worse, you have people like Ron Paul who idealize the past and then it looks to them like you have made things worse. Liberalism requires the most intelligence, the most imagination, and the most diligence. Liberals must find real, robust solutions to problems that are more than a conservative adjustment. They must share their imagination, their vision of their solution with others and they must be eloquent enough for others to see their vision and see it working. It is a difficult job to have vision. It requires bravery to lead a country through intense changes. The problems that we have now are problems that civilization has had for millenia; there aren't anymore low-hanging fruit in a world of six billion people.

And we do have problems. Many people are content with their lives because the world they live in--their job, their house, their family--is pretty damn good as is (this is probably the main reason why rich people are more often conservative than liberal). What about health care? What about the increasing division between rich and poor? What about the burdensome spending of our military-industrial complex?

The point is, there is a time to be conservative, and it is when we have checked off all of our big problems. After that we can elect people like George Bush and let them play golf and mend fences for their entire term. Then there is a time to be liberal, and that is when the status quo is not acceptable, not sustainable, or simply not the best we can do. Most people would agree that our current status quo fits all three. This is not the time to elect intellectually lazy geriatrics with ignorant apocalypticist running mates. This is the time to elect a smart president who actually has a chance at solving or at least improving many of our collective problems. The country has been mismanaged by silly old men for eight years now. The status quo is the last thing that we need.

This project's main purpose was to become more familiar with VTK, and TCL/TK, as well as gain some skill at hacking data formats.

Part 1 : Height Fields

With this part of the assignment we plotted two different data sets as height fields. The first data set was a fragmented R2->R1 function, with both sets of values stored in separate files. All I had to do was read the two files in and then combine them into a set of 3d points. These points were then triangulated, and a picture was drawn from this 3d data. This part of the assignment was relatively easy, because all I had to do was modify, very slightly, a file on the class webpage. What I ended up with was imageWarp1.tcl, and the images below, which I am not sure whether or not they are correct.

The second set was a 2D gray-scale image. The values at each pixel were used to create a third-dimension of height data. This image took even less editing of a file, again available on the class webpage. The results are below.

Part 2: Contour Maps This second part of the assignment was much more challenging. With this part of the assignment, reading in the data files and converting then plotting them was the trivial part. The challenging part was then to program a GUI to select one of two data-sets, and to change the values which control the image, interactively. TK is a pretty straight-forward software package, and after a little internet searching, I was able to build a pretty good-looking GUI. I decided to fix the 3d view, seeing as the contour maps are both 2d. This trivial simplification, made for a lot cleaner user interface. One thing I would like to change, but haven't figured out yet, is the initial slider values. I would like them to actually have viewable values when the application is opened up, so that the user doesn't have to change the values just to see an image. I'm sure I will figure out how to do this in future projects. Again, all the methods used are pretty standard and straight-forward. After a very brief search, I found all of the VTK filters I needed, I just needed to build in the user interface to interact with these filters. The results are at contour.tcl, and a screenshot of the program can be seen to the right. Questions Q What properties does a dataset need to have in order to have contour lines that make sense (and contribute to the visualization)? A It needs to be continuous and fairly smooth in all of its dimensions. Data that doesn't fit this criteria will make contour lines that don't "make sense." A noisy data set with only high-frequency data will produce contour lines which really don't tell you anything since most of this high-frequency data will be lost with contour lines. Q Where are a few places that these properties can be found? A The data sets in this project are great examples, especially Mt Hood. I can't think of a more useful (or perhaps widely-used) application of contour lines than in cartography. It also seems like there are many more places where you might find this kind of continuity. Another data set from this project, infra-red radiation is a good source. If you think of how heat dissipates, so evenly through most of the things around us, this makes a lot of sense in a contour-map representation.

Color Maps

Part A - Interactive Color Mapping

To the left you can see my visualization of Mt Hood, with height field and color map. To create this specific image and color-map, the first step was to read in a grayscale image with VTK. The scalar values at each pixel were then extracted. Geometry was then created by using these scalar values as z coordinates, making a third dimension to this originally flat image. The color map was then created, by taking two values (this particular image was done in RGB color space) and stepping between them with a simple for loop, and interpolating values for each R, G, and B channel linearly. Finally, this newly created color map is aplied to the height field. In vtk functions, the process went like this: ->read file ->vtkImageMagnitude (extract scalars) ->vtkImageDataGeometryFilter(put magnitude into geometry) ->vtkWarpScalar(warp magnitude values by certain amount) ->vtkMergeFilter(Merge geometry with scalars) ->vtkElevationFilter(Set values for color assignment range) ->vtkPolyDataMapper(map color map onto data)

This visualization to the right differs from the Mt Hood image, in that we are now working in HSV color space (This is the default visualization, currently saved by the saveView.tcl file). This image, by limiting the scale only to hue changes, shows well the change between positive and negative, by using mostly two colors, and blending between them in a very distinct, abrupt way. It also differs from the Mt Hood data in the fact that this data did not come from an image, but a set of discrete data samples, which then had to be triangulated to form a solid surface. What do you think works best, or what are the benefits of the different approaches? (with/without height fields) It seems to me that for certain data, it helps a lot to convert the data into a height field, especially for data that makes sense as one solid surface (such as the Mt Hood data). The height field in combination with color map shows you elevation information you probably wouldn't be able to visualize as well with just one or the other. The Thorax data doesn't seem to benefit too much from applying the height field, but at the same time, applying the height field does not seem to hinder the data. I think the height field is usually worth just the extra level of interactivity you get by having a third dimension. Which one is better? What are the differences? (RGB vs HSV) I find the HSV color model much more intuitive. It seems a lot easier to get a good color scale by using the HSV sliders than by using the RGB sliders. Pretty much any combination of extremes with HSV will give you a good color scale. Also, tweaking the scale to get the image to look better is much easier in HSV. The advantage to RGB seems to be the ease of creating complementary color schemes relatively easily. Like the blue/yellow, magenta/green, etc. scales. It all really depends on your data. However, it seems a lot harder to get a nice discretized-looking scale in RGB, when in HSV all you have to do is make a Hue scale.

Part B - Extra Data set

tell us what your images show in it I found it relatively difficult to find free scientific visualization data on the internet, but ultimately, I came across a grayscale .jpg of ocean elevation data around the South Atlantic and Indian Oceans. I found a Photoshop plug-in and converted this .jpg to a .pgm file. After that, the process was identical to visualizing the Mt Hood data. I kind of like the idea of having a blue color for where the ocean is supposed to be, and a more brown color for the land. I think that this yellow-blue color map worked out pretty well in dichotimizing the land and ocean, while still giving a good sense of the depth of the ocean floor in certain areas. I think that if the elevation data for land were not completely flattened out, this visualization would not be nearly as effective. In the end, this visualization is great at identifying the deepest parts of the ocean.

Part C - Bivariate Color Mapping

This part of the assignment involved using a color map which is bivariate. Using a bivariate color map on a data set, allows you to attempt to display an extra dimension of information at each point that is colored. I played around with quite a few bivariate color maps, but couldn't find too many that worked that well (In letting you visualize more data than a normal color map). Since VTK does not support bivariate color maps, you have to sort of hack it. Basically, you just create a very big univariate color map, but treat it like it is just a bivariate map whos rows have been collapsed down into one big long row. All you need to do is just figure out how to index into this one-dimensional array in a two-dimensional way, this is done pretty easily with a pair of nested 'for' loops, with one loop counting rows and the other columns.

document which one is best

I like the bivariate map I used below, because the two colors are easily discerned between, so that when you look at the image you can tell exactly which directions the gradients of Mt Hood's surface are increasing. This kind of color map, where the direction of the variance in color is easily discernable, seems to work much better than a bivariate color map which is more focused on showing correlations between two sets of data. Showing a correlation isn't really necessary at all in this Mt. Hood data set. I think the color map can be improved by mapping this specific data to a greater range of values, perhaps in a non-linear way.

MORE IMAGES:

Isosurfaces

Files Submitted:

isoSurface.tcl - Both programs for this assignment in one, with GUI to switch between modes
REPORT.html - this document
*.png - output images

Two Isosurfaces

Here you can see both the skull and face isosurfaces extracted from the volume data. The skin has an alpha value of .55. Which isosurfaces look the most interesting, and how did you find them? The isosurfaces that look the most interesting are the ones that show solid, whole structures of the volume data. This is why isosurfaces work so well on this head data set, because the skull can be separated out of the volume data well, and so can the shape of the head. I found these surfaces by creating a slider in my GUI which changed the isosurface currently viewed. This slider can really only be used interactively on the smaller data sets. It is much too slow on the full sized version of the data. I just slid the slider until I found a point where a nice solid structure was visible. To create these isosurfaces, I just used the vtkContourFilter, and then fed this data into the vtk mapper, then a vtk actor.

Univariate Curvature Color Maps

In these next images I have used univariate color maps derived from curvature data to color the isosurfaces with. The first two images below use only the magnitude of the principle curvatures (i.e. sqrt(k1*k1+k2*k2)). While the second two images use the mean curvature (i.e. 1/2*(k1+k2)). In addition to creating the isosurvaces as above, the vtkProbeFilter function had to be used after the contour filter to apply the color maps to the isosurfaces.

Describe how the two values relate to the shape of the iso surface.

With the curvatures magnitude images the color values on the surface are quite easy to decode. As the colors move from cyan to red on the hue scale, we get increasing curvature magnitude. The closer to red you are on the hue scale, the more "curved" the surface at that point is.

With the mean curvature values, we can tell much more about the surface at these points. I used a hue scale that does not wrap around. From this data we can establish a relationship between k1 and k2. We need the extra physical data the isosurface offers us because with the mean curvature, unique physical characteristics will get mapped to the same color. For example, a flat plane and an equal-but-opposite curvature saddle point will be colored the same. The mean curvature, with my hue map, really discretizes the various areas of this isosurface, so you can get a quantitative idea of curvature behavior on the surface.

What do you think works best, or what are the benefits of the different approaches?

I think with this familiar face model, that the curvature magnitude image works much better than the mean curvature images. I don't think this would be true for an isosurface of something I am not so familiar with, or haven't seen before. Just looking at the 3d rendering of the face and skull, you can get a good idea of where the saddle points, valleys, peaks, etc. are, and the curvature magnitude color map lets you get a good idea of where the surface changes dramatically. The mean curvature maps just add too much mess and redundancy to the data. However, with less familiar data, I think the mean curvature color map would be more helpful. It definately differentiates convex and concave surfaces quite well from each other, something the magnitude color map can't do.

Face Isosurface with Curvature Magnitude Hue Color Map

Skull Isosurface with Curvature Magnitude Hue Color Map

Face Isosurface with Mean Curvature Hue Color Map

Skull Isosurface with Mean Curvature Hue Color Map

Volume Rendering

Color Compositing Transfer Functions

Here you can see a comparison between two renderings: one directly rendered from volume data with some transfer function(above), and one where two sets of isosurfaces have been triangulated from volume data, and then rendered(below). This volume renderer casts rays into the scene, and intersects voxels. The transfer function takes the values at these intersected voxels and assigns a color and opacity to each pixel, as a composite of the transfer function value at every voxel intersected along a ray. Describe your transfer functions, what relationship do they have to the isovalues shown in your isosurface rendering? This particular transfer function maps opacity values of 0-0.05 to voxel values 30-70, linearly. It then spikes up to opacity 0.7 at voxel value 100. The color moves linearly between a light brown to white, from voxel values 25.0-100.0. This transfer function attempts to show the skull isosurface shown in my isosurface rendering, by spiking the opacity right around 100, the value of this isosurface. It also shows some of the mummy wrappings by slowly increasing throughout the range of these isovalues. Do you think volume rendering the mummy dataset offers a clear advantage over isosurfacing? For this particular dataset, I do believe that volume rendering shows a clear advantage over isosurfacing. For the last project, the skull and skin were much better defined. Isosurfacing is good at bringing out these solid, well-defined volumes. However, for this mummy data, the skull is much more fractured and un-even. Also, the wrappings around the skull are uneven and hard to see a shape in. The volume rendering of the mummy presents a much more solid, less-noisy image of the skull. You can get a real feel for the shape of the skull. Unlike in the isosurface image, where the surface is noisy and fractured.

Maximum Intensity Projection Renderings

To the right we have a comparison between maximum intensity projection (MIP) volume rendering (above) and composite volume rendering (below). We have seen composite volume rendering above. Composite volume rendering involves compositing the transfer function value for each voxel along a ray. MIP volume rendering involves just displaying the voxel with the maximum intensity along any given ray. What are some advantages and disadvantages of MIP versus compositing-based volume rendering? You can see that in the MIP image you lose a sense of a third dimension. It seems as if the mummy data has been flattened, probably because you can see through everything, and it looks kind-of like an x-ray. However, when you can interact with the MIP rendering, the rendering regains this third dimension. The MIP image is more clear than the composite volume rendering. If the dense parts of the volume data are what you are interested in, MIP is definately the algorithm you want to use. Basically, MIP cleans up the rendering by emphasizing this one attribute of the data. However, you kind of lose the solid structures of things, since you can see through some of the data. The teeth blend together, as does the skull. Again, though, this seems to be remedied by making the rendering interactive. What you do lose are interesting non-dense characteristics, like the ears and eyeballs. In some instances, these are probably every bit as interesting as the bone structure.

Vector Fields

1. Test Volumes

	This first test volume clearly shows a source critical point with glyphs.
	This second test volume shows a saddle point with streamlines.
	This third test volume shows a spiral sink point with streamlines, all three critical points in each test volume are at (15, 15, 15).

2-4. Challenge Volumes - Critical Points

The first challenge volume has 3 critical points.
The second challenge volume has 5 critical points.

5. Critical Point Visualizations

Volume 0, CP2 For this volume I chose stream lines, since it is a saddle point. I found all of these critical points by moving a small cube with an XYZ GUI widget. Also, I used the VTK PointSrc class to create groups of random points in sphere of space. With these streamlines, the points were then used, with vector data, to do integration with.
Volume 0, CP1 This point is a source. I did not use glyphs, so with this visualization, you have to take my word for it. In a larger visualization, you could spot this critical point by the colors around it. The red objects in this image, as in the last, are the critical points. The small dot off in the distance is the same saddle point pictured above.
Volume 1, CP4 In this critical point from the second challenge volume, I have decided to use glyphs to ensure that you can tell that this is a source critical point, and not a sink. The glyphs use the same point source as the streamlines, however, there is no integration here. Probably, a point is paired up with its nearest vector, and this value is used to create the glyph orientation, length and color.
Volume 1, CP2 Here we have a center node. You can see the box I use to find critical points in this picture. Also, you can see my hue color map as the streamlines are drawn closer and closer to the critical point, where in this case, vector velocity goes to zero.

6. Global Challenge Volume Visualizations

Challenge Volume 0
	This first visualization turned out alright, and I'm still not sure how to make it better. Instead of using random points to generate streamlines from, I used two parrallel planes. Together, the two planes capture all three critical points. The lines start out at points evenly placed on each respective plane. The blue streamlines originate from the bottom plane, and the yellow ones from the top. You can see the saddle point off to the left, the center point towards the bottom, and the source point almost at the middle of the image. You also get a good idea for the flow of the entire vector volume.
	Here I have added isosurfaces, to attempt to get an even more global idea of what is happening. The isosurfaces represent areas where vector magnitudes have dropped below .8047. The center point is located within the red globe at the bottom of the image. You can see the saddle point directly left of it. Also, you get a good idea of where the flow is quick, and where it is slow.
	In this third visualization of the first challenge volume, I have removed some of the clutter. You can still see both the saddle and center critical points, but now you can see how the field travels outside of these points. I created this image from only a single plane generating source points for integration.
Challenge Volume 1
	For the second challenge volume, I realized that every single critical point was on the z=20 plane. It seemed quite natural to therefore create all point sources on this specific plane. The visualization for this volume turned out much better than for the first. Here you can see the source with the four center points spinning off down the flow.
	This was a pretty flat visualization of this sample z=20 plane. I turned up the number of source points, and down the propogation of the streamlines. What you get is a visualization that stays pretty well within this plane. You can see clearly the center points in red, and the source point in green. Looking back, this visualization may have come off better with glyphs, since then you could get a better idea of the vector flow.
	This is the third and last visualization of the second challenge volume. I wanted to see what was happening outside of the z=20 plane, so I set the propogation quite high, and bumped down the number of source points. You can see that as these vectors come off the source, the loop around to all travel in almost the same direction. Also, it seems that after the center points, the vector field descends quite a bit. In general, getting good vector visualizations is a very difficult task. I found that building features into my GUI was probably the easiest way to improve visualizations. That way, you can see the results of changes interactively. Also, getting a good idea of what source points are going to produce good visualizations is very helpful. The critical points give you a very good guide as to where you should be placing your sourcepoints.

Tensor Fields

Strain Tensors

These first two images are just simple isosurfaces of the length volume of this Strain Tensor data set and the vector magnitude volume from the vector field data set, from left to right, respectively. They are both taken at value .7725. If there is some kind of correlation between these two images, I can't quite see it. It does seem like the one on the right could fit into the one on the left, however, it wouldn't be close to a perfect fit. It seems to me that the "length" of these tensors should be more visually correlated with the vector magnitude. Then again, I'm not exactly sure how these vectors relate to the tensors. I assume they are the principle eigenvectors, but I am not sure.
	The next three visualization employ both tensor glyphs, and vector glyphs. The tensor glyphs show the magnitude of the three eigenvalues, in relation to each other, as well as the direction of the eigenvectors. The box sizes and orientations encode all of this information. I colored the boxes with the vtkMergeFilter, as directed on the class webpage. The vector glyphs are simply oriented in the direction of the vector, and scaled proportional to the magnitude This particular critical point is a center point.
	This second critical point is a source.
	This third critical point is a saddle point. You can see the directions of the strain tensors and vectors change as everything around this critical point goes in, and then everything above and below goes out. Each of these visualization was created by using vtkPointSource around a critical point. Both the tensor glyphs and vector glyphs used these points. That is why there is a vector glyph paired with every single tensor glyph.
Here I have compared the streamlines from the last project, with "hyperstreamlines" from the tensor data. vtkHyperStreamline would not run on my computer, so I attempted to simulate these hyperstreamlines with the vtktubefilter. Unfortunately, with my simulations, the radius does not change, nor does the orientatiation twist. However, I think this visualization is a little bit more effective than my very cluttered streamline image. You definately get a general feel for the strain tensor flow.

Which tensor visualization technique (isosurfaces of a derived scalar, glyphs, hyperstreamlines) is the most effective, and why?
For this particular strain tensor dataset, I think the hyperstreamlines are the most effective. They can convey a global sense of the tensor data, quite clearly. The tensor glyphs were not too effective without the vector glyphs, and using these glyphs on a global scale did not work much at all. However, for the next volume, glyphs are much more effective than anything else. They seem much more suited for diffusion tensors than strain tensors.

Describe the relationship you see between the strain tensor and the local vector field.
From the critical point images, it seems like the vector field travels through the strain tensors in the direction of the minor eigenvector.

Diffusion Tensors

Here I have visualized the brain diffusion tensor data with vtkTensorGlyphs. Instead of using vtkPointSource, as in the last visualizations, I used vtkThresholdFilter with the anisotropy volume. This allowed me to display glyphs wherever the anisotropy of the diffusion tensor is high. This should filter out all of the highly-directional matter in the brain, called the white matter, where the brain pathways are. The color map is applied according to anisotropy as well. The most anisotropic part is in the center of the brain, where the two lobes are connected.
Here I have used the same tensor glyphs as above, but I have included an isosurface of the very isotropic parts of the brain. I wanted to get a good outline of the outside of the grey-matter in the brain. I have also made this isosurface transparent in the color mapping.
	These three visualizations implement all three visualization techniques: tensor glyphs, hyperstreamlines, and isosurfacing. The only addition from the last set of visualizations are my simulated hyperstreamlines. For these, I extracted the major eigenvector from the tensor data to create the streamlines, and then used the vtkTubefilter to volumize the streamlines. Again, the only drawback of this approach is the inability to change radius with changing minor eigenvectors, and the inability to see any twisting of these streamlines. However, they do show, more clearly than the glyphs alone, this very directional area of the brain.

How did you decide where to place the glyphs?
The assignment said that we were only interested in the white matter of the brain. This is the anisotropic part of the brain. We were also given an anisotropy volume, with scalar values derived from the three eigenvalues. I first used isosurfaces with a slider in my GUI to find a value that showed good separation between white and grey matter. I decided 0.5 looked pretty good. Then, I just used a threshold filter on this volume to take out all points below 0.5.

How did you determine where to start the hyperstreamlines?
I saw the highly isotropic area in my other visualizations, and then used my little cube with X, Y, and Z sliders to find the approximate coordinates of this area. I then used the vtkPointSource to create random points in a sphere around this area. My hyperstreamlines then originated from these points.

Why is tensor visualization hard?
I think the main reason why tensor visualization is so hard is because you have so much data. We can barely simulate three dimensional scalar fields of values well with volume rendering. With nine times the data, it makes sense that visualizing tensors would be an order of magnitude more difficult. The more data of each tensor you try to display, the more cluttered your visualization becomes. The more you reduce these tensors to less dimensions for visualizations, the less you can visualize from the tensor. You can't know everything that is going on in a tensor data set with a single visualization. But through interactivity and several sets of visualizations, you can accomplish this task pretty well.

My renderer can output in ppm, and rgbe. PPM is easy to code, and I had an rgbe writer from another renderer, so it was easy to put in. HDR images are nice for debugging, sometimes. None of these output format are supported in the openGL gui. You just have to hardcode them in. I will fix this in the future. I just have to get used to using opengl to only display pixels and not render anything.

This is a cropped screen shot of my openGL ray-tracing viewer

Performance template

For this program I created Shader, Lambertian, Surface, SurfaceList, Light, LightList, Camera, and PinholeCamera classes. I also made Context, HitRecord, and Scene classes, for general rendering infrastructure. My SurfaceList class has a hit function and does a linear hit search of all of the surfaces that are listed in it, when hit is called. Each surface has a shader pointer, and all my shaders will be sub-classes of the shader class. When something is hit, the shading function uses the LightList and colors the pixel. It gets information from the Scene class, the Context class, and the HitRecord class. The Scene class holds pointers to the surfaceList, lightList, etc.

This infrastructure has worked quite well for this scene, and I think it will work well for more complex scenes. I will be able to add more Shaders and more surfaces without having to change very much architecture.

Here are my two required images.

Here you can see my "creative" image. I have just added a bunch of spheres and another light, and made everything pretty symettrical. Also, I used my interactive viewer to take all of these images. You can see a screenshot of it below. As you can see, there are no widgets or sliders or anything. The only way to interact, right now, with it, is through the keyboard (for file writing), and with the mouse. The left mouse button moves the viewpoint, the middle one zooms in and out, and the right one rotates around the look-at point (used by holding down these buttons). I used GLUT, and the glut timer function to periodically update the image, every 30 ms. I still haven't done a pseudo-random pixel render-order. That is on my to-do list.

Performance Template

Required Image

Creative Image/ Extra Credit

You should be able to recognize this little piece of terrain. It is looking south at the point of the mountain. My hometown is off to the foreground and right in this image (Riverton). The 'sun' is a disk. That is why the shading is flat, and the 'moon' is a sphere. My little flying machine is made up of a triangle, a sphere, and a box. This particular height field is 1375x1044.

In this assignment, I added box, triangle, disk, ring, and heightfield to my renderer. I made disk and ring separate classes, though I don't think it matters either way. I also implemented bilinear patches to use in conjunction with my height fields, although they could be used independently. I used the box and bilinear patch intersections that were linked from the class webpage. I am using barycentric coordinates for my triangle intersection. My scenes are represented by a scene class which holds a surface list, light list, camera, and everything else needed to render any particular scene. The scene is initialized with a member function which I just hardcode all the details into, and thus have to change for every new scene.

Performance Template

Required Image

Creative Image

Extra Credit

L->R Lambertian, Phong, Cook-Torrance (with Varianing rms, color, and diffuse/specular/ambient terms

The extra credit shader I implemented is a Cook-Torrance shader. I implemented it straight off the 1982 paper. It worked out pretty well, and I even used the real Fresnel term and not the Schlick approximation. The rms term for microfacet distribution controls well how tight the highlight is. I figure since C-T can look quite diffuse and quite specular, I would include both a lambertian shader and a phong shader in my comparison images.

So I have added 4 shaders in this assignment: Phong, dielectric, and metal shading. I pretty much implemented the things right off of the class slides. Originally, my dielectric shader was just adapted from another renderer. It even already had Beer's law implemented. I had problems though, so I just started from scratch and followed the design in the class slides. I didn't implement any of the enhancements discussed in class. I may think about implementing the 'inside of' flag, but I'm not sure how much of a speed improvement it will make once I have an efficiency structure in place. I didn't implement the tree pruning, because I think, later, I will change this renderer into a path tracer. Or, I just think if the rendering is over a half second or so, it is already beyond interactive, how much, doesn't seem to matter too much anymore.

Performance Template

1 sample/pixel

9 stratified samples/pixel, Triangle Filter, 2 pixels wide

9 stratified samples/pixel, Sinc Filter, 2 pixels wide

I didn't hardcode any of this into my raytracer. I just added a couple loops to my render loop and added some temporary code for the sin function image. I didn't want to create the infrastracture to reuse samples, and I think I will just stick with the box-filter for my renderer if I am not going to reuse samples, and it is pretty easy to make an implicit box filter without having to add any extra rendering architecture. For these 9 sample/pixel images, I just did 49 samples/pixel, and then tested if the jittering made them fall within the 2 pixel wide filter (I guess the samples in the corners have a 1/4 chance of being included, and the side pixels have a 1/2 chance of being included. Which means I averaged 25 (interior) + 10 (out of 20 side) + 1 (out of 4 corner) = 36 samples/pixel (2 pixel wide filter -- still the 9 samples/pixel density))

My image is just my creative image from the last assignment. With the anti-aliasing, it looks a lot better. What I would be interested in seeing is a rendered image where you can tell the difference between a high samples/pixel box filter and maybe a high samples/pixel sinc filter. It is pretty easy to see with this well-behaved sin function. I just want to know that it is going to make a difference for a non-trivial number of standard renderings.

Performance Template

Required Image

Creative Images

I decided to implement a BVH. I was going to finish a grid too, but I had some problems, and won't have time to finish it this week. My BVH is a pretty standard binary tree, where each node has a bounding box, and pointers to two other surfaces. It is built with a standard top-down approach, by splitting the primitives into two groups along either the x, y, or z axis, and at each level of the tree this axis changes. This process recurses until there are only either 1 or 2 primitives left, at which point, the tree is built.

My creative image is a model a friend built of his wifes wedding ring. It works out to be about 100,000 triangles. I used maya to split the model into three different models, so that I could apply separate shaders to each one. However, the surrounding stones turned out to use the pretty much the same shader as the center stone, since I realized that this renderer does not have Beer's law implemented, so I couldn't make my stones different colors. They use different indexes of refraction, however, not that this is that noticable. Even with these issues, I still think the results are pretty cool. I'm not sure my friend ensured that all of these surfaces have outward facing normals, but it looks alright to me.

Performance Template

Required Image

Creative Images

I only added 2 new shader classes for this assignment: Checkerboard and MarblePhong. I also added a Texture class and a few texture sub classes, one to look up colors from an image, and one to return a solid color. In the end, however, I didn't end up using the solid color texture class. Instead, whenever I wanted to add the ability to extract colors from an image in a shader, I just added a texture pointer and set the default value to NULL in the constructor. I then have a branch in my shader to see whether or not this Phong/Lambertian/etc. shader is using a texture. I am not sure if this branching is faster than the virtual function look-up, but it was at least easier to implement.

For my creative image I decided to do a displacement mapping. I couldn't find an earth elevation image that would be easy to use for displacement mapping the earth textures we have, so instead, I used the night-lights image as a displacement map. I figure that the brightness of the area is pretty indicative of the population density. So that is what this is an image of. I think I could have gotten slightly better results if I first would have blurred the night lights image so that the data was more spread out and didn't make these very sharp peaks.

Performance Template

Required/Extra Credit Image

So it's not right, is it? I can't figure it out. I have been through each piece of code line by line at least 20 times, but to no avail. However, I did get my shadow algorithm to work, so hopefully that will make up for my colors being off.

I followed the implementation in the slides almost exactly (obviously not exactly enough). However, instead of putting my shader in a box, I made a new surface just for volume shaders. This surface had a bounding box and a special shadowHit function. The regular hit function just calls my VolumePhong shader after the bounding box has been hit. Also, since my bounding box has a function which returns both the near and far hit points I don't need to call the intersect routine twice. My shadowHit function in my Volume surface class calls a simplified attenuation function in the VolumePhong shader class. If the ray is attenuated to a dark enough opacity, then true is returned for the shadow hit function, otherwise false is returned. The VolumePhong/ColorMap classes were all done according to the class slides and the functions already written on the class webpage.

Performance Template

VolumePhong

Creative Image

Extra Credit Image

For this assignment all I had to do was create a new Instance class. My instance class behaves as described in the class slides, it is just a general instance class that stores a 4x4 Matrix. My infrastructure does not care about unit-length ray directions, so I didn't have to do anything special there. I just multiplied my ray origin by the entire matrix, and my ray direction by the upper 3x3 portion of the matrix. Then once my hit routine returned my normal and hit point, I multiplied the normal by the inverse of this upper 3x3 matrix, and the hit point by the inverse of the whole matrix.

For the extra credit image I realized my triangle class is pretty bloated (with per-vertex normals, uvs, etc), and 100 bunnies can't even fit into memory. For the second part, all I could fit were 40. The reason why my load time is so slow in the set-up time on my pre-computed performance template is that I just read the same file in 100 times, and it is an ASCII ply file, so it is quite slow. I also left the computation of per-vertex normals in my PLY reader, so this slowed the thing down even more. I was just too lazy to write a routine that takes a surface and multiplies it by a matrix, so I had to rely on the matrix that can be passed to my PLY reader.

Performance Template - Instancing

Performance Template - Pre-computed

Creative Image

Extra Credit Images

My creative image is a pretty standard-looking monte-carlo ray-traced image, except I used two shaders we have been using in our other programs. I used the phong shader on the texture-mapped globe, and I used our metal shader on half of the checkerboard. The other half of the checkerboard is my monte-carlo metal shader, so that the differences between sharp and blurry reflections can easily be seen. The other two spheres in the image are monte-carlo lambertian shaders. On the red sphere, you can see some color bleeding from the globe. All I did to create this image was add shaders to my infrastructure, shaders which recursively call my trace function instead of explicitly shading from point lights. This particular image is 400 samples/pixel.

My extra credit images show of a depth-of-field effect, easily created with monte-carlo ray tracing. I had already implemented a thin-lens camera model when I implemented my pinhole camera, so I didn't have to add anything for my extra credit images. You can see the three different levels of focus in both the triangles, and in the checkerboard plane. My extra credit images are 100 samples/pixel.

Creative Images

The first image is my backdrop for what was going to be a nice looking rainbow, something I spent 24 hours trying to get working last weekend. The ground is a texture-mapped heightfield. The heightfield is just elevation data from the web, while the texture is an aerial photo of the same area. The background is just a cylindrical map that I referenced into. I used it for shading but not lighting. There is a directional light where the sun is.

The second image shows a monte-carlo glossy surface, and environment map lighting.

The third image shows a full spectral rendering of the same scene, however, now you can see small little rainbows in the diamond. It definately adds something substantial that was missing before. The color matching isn't perfect because, in order to interface with rgb textures, I have just associated the rgb values with bins of wavelengths 400-500 for blue, 500-600 for green and 600-700 for red. Even with the crudity of this system, the color matching is still decent.

I had added quite a bit to my renderer in order to do a rainbow, but none of it amounted to any decent images, so I decided to show a few images to show the current state of the renderer, and I think they, together encompass everything this renderer can do right now.

Program 1 was a simple demonstration of anti-aliasing in ray-tracing. The geometry consists of an infinite checkerboard, colored alternatively black or white based on a two dimensional oscilating tringonometric function.

Rays were sent out from the eye, all passing through a screen rectangle, and then either hitting the geometry, or traveling too far without hitting anything. With only an infinite plane, the hit function can be generalized to work more quickly and accurately. Specifically, any ray going from the eye through the plane that is not parrallel with the tangent or binormal vectors of the plane WILL hit the plane. With a ray, a+tb, where a is the vector pointing to the eye, and b is a vector pointing to part of a pixel on our screen, we only need to take solutions where t is positive.

This is really beside the point of our first program, but it is still interesting to think about how exactly you go about intersecting a ray with an infinite plane. The point of the program was to show the incredibly high variance and slow convergence of this kind of stochastic ray tracing.

We took regular interval samples, random samples, jittered sampling, and cubic b-spline filtering each at 1, 9, 25, 100, 10000 samples per pixel. The images were all 512x384 pixels. This means that at our highest sampling frequency, we sent out almost 2 billion rays. Even with this incredibly simplistic model, the rendering with my implementation still took about 12 minutes to complete at the highest frequencies. That is about 2 million rays/second.

The point of listening all of these huge numbers is just to show you what a brute force solution ray-tracing is. It probably isn't true that 10,000 samples/pixel are entirely necessary to render this infinite checkboard perfectly, perhaps you can get away with a fourth or a tenth of that. But still, with such a simple model, if you look at the 100 samples/pixel images in my gallery, you will see how very imperfect they are. Raytracing just needs a lot of samples, that's all there is to it.

Regular Samples: Samples taken at regular intervals of a specific pixel. This kind of sampling can often hide, very consistently high-frequency information, by taking samples at intervals which are factors of the regular high frequency information.

Random Samples: Samples taken at random points within a single pixel. This method does not spread out sample points as evenly as regular sampling. It is very possible for many samples to bunch up and give redundant information, requiring even more samples.

Jittered Samples: Samples taken at regular intervals, but 'jittered' to place them randomly within a specific area. It is like dividing up any given pixel into sub-pixels, and then sampling randomly in each one of these sub-pixels. This is almost the best of both worlds of regular and random sampling, and the only thing I know of that beats it is the much more complicated poisson disk sampling, which ensures all samples are a certain distance apart, but still randomly placed within a pixel. Although, this algorithm is way too complicated for my tastes. The problem with Jittering is that, like random sampling, it still creates high frequency data from low frequency information. If you look at my Program 1 images, you will see that the Jittered sample at 1 or 9 samples/pixel still create noise very close, which is completely absent in the regular sampling images. Although, the regular sampling image have the more annoying problem of creating patters with the distant part of the plane which certainly do not exist.

Cubic-Bspline filter: Can be used on any of these sampling methods. A cubic b-spline can be implemented by summing together three randomly generated numbers in the range (-0.5,0.5). Probabilistically, these sums will produce a result with an expected value of 0, surrounded by a smooth bell curve probability density function. This has the effect of taking any regular sampling intervals, and perturbing them slightly, with less and less probability the further away you get from your regular sampling intervals.

Program 1 images

Thin-Lens Camera

Program 2 was an implementation of a simple thing lens camera. The same screen rectangle was used to create ray directions, as in the last program. However, the eye, or the origin of the ray is now perturbed slightly so as to model the depth of field effects that are unnavoidable when doing anything but pin-hole photography.

A very thin lens is modeled at the eye. Every ray which originates on this thin lens and goes through the image plane at a specific pixel, is sampling 3d space for that specific pixel. If your pixels are now seeing the world with these perturbed origin-rays, you can imagine that anything beyond this specific image rectangle will get more and more blurry the further away things are. Also, objects close to the eye and in front of our image plane will also appear blurry, as they are also being sampled by rays which do not form a straight line from the center of the eye, through the screen.

This is precisely the depth-of-field effect we are after. While it does not physically model an actual camera lens, and lacks some of the effects of real photography, it is good enough for most purposes.

The Thin-Lens-Camera is sampled at an even density throughout. This is accomplished by taking two random numbers on [0,1) and multiplying one by two pi, and by taking the square root of the other and then multiplying it by the thin-lens-camera radius. The first number becomes the azimuthal angle phi of our thin-lens disc, and the other tells us how far away from the center to sample. This second number must first be square-rooted, otherwise, there will be too many samples close to the center of our disc. Since, as you travel from the center to the outside of a sphere the area of a circle covered by a given angle increases quadratically.

Program 2 images

Naive Path Tracing

Program 3 was the implementation of a "Naive Path Tracer" with support for mirrors, glass, diffuse, and phong reflectance. As in the other two programs, rays were sent out from the eye (or thin-lens-camera), through the image rectangle, and out into the geometry of our 3d-world.

A path tracer takes these rays and bounces them off objects in the world until either a certain number of bounces are reached, or the ray hits a light. The information from this light is then recursively reflected back through the ray's adventure bouncing in the 3d-world, to the screen, where it is recorded at whatever pixel it originated. This is kind of a backwards way of looking at how light transport in the real world really works.

In the real world, light originates at lights and bounces on surfaces and through surfaces until it reaches our eye. Our eyes then interpret whatever changes have taken place to the light along its journey to our eye. Whether it be absorbtion, reflection, refraction, etc. In our naive path tracer each 3d object that is hit will perform some calculation on the light and change it in some way (If the world didn't change light at all, we wouldn't be able to see anything but the same light from all directions).

If a ray from our eye hits an object defined as glass, it will be refracted, and reflected. If a ray hits a mirror, it will be reflected, perfectly about the surface normal. If a ray hits a diffuse surface, it will be absorbed a little and reflected at some random angle, if enough of these random reflections are done at this surface, we can get a good idea of the illumination at that point. If a ray hits a "phong" surface it will be absorbed a little, and then reflected at an angle probabalistically close to the perfect angle of reflection. If after bouncing around, these rays do not hit a light source, they will not add any illumination to the pixel from which they originated. If they do, as I said before, the light will be recursively attenuated until it returns to the eye.

This kind of ray-tracer is very simple, and will give a non-biased solution to the light transport of a given scene. The calculations must be done from the eye to the lights, because you know that every single ray you send out from the eye is a visible one. The same is not true if you were to send out Rays from the various light sources in a scene and hopefully trace them back to the eye.

Program 3 images

This article is a reply to this essay, posted to our Free Thought Society website.

Basically, the proof for the events in question of Jesus life lies solely on the accounts of the New Testament gospels. There are no independent contemporary accounts, either by Jews or Romans. Jesus, himself, left us no writings. What we are left with are the New Testament gospels. The word gospel, itself, means "“good news."? Bringing into question the impartiality of these stories, since they were meant to engender faith. They were penned in Greek, anonymously by people who probably never knew Jesus. Since, Jesus' primary followers were poor, probably illiterate peasants who spoke Aramaic. They were written down from oral traditions that had been passed down for at least 35 years or so after the death of Jesus. These are hardly reliable sources. They may be enough to convey accurately the general sense of Jesus' message, but they can hardly be trusted to concretely prove his divinity.

With this characterization of the New Testament gospels in mind, I would like to address each one of your points Specifically:

The Empty Tomb

The first gospel recorded from oral traditions was probably the gospel of Mark. Originally, the story of the resurrection was conspicuously absent from this gospel. It was added later. This fact is agreed upon by almost every serious New Testament scholar. It is a convention in historical analysis to put more trust in the accuracy of more earlier sources €for obvious reasons. It is quite likely that the entire resurrection story was merely an addition by later Christians attempting to steer the theology in their preferred path.

Addressing the empty tomb directly, the gospels are fraught with a number of contradictioning descriptions about who visited the tomb, whether or not the stone was moved when they got there, the setting of the announcement of the resurrection, and the commands given to those at the tomb. If the gospels can't even agree on key facts surrounding these events, how well can we trust the gospels that these events actually happened?

Taking all this into account, your reasoning about what Christian, Jew or Roman thought about the tomb is based on false assumptions. Since this entire story probably evolved years after Jesus' death, it seems quite presumptuous to say what the Romans or Jewish aristocracy could have done. You're probably right though, if the Romans could look into the future 300 years or so, and could see what future Christians would claim happened historically, they probably would have behaved as you claimed. However, since they had no reason to believe the historical facts surrounding their crucifixion of Jesus would be in question in the future, there is no reason to believe they would take any further steps outside of executing a man they saw as a rabble-rouser.

They Died for Their Beliefs

Seeing as there were at least half-a-dozen Messiahs in Judea in the first century CE who had followers who died for their beliefs, it seems odd and unfair to hold the beliefs of followers of any one specific messiah in such irreproachable regard. Those surrounding the founding of any very-involved belief system will have extreme amounts of cognitive dissonance when it comes to looking at any facts which might contradict their strongly-held beliefs, especially when they have shared these beliefs with others, and much of their image is entangled with these beliefs. We don't know whether or not the contemporary followers of Jesus, the people who knew him, died under pain of torture for their beliefs, we do know about later Christians. Paul is a great example.

Your passage in 2 Corinthians is an account written by Paul, someone who never knew Jesus, nor was around Judea during Jesus' ministry. How could Paul possibly know whether or not what he preached was a lie or not?

Again, there really isn't anything here that would come close to establishing the divinity of Jesus Christ. We are still far from that extraordinary level of proof we require.

The Conversion of Skeptics, The Conversion of Jews & Baptism and Communion

In this case (as in others), I think you present an illusion of certainty about facts we can't possibly know for certain. Namely, how do you know 10,000 Jews joined the Christian movement? How do you know apostles who personally knew and lived with Jesus were persecuted as Paul claimed to be? How can you be so sure of the validity of Paul's conversion story? How do you know early Christians took part in Baptism and Communion? How does someone being converted from one religion to another prove its validity? If I was a Christian and then became a Muslim a generation after Mohammad's death, would Christianity be disproved?

Also, it is unclear as to how severe the sociological and theological consequences would be that you purport would face the Jews who believed in Jesus and passed on the stories of his life. From the point of view of the formation of the New Testament I described to you, it seems very likely that those who passed on these stories about Jesus could continue being Jewish in every conceivable way. Christianity itself was far more diverse before Constantine than it is now. Assuming that all of these Jews believed in Jesus the same way you believe in Jesus, namely that he was god seems presumptuous from a more historical point of view. The Jews who lived with Jesus probably spread his stories beyond Judea, where they evolved in all kinds of unpredictable ways. Many Christian churches eventually cut all ties with Judaism and even created anti-Semitic doctrines. This seems a peculiar fact in a belief structure you paint as being so homogenous.

The Swift Rise and Spread of Christianity Throughout the Roman Empire

Before the conversion of Constantine, Christianity grew at about the same rate as Mormonism has over the last 150 years. For this issue, specifically, looking at Mormonism puts the growth of Christianity into perspective. Historically speaking--probably due to better-record keeping and more falsifiable claims (i.e. Native Americans being Jewish)--Mormonism has very little to stand on. However, looking at their growth alone, you might wonder how so many people could have overlooked so much. There are dozens of reasons, and it is far more complicated than our intuition, something you want us to rely on when looking at the growth of Christianity.

The truth is, aside from perhaps two emperors over a 300 year period, Christianity faced very little in way of systematic Roman persecution. Also, most of the Christian churches grew outside of the realm of Jewish aristocratic influences. It seems valid to compare Martin Luther King Jr.'s "“I Have a Dream"? speech, perhaps to the sermon on the mount. However, the sermon on the mount is not at issue here. The resurrection story and claims of Jesus' divinity are. If these events never happened, then there is no chance for Christians to mischaracterize them. You can't mischaracterize something that never happened. If the resurrection story, as I suggest, was made up out of whole cloth, then finding people who didn't-not see Jesus resurrected is a non-sensical issue. Just like you can't find anyone who spent every hour of every day with Joseph Smith who can prove he never talked to Jesus and God.

A Reliable Record

Your argument here centers on the straw man of showing how widely and accurately copied the texts in the New Testament are. No one is debating this fact. Scholars debate whether or not we can trust the original writings contained in the New Testament themselves, not the copying process afterwards. As I stated earlier, these original writings were penned by people who probably never knew Jesus, who received these stories from much more-volatile and evolving oral traditions.

Your statements about Josephus, and earlier Roman historians merely support the idea that Christians did in-fact exist in the first and second centuries, again, something that is not being debated.

Whether or not early Christians were surrounded by bitter enemies is still very much in question. Though you continue in this presupposition with very little evidence. The persecution of such a devoted evangelist like Paul can be agreed upon. But whether or not followers of Christ--who did not go out of their way to convert others--were allowed to practice their faith in peace is unclear.

The Verdict

As you claim that there are no alternate theories which succeed in explaining all of the evidence you presented. I would like to present one now, which I think is very historically based, and a much more likely explanation of all of the facts we know, and continue to learn about.

Basically, this is what I believe about Jesus and why:

First, we have to throw out the assumption that Jesus was a revolutionary teacher who sought to change the face of Judaism in his lifetime. It makes so much more sense, historically speaking, to paint Jesus as a very Jewish preacher, who taught very Jewish things, exclusively to Jews in Judea. More than that, he was an apocalypticist preacher, an idea very common in first century Judaism. His message was one that offended specifically the Jewish Aristocracy, and was seen by the Roman governor Pilate as an unnecessary nuisance. Jesus was executed by the Romans to keep the peace during the Jewish Passover. His teachings garnered him a respectable following who spread stories of him after his death. These stories evolved over time and were used to start a new religion about Jesus, instead of one based on Jesus' teachings.

Jesus lived in a very literate time in world history. There were literally dozens of historical writings we have that were penned contemporary to Jesus, yet Jesus is mentioned in none of them. This leads me to believe that Jesus' effect on his world was much more minor than his effect on our world. To me, this rules out thinking of Jesus as a revolutionary teacher. Otherwise his teachings and life would have created more conflict in his lifetime, and hence more contemporary knowledge of his existence. His teachings and an understanding of Jewish theology of the time paint a much different picture.

Jesus spoke continually of a world ruled by evil, soon to be overthrown by god and ruled by a Messiah. Several times while teaching to large crowds he makes it known that this event will take place within their lifetime. Many people reading the New Testament may notice that the ethics of Jesus seem not to be entirely sustainable. Specifically, many of his ethics make so much more sense from the point of view of a man who thinks the world as it currently exists is about to be turned upside down. The rich would become poor and the poor rich, and all kinds of injustices would be turned around. Jesus was not unique in his apocalypticism. Studying the Dead Sea Scrolls, some first century Jewish writings, we see that these apocalyptic ideas were quite popular, especially in the repressed peasant classes.

Jesus in no way meant to replace the Jewish law with his own brand of ethics. In fact, his oft-quoted reduction of the ten commandments into two laws are in-fact merely Old Testament ideas expressed in Deuteronomy 6 and Leviticus 19. He may have drawn a sharp distinction between himself and the legalistic Pharisees, however, the Pharisees were just a sub-set of Judaism, and Jesus' disagreement with this group in no way precluded what he was teaching from remaining well within the bounds of the Jewish Religion. Jesus did not, himself, form a new Religion. The Christianity of Paul would be about Jesus and not about Jesus teachings. This was the religion which was irreconcilable with Judaism, but again, this was not what Jesus taught to his followers.

Jesus' apocalypticism also explains quite well why he was executed. Jesus taught that the rich would become poor and the poor rich. This was a direct threat to the Jewish Aristocracy, made up mostly of Sadducees. Pilate, the Roman Governor of Judea, had nothing to lose by executing anyone who might disturb the peace of the gathering in Jerusalem at Passover. There is nothing too enigmatic here. The execution of Jesus seems to follow pretty transparently from just these two facts. John the Baptist, another Jewish Apocalypticist was executed for very similar reasons.

After Jesus was executed, there is no reason to believe that all of his followers would disperse and forget about him if he did not rise from the dead and return to them. Many of these people had probably invested much of their lives in Jesus' teachings being true. These people would carry on his story and his legend as long as they still could. There are hundreds of historical examples where people behave similarly when their leader falls ahead of them. You only have to look so far as John the Baptist to find a very similar example. His followers spread his message after John the Baptist was executed. The behavior of Jesus' followers after his death was nothing unique or special. It seems to me, that if it weren't for the missionary work of Paul, and later the conversion of Constantine, Christianity would probably just be another footnote in the history of ancient Judea.

Conclusion

I have presented a version of history, I think, that not only fits the discernable facts more believably, but also fits more evenly into our knowledge of world history as a whole. The idea that the paltry amount of proof Christians have for Jesus' divinity is enough to set this one event apart from every other event in world history, as the only supernatural interference of god, is not an idea a person with any amount of healthy skepticism and faculties of rational reasoning can take seriously. Extraordinary claims require extraordinary proof. All Christians have is propaganda written decades after the events. The price we pay for accepting Christianity by such a lowered standard of proof is one that is far too great.

We have roughly 365.24 days a year, the time it takes the earth to make a complete orbit of the sun. I would like to break down the number of days in the year into equal parts. This will remove one of the inefficiencies I see with our current calendar: remembering which months have 30 days and which months have 31 days. Unfortunately, 365 doesn't break down very nicely. 365 has the very succint prime factorization of 5*73. Since, in most parts of the world, there are four distinct seasons, and I would like to represent that in my calendar somehow, the number 365 simply will not do. I'm going to work with 364.

364 breaks down into 2*2*7*13. If we want to keep something that most closely respembles our current calendar, we would have 13 months of 28 days each, with 7 day weeks. Adding in a day somewhere, along with a leap day using the current method. This has the benefit of creating months, all with the same number of days, but we have lost the ability to have an equal number of months per season, 3 for each winter, spring, summer, and autumn.

This is what I suggest: Either (1) 4 months of 91 days each, or (2) 12 months , with a 3 months pattern of 28, 28, 35 days (or 4, 4, 5 weeks). Also, the first day of the year will not be in any month, nor will it be a day of the week. It will simply be "New Years Day." Also, that night will be the winter solstice. On leap years, a day will be added exactly half of the year after New Years, which will also not be the part of any month, nor a day of the week. This may sound wonky to many, however, it comes with a very distinct advantage. Every day of the year will always be on the same day of the week. The first day of every month will always be the same day of the week. Any date in any month will always be a certain day of the week. Brilliant.

This chart is for the single deck games, no double-after-split, double-on-anything, split aces only once, and dealer hits a soft 17. For the longest time, this was the only game offered in Wendover, but I have found a few shoe and two-deck games in recent visits.

There is so much crappy software out there. There is a lot of crappy shareware software with annoying nag screens, free programs which are poorly written, and of course overpriced commercial software. For almost every case of software that you either have to pay for, or is of this annoying shareware variety, there is a nice little freeware program that does the job better. Over the years I've used a lot of different software and I think I've found the best for most of the things you'll do on a computer.

Freeware

• Web Browser: Chrome     //All the features I need, no wasted pixels
• Simple Text Editor: Notepad++     //Fast, simple, good replacement for notepad
• PDF Reader: Foxit Reader     //Faster than Adobe, less wasted pixels, not perfect
• PDF Writer: CutePDF     //Cheaper than Adobe and works well
• FTP: UltraFXP     //Haven't used this as much as FlashFXP but seems solid
• E-mail: Gmail     //Still miss folders a little, but love me my google
• Image Viewer: Irfanview     //Have only used for rare formats since Picasa 3
• Image Browser: Picasa     //Brilliant Google software, and has image viewer now
• Video Player: Media Player Classic     //Cleanest player around for windows
• Audio Player: Foobar2000     //Just plays audio files, infinitely customizable
• DVD Ripper: DVDShrink     //Program I used to rip all my DVDs, 
• Bittorrent Client: uTorrent     //Haven't switched torrent clients since I found this
• Latex Editor: WinShell     //Doesn't annoy me like other editors have
• Calculator: Emu48     //Haven't found a better RPN calculator
• DVD Movie Writer: DVDFlick     //Haven't used much, but seems simple

• Photo Editing: Photoshop
  
• FTP: FlashFXP     //Have never had problems, which is more than I can say for most FTP
• Operating System: Windows     //Good balance between do everything with Linux, and fuck you with OSX
• IDE: Visual Studio 2008     //Messy, but still better debugger and user experience than anything else I've tried