Colony

    cleanup(0);

#ifndef SHMIMGSERVE_H

#define SHMIMGSERVE_H

#include <cv.h>

#define JPEG_QUALITY  50

int sendImage(IplImage *image);

int openShM();

void releaseShM();

#endif

#include "shmimgserve.h"

#define DEBUG 0 //Debug to find threshold level

  openShM();

  releaseShM();

    printf("Could not grab a frame\n");

  sendImage(im_capture);

    if (DEBUG) cvCircle( image03, center, 3, CV_RGB(255,255,255), 3, 8, 0 );

  if (DEBUG) cvShowImage( "mywindow1", image03 );

/*

   +----------------------------------------------------------------------+

   | PHP Version 5                                                        |

   +----------------------------------------------------------------------+

   | Copyright (c) 1997-2008 The PHP Group                                |

   +----------------------------------------------------------------------+

   | This source file is subject to version 3.01 of the PHP license,      |

   | that is bundled with this package in the file LICENSE, and is        |

   | available through the world-wide-web at the following url:           |

   | http://www.php.net/license/3_01.txt                                  |

   | If you did not receive a copy of the PHP license and are unable to   |

   | obtain it through the world-wide-web, please send a note to          |

   | license@php.net so we can mail you a copy immediately.               |

   +----------------------------------------------------------------------+

   | Authors: Tom May <tom@go2net.com>                                    |

   |          Gavin Sherry <gavin@linuxworld.com.au>                      |

   +----------------------------------------------------------------------+

 */

/* $Id: sysvsem.c,v 1.51.2.3.2.3 2007/12/31 07:20:13 sebastian Exp $ */

/* Latest update build anc tested on Linux 2.2.14

 *

 * This has been built and tested on Solaris 2.6 and Linux 2.1.122.

 * It may not compile or execute correctly on other systems.

 *

 * sas: Works for me on Linux 2.0.36 and FreeBSD 3.0-current

 */

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

#include <errno.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <php/main/php_config.h>

#include "php_sysvsem.h"

#if !HAVE_SEMUN

union semun {

	int val;                    /* value for SETVAL */

	struct semid_ds *buf;       /* buffer for IPC_STAT, IPC_SET */

	unsigned short int *array;  /* array for GETALL, SETALL */

	struct seminfo *__buf;      /* buffer for IPC_INFO */

};

#undef HAVE_SEMUN

#define HAVE_SEMUN 1

#endif

/* Semaphore functions using System V semaphores.  Each semaphore

 * actually consists of three semaphores allocated as a unit under the

 * same key.  Semaphore 0 (SYSVSEM_SEM) is the actual semaphore, it is

 * initialized to max_acquire and decremented as processes acquire it.

 * The value of semaphore 1 (SYSVSEM_USAGE) is a count of the number

 * of processes using the semaphore.  After calling semget(), if a

 * process finds that the usage count is 1, it will set the value of

 * SYSVSEM_SEM to max_acquire.  This allows max_acquire to be set and

 * track the PHP code without having a global init routine or external

 * semaphore init code.  Except see the bug regarding a race condition

 * php_sysvsem_get().  Semaphore 2 (SYSVSEM_SETVAL) serializes the

 * calls to GETVAL SYSVSEM_USAGE and SETVAL SYSVSEM_SEM.  It can be

 * acquired only when it is zero.

 */

#define SYSVSEM_SEM		0

#define SYSVSEM_USAGE	1

#define SYSVSEM_SETVAL	2

/* {{{ release_sysvsem_sem

 */

sysvsem::~sysvsem()

{

	struct sembuf sop[2];

	int opcount = 1;

	/* Decrement the usage count. */

	sop[0].sem_num = SYSVSEM_USAGE;

	sop[0].sem_op  = -1;

	sop[0].sem_flg = SEM_UNDO;

	/* Release the semaphore if it has been acquired but not released. */

	if (this->count) {

		sop[1].sem_num = SYSVSEM_SEM;

		sop[1].sem_op  = this->count;

		sop[1].sem_flg = SEM_UNDO;

		opcount++;

	}

	semop(this->semid, sop, opcount);

	//TODO: Need to auto remove() semaphore when SYSVSEM_USAGE is 0

	//efree(sem_ptr);

}

