To get two synced is pretty easy once you have the networking figured out. You might want to put the scripts in your /Users/local/bin/ directory but you can put them where ever you like. Add the path to the synced directories in BOTH scripts. Now you are ready to sync. To test run the script in the terminal:

sent 38 bytes received 398811 bytes 159539.60 bytes/sec
total size is 55629350557 speedup is 139474.71
building file list … done
EngineeringProjects/mySync/DDNS_PortForwarding.png
EngineeringProjects/mySync/DDNS_PortForwarding.vsd

sent 516249 bytes received 2302 bytes 345700.67 bytes/sec
total size is 55629350567 speedup is 107278.46

Thats it! Do the same steps on the remote side for a full bi-directional sync. If you want to delete files

When the remote initializes a sync the file deletme will be deleted. Last thing is to automate the sync with a cronjob. On the terminal type contab -e and add

This set a variable so the script knows its being run from a cronjob and will not ask for user input and will sync the folder every 15 minutes.  And there you have it, virtually unlimited sync space for free!

Projects Home

With that said lets get into the code! I have two bash scripts, one to sync the data and one to properly delete files. In order to get two folders synced for the first time is enter the path to the local sync folder, the path to the remote sync folder, and the port. Remember that by default rsync does not have access to the remotes root folder only the user home directory that you log in as. The remote sync directory is relative to this directory.

The code is well commented but here is a quick rundown. When the script is ran for the first time it will create the specified directorys if they dont exist and initializes a .rsync folder which holds the system files.

Next it sets the remote “deleteLock file” to prevent any remote files from being deleted while a sync is taking place. In case files were being deleted before the lock was set, a synclock file is checked prior to checking out the deleted file list.

Once cleared the delete file list is downloaded. The files are checked to make sure the modification date and size are identical before deleting the files. This helps ensure only identical files are deleted in case of the match had been modified after a long period without syncing. After the deleted files have been removed locally, the remote list is cleared.

Finally the remote modified files are downloaded using rsync. The –copy-links and –keep-dirlinks options have been enabled as I like to selectively chose which folders to sync while maintaining the original directory structure. My sync folder typically contains soft links (ln -s ) aka shortcuts to folders I would like to have synced. Also the -a options ensures that the permissions, modified date, for example are preserved. The -u option only transfers files that are newer.

Rsync has many options which can be customized to your situation. Be sure to be careful as it can delete files on both sides.

For the delete script all you need to do is again add the local sync directory. It take the files you would like to delete as command line arguments and DOES NOT PROMPT for each deletion, so be sure you have the right files.

It is worth noting that this script does use “rm -r”! Be sure of what your deleting when using this script

next page —>

Now that ssh is enabled on both computers you need to know how to find it on the internet.  The process isnt hard and can be done for free.  The process will start with the host domain name in a nice human readable format (www.remoteHost.com), but this is no good for a computer, it likes numbers.  So using DDNS it can translate the human readable domain name to the actual ip address.  I use no-ip’s free service and run its dynamic updater on each of my machines.  This will get us to the remote router, but now the router needs to know what computer to send the request to as there usually are many devices connected to any given router.  Using port forwarding the router can be configured to forward any given port to a given computer.  We will be using sftp (ssh) which is by default on port 22 but this can can be specified.  Therefore the router will need to forward any port 22 requests to the “remote” computer illustrated below.  This is done differently depending on your router.

Now that we know how to find the remote destination we need to do this securely.  By using rsync with the -e option we can specify the use of a secure shell (SSH).  This is great but we want to do it without having to enter the password every time we want to transfer data.  To get around this we will first have to generate a set of authentication keys using ssh-keygen.  Open a terminal and enter the following:

Leave the passphrase blank. This will generate a keypair (private and public). Leave the private key in the .ssh folder and copy the public key contents into the authorized_users file in the remote .ssh folder. For example enter the following in the terminal:

You also may need to adjust the permissions to 600 if you have problems. Now you should be able to ssh into the remote computer without entering a password. Authentication is done by matching the private key with the public key automatically. Do not share the private key!

next page—>

There are a bunch of programs out there that have plenty of bells and whistles to help with this.  All I needed was something to sync specified folders from my desktop to laptop. It had to be a bi-directional sync meaning if I added or removed a file on one side the same would happen on the other.  I didn’t need backups (that was time-machine is for) or versioning (all code is kept in svn repos).  Goodsync seemed to be good but I didnt feel like paying $30 + $10 per license.  I saw freeware with poor reviews or not really bi-directional (no remote deletion).  I had been looking for a good excuse to work on my bash scripting abilities and decided this would make for a good project.

