Update readme files.

Author: blendmaster

README.md

@@ -1,5 +1,16 @@
 # geoid
 
-An augmented reality globe through your android device's camera! Radical, dude!
+An augmented reality globe application in Python and OpenCV, as well as a ocean current visulization project in Javascript/WebGL.
 
-This is Steven Ruppert's final project for **EGGN 512 Computer Vision** in the Spring 2013 semester at the Colorado School of Mines.
+These are Steven Ruppert's final projects for **EGGN 512 Computer Vision** and **CSCI 547 Scientific Visulization** in the Spring 2013 semester at the Colorado School of Mines.
+
+## Contents
+
+* The `android` directory contains an Android application that draws a camera frame through OpenGL ES 2.0.
+* The `images` directory contains older training images, not used.
+* The `octave` directory contains some code to pull and process the ocean dataset from ECCO2 for the WebGL project.
+* The `python` directory contains the main AR globe application and supporting code.
+* The `training` directory contains raw and cropped training images for the `geoid.py` program in the `python` directory.
+* The `webgl` directory contains the ocean current visualization program, also hosted at <http://blendmaster.github.io/geoid/>
+
+View the README.md in each folder for more details

python/README.md

@@ -0,0 +1,23 @@
+# geoid.py
+
+`geoid.py` connects to either a camera attached to your computer or a video file, such as `test.ogv`, and attempts to augment a globe with a virtual overlay.
+
+You'll need OpenCV 2.5.4 and Python 2.7.2 installed.
+
+Run:
+
+    python geoid.py -h
+
+To list options.
+
+To run against the training images and test video included in this repository, run:
+
+    python geoid.py ../training/cropped -v test.ogv
+
+## record.py
+
+`record.py` captures webcam frames and records them to `output.mpg`.
+
+## train.py
+
+`train.py` will save an image from the camera called `train-{n}.jpg` every time the spacebar is pressed.

python/geoid.py

@@ -232,7 +232,7 @@ def filter_matches(kp1, kp2, matches, ratio = 0.75):
   camera_intrinsics = K(w, h)
 
   vis = img
-  g = grid_img.copy()
+  #g = grid_img.copy()
 
   img_keypoints, img_desc = image_detector.detectAndCompute(img, None)
   if img_desc != None: # if there are any keypoints
@@ -251,13 +251,13 @@ def filter_matches(kp1, kp2, matches, ratio = 0.75):
         xg, yg = known_kp.pt
 
         # draw kp on output
-        cv2.circle(vis, (int(xim), int(yim)), 2, know.color, -1)
+        #cv2.circle(vis, (int(xim), int(yim)), 2, know.color, -1)
 
         # draw original on grid
-        p = (int((xg / ksize * fgrid) + know.j),
-             int((yg / ksize * fgrid) + know.i))
-        grid_points.append(p)
-        cv2.circle(g, p, 2, know.color, -1)
+        #p = (int((xg / ksize * fgrid) + know.j),
+             #int((yg / ksize * fgrid) + know.i))
+        #grid_points.append(p)
+        #cv2.circle(g, p, 2, know.color, -1)
 
         image_points.append(img_kp.pt)
         object_points.append(known_globe_point(known_kp.pt, know.lat, know.lon))
@@ -293,17 +293,17 @@ def filter_matches(kp1, kp2, matches, ratio = 0.75):
 
         radius = int(np.sqrt((x_c - x_n)**2 + (y_c - y_n)**2))
 
-        cv2.circle(vis, (int(x_c), int(y_c)), radius, (255, 0, 0), -1)
+        #cv2.circle(vis, (int(x_c), int(y_c)), radius, (255, 0, 0), -1)
 
-        for i in inliers:
-          xim, yim = image_points[i]
-          color = point_colors[i]
-          p = grid_points[i]
+        #for i in inliers:
+          #xim, yim = image_points[i]
+          #color = point_colors[i]
+          #p = grid_points[i]
 
-          cv2.circle(vis, (int(xim), int(yim)), 5, (0, 0, 0), -1)
-          cv2.circle(vis, (int(xim), int(yim)), 2, color, -1)
+          #cv2.circle(vis, (int(xim), int(yim)), 5, (0, 0, 0), -1)
+          #cv2.circle(vis, (int(xim), int(yim)), 2, color, -1)
 
-          cv2.circle(g, p, 5, (0,0,0), 1)
+          #cv2.circle(g, p, 5, (0,0,0), 1)
 
         #[[est_x], [est_y], [est_z]] = tvec
         #[[est_rx], [est_ry], [est_rz]] = rvec