/* }}} */

#define SETVAL_WANTS_PTR

#if defined(_AIX)

#undef SETVAL_WANTS_PTR

#endif

/* {{{ proto resource sem_get(int key [, int max_acquire [, int perm [, int auto_release]])

	 Return an id for the semaphore with the given key, and allow max_acquire (default 1) processes to acquire it simultaneously */

/*  max_aquire = 1, perm = 0666, auto_release = 1 */

sysvsem::sysvsem(long key, long max_acquire, long perm, long auto_release) throw (sysvsem_error)

{

	int semid;

	struct sembuf sop[3];

	int count;

	/* Get/create the semaphore.  Note that we rely on the semaphores

	 * being zeroed when they are created.  Despite the fact that

	 * the(?)  Linux semget() man page says they are not initialized,

	 * the kernel versions 2.0.x and 2.1.z do in fact zero them.

	 */

	semid = semget(key, 3, perm|IPC_CREAT);

	if (semid == -1) {

		fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

		throw sysvsem_error("failed to open semaphore");

	}

	/* Find out how many processes are using this semaphore.  Note

	 * that on Linux (at least) there is a race condition here because

	 * semaphore undo on process exit is not atomic, so we could

	 * acquire SYSVSEM_SETVAL before a crashed process has decremented

	 * SYSVSEM_USAGE in which case count will be greater than it

	 * should be and we won't set max_acquire.  Fortunately this

	 * doesn't actually matter in practice.

	 */

	/* Wait for sem 1 to be zero . . . */

	sop[0].sem_num = SYSVSEM_SETVAL;

	sop[0].sem_op  = 0;

	sop[0].sem_flg = 0;

	/* . . . and increment it so it becomes non-zero . . . */

	sop[1].sem_num = SYSVSEM_SETVAL;

	sop[1].sem_op  = 1;

	sop[1].sem_flg = SEM_UNDO;

	/* . . . and increment the usage count. */

	sop[2].sem_num = SYSVSEM_USAGE;

	sop[2].sem_op  = 1;

	sop[2].sem_flg = SEM_UNDO;

	while (semop(semid, sop, 3) == -1) {

		if (errno != EINTR) {

			fprintf(stderr, "%s failed acquiring SYSVSEM_SETVAL for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

			break;

		}

	}

	/* Get the usage count. */

	count = semctl(semid, SYSVSEM_USAGE, GETVAL, NULL);

	if (count == -1) {

		fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

	}

	printf("proc count: %d\n", count);

	/* If we are the only user, then take this opportunity to set the max. */

	if (count == 1) {

#if HAVE_SEMUN

		/* This is correct for Linux which has union semun. */

		union semun semarg;

		semarg.val = max_acquire;

		if (semctl(semid, SYSVSEM_SEM, SETVAL, semarg) == -1) {

			fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

		}

#elif defined(SETVAL_WANTS_PTR)

		/* This is correct for Solaris 2.6 which does not have union semun. */

		if (semctl(semid, SYSVSEM_SEM, SETVAL, &max_acquire) == -1) {

			fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

		}

#else

		/* This works for i.e. AIX */

		if (semctl(semid, SYSVSEM_SEM, SETVAL, max_acquire) == -1) {

			fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

		}

#endif

	}

	/* Set semaphore 1 back to zero. */

	sop[0].sem_num = SYSVSEM_SETVAL;

	sop[0].sem_op  = -1;

	sop[0].sem_flg = SEM_UNDO;

	while (semop(semid, sop, 1) == -1) {

		if (errno != EINTR) {

			fprintf(stderr, "%s failed releasing SYSVSEM_SETVAL for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

			break;

		}

	}

	//sem_ptr = (sysvsem_sem *) emalloc(sizeof(sysvsem_sem));

	this->key   = key;

	this->semid = semid;

	this->count = 0;

	this->auto_release = auto_release;

	//this->id = (int)sem_ptr;

	//return sem_ptr;

}

/* }}} */

/* {{{ php_sysvsem_semop

 */

int sysvsem::php_sysvsem_semop(int acquire)

{

	struct sembuf sop;

	if (!acquire && this->count == 0) {

		fprintf(stderr, "SysV semaphore 0x%x is not currently acquired\n", this->key);

		return 0;

	}

	sop.sem_num = SYSVSEM_SEM;

	sop.sem_op  = acquire ? -1 : 1;

	sop.sem_flg = SEM_UNDO;

	while (semop(this->semid, &sop, 1) == -1) {

		if (errno != EINTR) {

			fprintf(stderr, "%s failed to %s semaphore 0x%x: %s\n", __FUNCTION__, acquire ? "acquire" : "release", this->key, strerror(errno));

			return 0;

		}

	}

	this->count -= acquire ? -1 : 1;

	return 1;

}

/* }}} */

/* {{{ proto bool sem_acquire(resource id)

	 Acquires the semaphore with the given id, blocking if necessary */

int sysvsem::sem_acquire()

{

	return this->php_sysvsem_semop(1);

}

/* }}} */

/* {{{ proto bool sem_release(resource id)

	 Releases the semaphore with the given id */

int sysvsem::sem_release()

{

	return this->php_sysvsem_semop(0);

}

/* }}} */

/* {{{ proto bool sem_remove(resource id)

	 Removes semaphore from Unix systems */

/*

 * contributed by Gavin Sherry gavin@linuxworld.com.au

 * Fri Mar 16 00:50:13 EST 2001

 */

int sysvsem::sem_remove()

{

#if HAVE_SEMUN

	union semun un;

	struct semid_ds buf;

#endif

#if HAVE_SEMUN

	un.buf = &buf;

	if (semctl(this->semid, 0, IPC_STAT, un) < 0) {

#else

	if (semctl(this->semid, 0, IPC_STAT, NULL) < 0) {

#endif

		fprintf(stderr, "SysV semaphore 0x%x does not (any longer) exist\n", this->key);

		return 0;

	}

#if HAVE_SEMUN

	if (semctl(this->semid, 0, IPC_RMID, un) < 0) {

#else

	if (semctl(this->semid, 0, IPC_RMID, NULL) < 0) {

#endif

		fprintf(stderr, "%s failed for SysV sempphore 0x%x: %s\n", __FUNCTION__, this->key, strerror(errno));

		return 0;

	}

	/* let release_sysvsem_sem know we have removed

	 * the semaphore to avoid issues with releasing.

	 */ 

	this->count = -1;

	return 1;

}

/* }}} */

/*

 * Local variables:

 * tab-width: 4

 * c-basic-offset: 4

 * End:

 * vim600: sw=4 ts=4 fdm=marker

 * vim<600: sw=4 ts=4

 */

  cvReleaseImage(&img);

/* 

   +----------------------------------------------------------------------+

   | PHP Version 5                                                        |

   +----------------------------------------------------------------------+

   | Copyright (c) 1997-2008 The PHP Group                                |

   +----------------------------------------------------------------------+

   | This source file is subject to version 3.01 of the PHP license,      |

   | that is bundled with this package in the file LICENSE, and is        |

   | available through the world-wide-web at the following url:           |

   | http://www.php.net/license/3_01.txt                                  |

   | If you did not receive a copy of the PHP license and are unable to   |

   | obtain it through the world-wide-web, please send a note to          |

   | license@php.net so we can mail you a copy immediately.               |

   +----------------------------------------------------------------------+

   | Author: Tom May <tom@go2net.com>                                     |

   +----------------------------------------------------------------------+

*/

/* $Id: php_sysvsem.h,v 1.16.2.1.2.2 2007/12/31 07:20:13 sebastian Exp $ */

#ifndef PHP_SYSVSEM_H

#define PHP_SYSVSEM_H

#include <stdexcept>

#include <string>

struct sysvsem_error : public std::runtime_error

{

    sysvsem_error(const std::string& msg) : runtime_error(msg){}

};

class sysvsem {

private:

	//int id;						/* For error reporting. */

	int key;					/* For error reporting. */

	int semid;					/* Returned by semget(). */

	int count;					/* Acquire count for auto-release. */

	int auto_release;			/* flag that says to auto-release. */

	int php_sysvsem_semop(int acquire);

public:

	sysvsem(long key, long max_acquire = 1, long perm = 0666, long auto_release = 1) throw (sysvsem_error);

	~sysvsem();

	int sem_acquire();

	int sem_release();

	int sem_remove();

};

#endif /* PHP_SYSVSEM_H */

#include "shmimgserve.h"

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/shm.h>

#include "php_sysvsem.h"

#define DEBUG 0

#if DEBUG

#define dbg_printf(...)   printf(__VA_ARGS__)

#else

#define dbg_printf(...) 

#endif

int write_JPEG_to_mem (unsigned char *storage, int length, IplImage *_img, int quality);

static sysvsem *sem;

static int shm_id;

int sendImage(IplImage *image)

{

  dbg_printf("Send image\n");

	if (sem->sem_acquire())

	{

		dbg_printf("Semaphore acquired\n");

		unsigned char *p = (unsigned char *)shmat(shm_id, NULL, 0);

		if (p!=(void *)-1)

		{

			dbg_printf("Memory mapped at %p\n", p);

			int len = write_JPEG_to_mem (p+4, 150000-4, image, JPEG_QUALITY);

			int i;

			int length = len;

			dbg_printf("%d\n", length);

			for(i=0; i < 4; i++)

			{

				char digit = (char)(length & 0xff);

				length >>= 8;

				memcpy(p+i, &digit, sizeof(char));

			}

			dbg_printf("Memory copied\n");

			sem->sem_release();

			dbg_printf("Semaphore released\n");

			shmdt(p);

		  dbg_printf("Memory detached\n");

		}

	}

  if (errno!=0)

  {

    int errnum = errno;

    errno = 0;

    fprintf(stderr, "error %d %s\n", errnum, strerror(errnum));

    return errnum;

  }

  return 0;

}

int openShM()

{

	shm_id = shmget(0x40305163, 150000, IPC_CREAT | 0666);

	if (shm_id > 0)

		dbg_printf("Shared memory opened\n");

	else

	{

		fprintf(stderr, "Error opening shared memory\n");

		return -1;

	}

  sem = new (std::nothrow)sysvsem(0x40309999);

  if (sem)

		dbg_printf("Semaphore opened\n");

	else

	{

		fprintf(stderr, "Error opening semaphore\n");

		return -2;

	}

}

void releaseShM()

{

  sem->sem_remove();

	delete sem;

	dbg_printf("Semaphore deleted\n");

  shmctl(shm_id, IPC_RMID, NULL);

  dbg_printf("Memory marked for deletion\n");

}

all: clean_programs clean_vision shmimgserve vision vision_driver fitellipse

shmimgserve:

	$(CC) -ggdb `pkg-config opencv --cflags` -c -g -I . memdst.c

	$(CC) -ggdb                              -c -g -I . sysvsem.cpp

	$(CC) -ggdb `pkg-config opencv --cflags` -c -g -I . shmimgserve.cpp

vision_driver: vision shmimgserve

	$(CC) -ggdb `pkg-config opencv --cflags --libs` -g -I. -L. vision_driver.c memdst.o savetonetwork.o sysvsem.o shmimgserve.o vision.o -ljpeg -o vision_driver

#include <cv.h>

#include <highgui.h>

#include <stdio.h>

#define CAPTURE

#ifdef CAPTURE

static CvCapture *capture;

#endif

#include <sys/types.h>

#include <sys/shm.h>

#include <string.h>

#include <stdlib.h>

#include "php_sysvsem.h"

#include <errno.h>

int write_JPEG_to_mem (unsigned char *storage, int length, IplImage *_img, int quality);

static sysvsem *sem;

static int shm_id;

int sendImage(IplImage *image)

{

  printf("Send image\n");

	if (sem->sem_acquire())

	{

		printf("Semaphore acquired\n");

		unsigned char *p = (unsigned char *)shmat(shm_id, NULL, 0);

		if (p!=(void *)-1)

		{

			printf("Memory mapped at %p\n", p);

			int len = write_JPEG_to_mem (p+4, 150000-4, image, 30);

			int i;

			int length = len;

			printf("%d\n", length);

			for(i=0; i < 4; i++)

			{

				char digit = (char)(length & 0xff);

				length >>= 8;

				memcpy(p+i, &digit, sizeof(char));

			}

			printf("Memory copied\n");

			sem->sem_release();

			printf("Semaphore released\n");

			shmdt(p);

		  printf("Memory detached\n");

		}

	}

  if (errno!=0)

  {

    int errnum = errno;

    errno = 0;

    fprintf(stderr, "error %d %s\n", errnum, strerror(errnum));

    return errnum;

  }

  return 0;

}

void openShM()

{

	shm_id = shmget(0x40305163, 150000, IPC_CREAT | 0666);

	if (shm_id > 0)

		printf("Shared memory opened\n");

	else

	{

		fprintf(stderr, "Error opening shared memory\n");

		exit(-2);

	}

  sem = new (std::nothrow)sysvsem(0x40309999);

  if (sem)

		printf("Semaphore opened\n");

	else

	{

		fprintf(stderr, "Error opening semaphore\n");

		exit(-1);

	}

}

void releaseShM()

{

  sem->sem_remove();

	delete sem;

	printf("Semaphore deleted\n");

  shmctl(shm_id, IPC_RMID, NULL);

  printf("Memory marked for deletion\n");

}

int main(int argc, char *argv[])

{

#ifdef CAPTURE

  capture = cvCaptureFromCAM( 0 );

  if( !capture ) {

    fprintf( stderr, "ERROR: capture is NULL \n" );

    return -1; 	

  }

#endif

	openShM();

  // Create a window in which the captured images will be presented

  //cvNamedWindow( "mywindow1", CV_WINDOW_AUTOSIZE );

  // Show the image captured from the camera in the window and repeat

  while((cvWaitKey(10) & 255) != 27)

  {

    usleep(15000);

#ifdef CAPTURE

    if(!cvGrabFrame(capture)){              // capture a frame

      printf("Could not grab a frame\n\7");

      return -1;

    }

    IplImage *image03=cvRetrieveFrame(capture);

#else

    IplImage *image03;

    // load image and force it to be grayscale

    if ((image03 = cvLoadImage(argv[1], 0)) == 0) {

      fprintf(stderr, "Failed to load image.\n");

      return -1;

    }

#endif

    //cvShowImage( "mywindow1", image03 );

    sendImage(image03);

#ifndef CAPTURE

    cvReleaseImage(&image03);

#endif

    //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),

    //remove higher bits using AND operator

  }

#ifdef CAPTURE

  // Release the capture device housekeeping

  cvReleaseCapture( &capture );

#endif

  releaseShM();

  cvDestroyWindow( "mywindow1" );

  return 0;

}

    //TODO: Can we continue safely without wireless?

    //return -1;

/**

 * @brief The function that is run in the new pthread in order to do the client processing

 */

/**

 * @brief Launchpad function to start loop_server() since callbacks don't support member functions

 *

 * @param arg the argument to give to the new thread

 */

/**

 * @brief Main loop of the server, runs periodic tasks

 *

 * @return 0 on success, negative error code on failure

 */

VISIONOBJECTS = vision/vision.o vision/savetonetwork.o vision/memdst.o vision/sysvsem.o vision/shmimgserve.o

#define SAME_ROBOT_DISTANCE_THRESHOLD 60 //TODO: This needs some tuning

	public static final String WEBCAM_PATH = "http://128.2.99.176/colonet/overheadimage.php";

<?php

header('Content-Type: image/jpeg');

$sem_key = 0x40309999;

$shm_key = 0x40305163;

$sem_id = sem_get($sem_key, 1);

if (!sem_acquire($sem_id))

{

   print "Error acquiring semaphore\n";

   return;

}

$shm_id = shmop_open($shm_key, 'a', 0666, 150000);

if ($shm_id===false)

{

   print "Error opening shared memory\n";

   return;

}

$size = shmop_read($shm_id, 0, 4);

$length = 0;

for ($i=strlen($size)-1; $i >= 0; $i--)

{

   $length <<= 8;

   $length |= ord(substr($size, $i));

}

$data = shmop_read($shm_id, 4, $length);

shmop_close($shm_id);

sem_release($sem_id);

print $data;

?>

/*

 * Copyright (c) Ian F. Darwin, http://www.darwinsys.com/, 1996-2002.

 * All rights reserved. Software written by Ian F. Darwin and others.

 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 * 

 * Java, the Duke mascot, and all variants of Sun's Java "steaming coffee

 * cup" logo are trademarks of Sun Microsystems. Sun's, and James Gosling's,

 * pioneering role in inventing and promulgating (and standardizing) the Java 

 * language and environment is gratefully acknowledged.

 * 

 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for

 * inventing predecessor languages C and C++ is also gratefully acknowledged.

 */

import java.applet.Applet;

import java.applet.AppletContext;

import java.applet.AppletStub;

import java.applet.AudioClip;

import java.awt.BorderLayout;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.Image;

import java.awt.Label;

import java.awt.Panel;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import javax.swing.JFrame;

/*

 * AppletViewer - a simple Applet Viewer program.

 * @author  Ian Darwin, http://www.darwinsys.com/

 */

public class AppletViewer {

  /** The main Frame of this program */

  JFrame f;

  /** The AppletAdapter (gives AppletStub, AppletContext, showStatus) */

  static AppletAdapter aa = null;

  /** The name of the Applet subclass */

  String appName = null;

  /** The Class for the actual applet type */

  Class ac = null;

  /** The Applet instance we are running, or null. Can not be a JApplet

   * until all the entire world is converted to JApplet. */

  Applet ai = null;

  /** The width of the Applet */

  final int WIDTH = 250;

  /** The height of the Applet */

  final int HEIGHT = 200;

  /** Main is where it all starts. 

   * Construct the GUI. Load the Applet. Start it running.

   */

  public static void main(String[] av) {

    if (av.length==0)

    {

      System.err.println("No class name specified\n");

      System.exit(1);

    }

    new AppletViewer(av[0]);

  }

  /** Construct the GUI for an Applet Viewer */

  AppletViewer(String appName) {

    super();

    this.appName = appName;

    f = new JFrame(appName);

    f.addWindowListener(new WindowAdapter() {

      public void windowClosing(WindowEvent e) {

        f.setVisible(false);

        f.dispose();

        System.exit(0);

      }

    });

    Container cp = f.getContentPane();

    cp.setLayout(new BorderLayout());

    // Instantiate the AppletAdapter which gives us

    // AppletStub and AppletContext.

    if (aa == null)

      aa = new AppletAdapter();

    // The AppletAdapter also gives us showStatus.

    // Therefore, must add() it very early on, since the Applet's

    // Constructor or its init() may use showStatus()

    cp.add(BorderLayout.SOUTH, aa);

    showStatus("Loading Applet " + appName);

    loadApplet(appName , WIDTH, HEIGHT);  // sets ac and ai

    if (ai == null)

      return;

    // Now right away, tell the Applet how to find showStatus et al.

    ai.setStub(aa);

    // Connect the Applet to the Frame.

    cp.add(BorderLayout.CENTER, ai);

    Dimension d = ai.getSize();

    d.height += aa.getSize().height;

    f.setSize(d);

    f.setVisible(true);    // make the Frame and all in it appear

    showStatus("Applet " + appName + " loaded");

    // Here we pretend to be a browser!

    ai.init();

    ai.start();

  }

  /*

   * Load the Applet into memory. Should do caching.

   */

  void loadApplet(String appletName, int w, int h) {

    // appletName = ... extract from the HTML CODE= somehow ...;

    // width =     ditto

    // height =     ditto

    try {

      // get a Class object for the Applet subclass

      ac = Class.forName(appletName);

      // Construct an instance (as if using no-argument constructor)

      ai = (Applet) ac.newInstance();

    } catch(ClassNotFoundException e) {

      showStatus("Applet subclass " + appletName + " did not load");

      return;

    } catch (Exception e ){

      showStatus("Applet " + appletName + " did not instantiate");

      return;

    }

    ai.setSize(w, h);

  }

  public void showStatus(String s) {

    aa.getAppletContext().showStatus(s);

  }

}

/*

 * AppletAdaptor: partial implementation of AppletStub and AppletContext.

 *

 * This code is far from finished, as you will see.

 *

 * @author  Ian Darwin, http://www.darwinsys.com/, for Learning Tree Course 478

 */

class AppletAdapter extends Panel implements AppletStub, AppletContext {

  /** The status window at the bottom */

  Label status = null;

  /** Construct the GUI for an Applet Status window */

  AppletAdapter() {

    super();

    // Must do this very early on, since the Applet's

    // Constructor or its init() may use showStatus()

    add(status = new Label());

    // Give "status" the full width

    status.setSize(getSize().width, status.getSize().height);

    showStatus("AppletAdapter constructed");  // now it can be said

  }

  /****************** AppletStub ***********************/

  /** Called when the applet wants to be resized.  */

  public void appletResize(int w, int h) {

    // applet.setSize(w, h);

  }

  /** Gets a reference to the applet's context.  */

  public AppletContext getAppletContext() {

    return this;

  }

  /** Gets the base URL.  */

  public URL getCodeBase() {

    return getClass().getResource(".");

  }

  /** Gets the document URL.  */

  public URL getDocumentBase() {

    return getClass().getResource(".");

  }

  /** Returns the value of the named parameter in the HTML tag.  */

  public String getParameter(String name) {

    String value = null;

    return value;

  }

  /** Determines if the applet is active.  */

  public boolean isActive() {

    return true;

  }

  /************************ AppletContext ************************/

  /** Finds and returns the applet with the given name. */

  public Applet getApplet(String an) {

    return null;

  }

  /** Finds all the applets in the document */

  public Enumeration<Applet> getApplets()  {

    class AppletLister implements Enumeration<Applet> {

      public boolean hasMoreElements() {

        return false;

      }

      public Applet nextElement() {

        return null;

      }

    }

    return new AppletLister();

  }

  /** Create an audio clip for the given URL of a .au file */

  public AudioClip getAudioClip(URL u) {

    return null;

  }

  /** Look up and create an Image object that can be paint()ed */

  public Image getImage(URL u)  {

    return null;

  }

  /** Request to overlay the current page with a new one - ignored */

  public void showDocument(URL u) {

  }

  /** as above but with a Frame target */

  public void showDocument(URL u, String frame)  {

  }

  /** Called by the Applet to display a message in the bottom line */

  public void showStatus(String msg) {

    if (msg == null)

      msg = "";

    status.setText(msg);

  }

  /* StreamKey stuff - new in JDK1.4 */

  Map<String, InputStream> streamMap = new HashMap<String, InputStream>();

  /** Associate the stream with the key. */

  public void setStream(String key, InputStream stream) throws IOException {

    streamMap.put(key, stream);

  }

  public InputStream getStream(String key) {

    return streamMap.get(key);

  }

  public Iterator<String> getStreamKeys() {

    return streamMap.keySet().iterator();

  }

}

	cp overheadimage.php /var/www/colonet/overheadimage.php