All macs come with a handy program called rsync.  It is really easy to use and solved half of the problem up front, one way sync.  If I only needed to mirror a folder I would have been done, but that is not very dropbox like.  I want to add and delete to both folders at any given time.  Rsync’s conundrum is that it cannot tell if a local missing file is because it was deleted locally or added remotely.  Linux pinguin gives a good run though of this issue.

My solution uses rsync to power the transfer and adds logic to keep track of deleted files.  A list of all local deleted files is maintained on both sides (as of now no GUI exists so files must be deleted via terminal).  When a sync occurs the remote list of deleted files is pulled and all local copies are locally deleted if they have the identical size/mod time.  Now all of the files that have been deleted on the remote side are in sync locally but the locally deleted files still exist on the remote side.  These files will not be deleted until the remote computer initializes the sync and does the same process.  To avoid downloading files that have been deleted locally and not remotely, the local list of deleted files is used to tell rysnc not to blacklist these files. The same script is ran on the remote to sync its local files.

All this is seamlessly automated by adding the script to a cronjob set for every 15 minutes ( or any time interval of you choice) and a very basic dropbox has been implemented!  Now I can transition from my laptop to desktop and back with out having to worry about manually tranfering large amounts of data.  Best of all its free with practically unlimited space!

If your interested in doing this yourself I will be posting part II with a walk through of the code and how to set up DDNS/port forwarding/sftp/authentication on the mac.  All you need to sync data securely from anywhere!

next page —>

At this point we were able to create decent point clouds with matlab.  The resulting pointclouds can be shown in matlab using the ‘mesh’ function.  To add color us the ‘caxis’ function.

The code above works but notice it does not handle cleaning up any erroneous points where no Structured Light is found (fuzzy black and white areas).   This was implemented after the code was ported to C.  Since the noise has a gaussian distribution it can be filtered out using a gaussian filter.

This cleans up the noise and provides good results.  The video below shows a better representation of the 3D model.  The noise has been greatly reduced in the blue area where no SL patterns were projected. There are a few areas that were not the best surfaces to reflect the projected light such as the glossy surface that is close to being parallel with the camera.

<–Previous     Project Home     Next –>

• Open Meshlab and open the .xyz file from the 3D camera
• Delete any points that look like they dont belong ( if you only see a small group of points you are probably zoomed out really far dude to a rogue point; delete it and zoom in)

• Orient the pointcloud so that it represents the original scene (looking straight at it).  We will now compute the normals for each point.
  • Filters->point Set->Compute Normals For Point Sets
    • # of neighbors = 100
    • Check flip normals w.r.t viewpoint
  • Render->Lighting->Light On
  • The points should now have a shading effect depending on there normal.  To verify render->Show Vertex Normals

• Lets add some color to the depth to make it stand out (darker as depth increases).  Meshlab has a tool to set color per vertex.  Use the z coordinate as a variable as shown below.
  • Filters->Color Creation and Processing->Per Vertex Color Function
  • For each of the colors adjust this formula for good results; z*0.78+125

• We should have a good looking pointcloud at this point.  We can also generate a surface mesh with our point cloud.
  • Filters->Point Set->Surface Reconstruction:Poisson
    • Set Octree Depth to 10 or so
  • The toolbar has a list of different view options.  Click the ones with cylinders on them to view in surface mode.

And there you have it!  3D picture taken with the beagleboard.  The results look pretty good for a completely portable setup and HVGA projector.  I look forward to seeing what others can do with high resolution hardware!  Thanks for reading!

<–Previous     Project Home

Contents

• Graycoded Structured Light images [20]
• Makefile  // includes links to openCV cflags and libs.  Use this to natively compile SL code.
• sl.cpp  //sl program
• slGPIO.cpp  // starting point.  Initializes GPIO interrupt and calls sl.cpp
• results folder //result go here if no SDcard is found

# 'make'        build executable file 'mycc'
# 'make clean'  removes all .o and executable files

.PHONY: depend clean

SCAN = slGPIO
DISPLAY = display

CC = gcc
CFLAGS := -g -Wall -DLINUX $(shell pkg-config opencv --cflags)
LIBs := $(shell pkg-config opencv --libs)
LFLAGS =

# Source files
SRCs := \
	slGPIO.cpp
	#sl.cpp \

# List of object files to compile
OBJs = $(SRCs:.cpp=.o)

all: $(SCAN)

$(DISPLAY): display.o
	gcc -g -Wall 

$(SCAN): $(OBJs)
	$(CC) $(CFLAGS) $(INCLUDES) -o $(SCAN) $(OBJs) $(LFLAGS) $(LIBs)