@@ -316,32 +316,32 @@ def filter_matches(kp1, kp2, matches, ratio = 0.75):
         #print "dot(eye, norm):", np.dot(np.array([-est_x, -est_y, -est_z]), norm)
 
         ## draw equator/prime meridian
-        for j in range(-90, 90, 5):
-          x, y, z, _ = surface_point(0, j, model_globe)
-          [[[x_im, y_im]]], _ = cv2.projectPoints(np.array([(x, y, z)]), rvec, tvec, camera_intrinsics, None)
+        #for j in range(-90, 90, 5):
+          #x, y, z, _ = surface_point(0, j, model_globe)
+          #[[[x_im, y_im]]], _ = cv2.projectPoints(np.array([(x, y, z)]), rvec, tvec, camera_intrinsics, None)
 
-          x2, y2, z2, _ = surface_point(0, j + 5, model_globe)
-          [[[x_im2, y_im2]]], _ = cv2.projectPoints(np.array([(x2, y2, z2)]), rvec, tvec, camera_intrinsics, None)
+          #x2, y2, z2, _ = surface_point(0, j + 5, model_globe)
+          #[[[x_im2, y_im2]]], _ = cv2.projectPoints(np.array([(x2, y2, z2)]), rvec, tvec, camera_intrinsics, None)
 
-          cv2.line(vis, (int(x_im), int(y_im)), (int(x_im2), int(y_im2)), (255, 0, 255), 2)
+          #cv2.line(vis, (int(x_im), int(y_im)), (int(x_im2), int(y_im2)), (255, 0, 255), 2)
 
-        # prime meridian
-        for j in range(-90, 90, 5):
-          x, y, z, _ = surface_point(j, 0, model_globe)
-          [[[x_im, y_im]]], _ = cv2.projectPoints(np.array([(x, y, z)]), rvec, tvec, camera_intrinsics, None)
-          x2, y2, z2, _ = surface_point(j + 5, 0, model_globe)
-          [[[x_im2, y_im2]]], _ = cv2.projectPoints(np.array([(x2, y2, z2)]), rvec, tvec, camera_intrinsics, None)
+        ## prime meridian
+        #for j in range(-90, 90, 5):
+          #x, y, z, _ = surface_point(j, 0, model_globe)
+          #[[[x_im, y_im]]], _ = cv2.projectPoints(np.array([(x, y, z)]), rvec, tvec, camera_intrinsics, None)
+          #x2, y2, z2, _ = surface_point(j + 5, 0, model_globe)
+          #[[[x_im2, y_im2]]], _ = cv2.projectPoints(np.array([(x2, y2, z2)]), rvec, tvec, camera_intrinsics, None)
 
-          cv2.line(vis, (int(x_im), int(y_im)), (int(x_im2), int(y_im2)), (0, 255, 255), 2)
+          #cv2.line(vis, (int(x_im), int(y_im)), (int(x_im2), int(y_im2)), (0, 255, 255), 2)
 
-        ## draw edge of globe
-        for j in range(0, 360, 5):
-          x, y, z, _ = surface_point(j, 90, model_globe)
-          [[[x_im, y_im]]], _ = cv2.projectPoints(np.array([(x, y, z)]), rvec, tvec, camera_intrinsics, None)
-          x2, y2, z2, _ = surface_point(j + 5, 90, model_globe)
-          [[[x_im2, y_im2]]], _ = cv2.projectPoints(np.array([(x2, y2, z2)]), rvec, tvec, camera_intrinsics, None)
+        ### draw edge of globe
+        #for j in range(0, 360, 5):
+          #x, y, z, _ = surface_point(j, 90, model_globe)
+          #[[[x_im, y_im]]], _ = cv2.projectPoints(np.array([(x, y, z)]), rvec, tvec, camera_intrinsics, None)
+          #x2, y2, z2, _ = surface_point(j + 5, 90, model_globe)
+          #[[[x_im2, y_im2]]], _ = cv2.projectPoints(np.array([(x2, y2, z2)]), rvec, tvec, camera_intrinsics, None)
 
-          cv2.line(vis, (int(x_im), int(y_im)), (int(x_im2), int(y_im2)), (255, 255, 255), 2)
+          #cv2.line(vis, (int(x_im), int(y_im)), (int(x_im2), int(y_im2)), (255, 255, 255), 2)
   dt = clock() - t
 
   total_time = total_time + dt
@@ -350,7 +350,7 @@ def filter_matches(kp1, kp2, matches, ratio = 0.75):
   draw_str(vis, (20, 20), 'time: %.1f ms' % (dt*1000))
 
   cv2.imshow('camera', vis)
-  cv2.imshow('training', g)
+  #cv2.imshow('training', g)
 
   if 0xFF & cv2.waitKey(5) == 27:
     break