# 	cp $(SCAN) Release/

%.o: %.cpp %.h
	$(CC) $(CFLAGS) $(INCLUDES) -c $<  -o $@

clean:
	$(RM) *.o *~ $(SCAN)

The sl code was written by myself and Peter Hokanson.  Its not to long and is broken up into 3 sections.  The source code will likely be easier to read with proper highlighting.  OpenCV was only used to manipulate the camera and projector.  Part 1 below projects and captures the images:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <assert.h> // For my own paranoia's sake
#include <opencv/cv.h>
#include <opencv/highgui.h>
#define WHITE_THRESHOLD 5
#define BLACK_THRESHOLD -5
#define NUM_IMAGES 18
#define CAM_WIDTH 640
#define PROJ_WIDTH 640
#define Z_SCALE 500   //250 works

//#define TEST_RECOGNIZER

int gray2bin(int gray);
bool file_exists(const char * filename);
int slScanner(void);

int slScanner(void)
{
	//*********PART1 - Project SL and Cap Imgs************
	//Initialize
	IplImage* slPat[NUM_IMAGES] = {0};
	IplImage* capImg[NUM_IMAGES + 1] = {0};
// 	int height,width,step,channels;
	uchar *data;
	char s[128];
	int i,outFileNum=0;

	//Usage
	//if(argc>1){
	//	printf("Usage: sl images are in same folder named grayIMGx.png and range from 0-19\n");
	//	exit(0);
	//}

	//Load sl images
#ifndef TEST_RECOGNIZER
	for(int i=0;i<NUM_IMAGES;i++){
		sprintf(s,"%d.png",i+1);
		slPat[i]=cvLoadImage(s);
		if(!slPat[i]){
			printf("Could not load image file: %s\n",s);
			exit(0);
		}
	}

	// create a window
	cvStartWindowThread();
	cvNamedWindow("mainWin", CV_WINDOW_NORMAL);
	cvSetWindowProperty("mainWin", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);

	// pause
	cvWaitKey(500);

	// set up camera
	CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY );
	if (!capture){
		fprintf( stderr, "Camera not found \n");
		getchar();
		exit(0);
	}
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 480);
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 640);
	//cvSetCaptureProperty(capture, CV_CAP_PROP_FPS, 5);
	//cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_COUNT, 1);
	//Maybe this will fix the frame delay?

	//Display images and capture
	for(int i=0;i<NUM_IMAGES;i++){

		// show the image
		cvShowImage("mainWin", slPat[i] );

		// pause
		cvWaitKey(5);

		// capture the image
		cvGrabFrame(capture);
		cvGrabFrame(capture);
		cvGrabFrame(capture);
		cvGrabFrame(capture);
		cvGrabFrame(capture); //Get to last frame in buffer
		capImg[NUM_IMAGES + 1] = cvRetrieveFrame(capture);   

		// write the image
		//cvWriteFrame(writer, capImg[i]);
		capImg[i] = cvCloneImage(capImg[NUM_IMAGES + 1]);
		sprintf(s,"results/%d.png",i+1);
		cvSaveImage(s,capImg[i]);
	}

	cvReleaseCapture(&capture);

	//Display captured images for debug
	for(int i=0;i<NUM_IMAGES;i++){

		// show the image (for debug)
		cvShowImage("mainWin", capImg[i] );

		// pause
		cvWaitKey(100);
	}

#else // TEST_RECOGNIZER
	for(int i=0;i<NUM_IMAGES;i++) {
		sprintf(s,"setupp/%d.png",i+1);
		capImg[i]=cvLoadImage(s);
		if(!capImg[i]){
			printf("Could not load image file: %s\n",s);
			exit(0);
		}
	}
#endif

Part 2 contains the SL decoding and depth redering algorithm:

	//*********PART2 - Decode captured images************

	// First initialize a matrix for showing the decoded values, needs 10 bits,
	// so could move to short* if memory becomes an issue.
	int *columnmap = (int*)calloc(capImg[0]->imageSize, sizeof(int));
	if(columnmap == NULL) {
		printf("Allocation for column map failed! Aborting\n");
		return 1;
	}

	// We're going to step over matching inverse pairs of projected patterns, and
	// perform a threshold operation to determine whether a given pixel is white
	// or not.
	for(int i=0;i<NUM_IMAGES;i+=2){
		printf("Processing scan patterns %d, %d\n",i,i+1);
		uchar* data1 = (uchar*)capImg[i]->imageData;
		uchar* data0 = (uchar*)capImg[i+1]->imageData;

		for(int y=0;y<capImg[i]->height;y++){
			for(int x=0;x<capImg[i]->width;x++) {
				int u = y*capImg[i]->widthStep+x*capImg[i]->nChannels;
				if(columnmap[u] == -1){
					// We have discarded this pixel
					continue;
				}
				int gray1 = data1[u] + data1[u+1] + data1[u+2];
				int gray0 = data0[u] + data0[u+1] + data0[u+2]; 

				// Shift our Gray code bit vector
				columnmap[u] = columnmap[u] << 1;
				if(gray1 - gray0 > WHITE_THRESHOLD){
					// We have a white pixel!
					assert((columnmap[u] & 1) == 0);
					columnmap[u] |= 1;
				} else if(gray1 - gray0 < BLACK_THRESHOLD){
					// A black pixel
					assert((columnmap[u] & 1) == 0);
					columnmap[u] |= 0;
				} else {
					// Not quite sure about this pixel: Punt!
					columnmap[u] = -1;
				}
			}
		}

		// Avoid memory leaks!
// 		printf("Releasing images %d, %d\n", i,i+1);
// 		cvReleaseImage(&capImg[i]);
// 		cvReleaseImage(&capImg[i+1]);
	}

	// Convert Gray code to decimal
	for(i = 0; i < capImg[0]->imageSize; i++){
// 		int tmp = columnmap[i];
		columnmap[i] = gray2bin(columnmap[i]);
// 		printf("Gray: %4x -> Binary %4x\n",tmp,columnmap[i]);
	}

	// TODO: Test against projector patterns -> 0 disparity
	// TODO: Test with SL images

    //Find available filename on jumpdrive
    sprintf(s,"/media/sda1/result%d.xyz",outFileNum);
    while (file_exists(s)) {
        outFileNum++;
        sprintf(s,"/media/sda1/result%d.xyz",outFileNum);
    }

	// Write the pointcloud
	FILE *f = fopen(s,"w");
	if(f == NULL) {
	  printf("Error opening %s:  Trying local directory...\n",s);
	  FILE *f = fopen("result.xyz","w");
	  if(f == NULL) {
            printf("Error opening result.xyz:  Aborting!\n");
            return 1;
	  }
	}

	printf("Writing pointcloud...\n");
	for(int y = 0;y < capImg[0]->height; y++){
		for(int x = 0;x < capImg[0]->width; x++) {
			int u = y*capImg[0]->widthStep+x*capImg[0]->nChannels;

			if(columnmap[u] == -1) continue; // Discarded!

			float disp = (float)columnmap[u]/(PROJ_WIDTH) - (float)x/CAM_WIDTH;
// 			printf("%f\n",disp);
			if(disp == 0.0) continue;
			float z = (float)Z_SCALE/(disp);

			fprintf(f,"%d %d %f\n",x,y,z);
		}
	}

	fclose(f);

Part 3 is a work in progress.  All thats contained here is some cleanup.

	//*******Part3 - Project 3D object with openGL*********

	for(int i = 0; i < NUM_IMAGES; i++){
		cvReleaseImage(&capImg[i]);
		//cvReleaseImage(&slPat[i]);
	}
	//Exit
	cvDestroyWindow("mainWin");
	free(columnmap);
	return 0;
}

<–Previous     Project Home     Next –>

The guys over at ridgerun have a great example on GPIO and interrupts, which I have modified to suit my purposes.  I have posted modifications below:

GPIO Setup:

gpio = 139; // SPST connected to GPIO 139
gpio_export(gpio); //export to user space
gpio_set_dir(gpio, 0); //set direction to input
gpio_set_edge(gpio, “falling”);  // Set interrupt edge, can be rising, falling or both.
gpio_fd = gpio_fd_open(gpio);

Upon interrupt:

printf("Starting Scann");
slScanner(); // run the sl code
printf("Scan Completen");
printf("Press button to scan again or Ctrl C to quit");

<–Previous     Project Home     Next –>

• camera=lbcmvga

We also need to build a jig to mount the lens to the camera.  Since the lens uses a magnetism to adhere a metal washer will do the trick.  A hot-glue gun works great for attaching the washer to the camera board.

<–Previous     Project Home     Next –>

1. Select Beagleboard
2. Select the Packages you want
   • OpenCV – Libraries will be readily available to include in your code
   • Toolchain – Ability to compile code natively on beagleboard
3. Build ( this step takes a while so be patient)

I find it useful to select the build type as an SD image under the advanced option.  Once downloaded you can download the image onto the sd card easily with win32DiskImager.  After the image has been loaded, plug the SD card into the beagle board and boot it up.  This step also takes a long while to install but once it boots your all set!

<–Previous     Project Home     Next –>