/* FEATURE MORPH
*
*/

/* ==================================================================== */
/* includes for graphics */
#include <Dialogs.h>
#include <Fonts.h>
#include <MacWindows.h>
#include <Menus.h>
#include <QuickDraw.h>
#include <TextEdit.h>

#include <Types.h>
#include <Memory.h>
#include <Dialogs.h>
#include <OSUtils.h>
#include <ToolUtils.h>
#include <SegLoad.h>
#include <Sound.h>

#include "DrawSprocket.h"
#include <agl.h>

/* ==================================================================== */
/* includes for graphics */
#include <math.h>
#include <stdlib.h>
#include <stdio.h>

/* ==================================================================== */
/* constants */
#define DISPLAY
#define SCREEN_WIDTH 400
#define SCREEN_HEIGHT 400

#define LINEFEED printf("\n");

const int WIDTH = 200;
const int HEIGHT = 200;
const int BYTESIZE = WIDTH*HEIGHT*3;

/* ==================================================================== */
/* STRUCTURES */

/* XY structure*/
typedef struct xy_struct {
  float x,y;
} xy_td;

/* FEATURE
 *   line in image1: p1,p2; 
 *   line in image2: q1,q2
 *   weigths used in mapping: a,b,p
 *   length of line in image2 
 */
typedef struct feature_struct {
  xy_td p1,p2,q1,q2;
  float  a,b,p;
  float  plength,qlength;
} feature_td;

/* FEATURE LIST*/
typedef struct featureList_struct {
  int  num;
  feature_td  *features;
} featureList_td;


/* ==================================================================== */
/* globals for graphics*/
DSpContextAttributes gTheContextAttributes;
DSpContextReference gTheContext;

/* ==================================================================== */
/* static function prototypes for graphics */
static CGrafPtr SetupScreen(void);
static void ShutdownScreen(CGrafPtr theFrontBuffer);
static AGLContext setupAGL(AGLDrawable win);
static void cleanupAGL(AGLContext ctx);
/* static void drawGL(); */
static void drawGL(AGLContext ctx, char *values, int numu, int numv);


/* ==================================================================== */
/* INITIALIZE */
static void initialize(void)
{
	InitGraf(&qd.thePort);
	InitFonts();
	InitWindows();
	InitMenus();
	TEInit();
	InitDialogs(nil);
	InitCursor();
	HideCursor();
}


/* ==================================================================== */
/* function prototypes for feature morph routines */

void fill_rect(char *buffer,int x, int y, int dx, int dy, int r, int g, int b);
void init_features(featureList_td *features);
void init_buffer();
void morph(featureList_td *features);


/* ==================================================================== */
/* images */

char image1[BYTESIZE];
char image2[BYTESIZE];

/* ==================================================================== */
/*  MAIN */
void main()  {
	CGrafPtr theScreen;
	AGLContext ctx;
	featureList_td  features;
  
	initialize();

	init_features(&features);

	init_buffer();

	morph(&features);

	#ifdef DISPLAY
		theScreen = SetupScreen();
		/* Setup the OpenGL context */
		ctx = setupAGL((AGLDrawable) theScreen);
		if(!ctx) return;

		do {
			drawGL(ctx,image1,WIDTH,HEIGHT);
		} while (!Button());
		
		/* Cleanup the OpenGL context */
		cleanupAGL(ctx);

		ShutdownScreen(theScreen);
		
		ShowCursor();
		
		FlushEvents(everyEvent, 0);
		
		ExitToShell();
	#endif
}

/* ==================================================================== */
/* INIT_FEATURES  */
void init_features(featureList_td *featureList)
{
  feature_td	*featureArray;
  float			v1,v2;
  int			num;
  int			a,b,p;
  int			x1,y1,x2,y2;
  int			i;

  printf("\n number of features = ");
  scanf("%d",&num);

  featureList->num = num;

  featureArray = (feature_td *)malloc(sizeof(feature_td)*num);
  featureList->features = featureArray;

  for (i=0; i<num; i++) {

    printf("\n input image1 feature line (x1,y1,x2,y2):" );
    scanf("%d %d %d %d",&x1,&y1,&x2,&y2);

    featureList->features[i].p1.x = x1;
    featureList->features[i].p1.y = y1;
    featureList->features[i].p2.x = x2;
    featureList->features[i].p2.y = y2;
  
    printf("\n input image2 feature line (x1,y1,x2,y2):" );
    scanf("%d %d %d %d",&x1,&y1,&x2,&y2);

    featureList->features[i].q1.x = x1;
    featureList->features[i].q1.y = y1;
    featureList->features[i].q2.x = x2;
    featureList->features[i].q2.y = y2;
  
    printf("\n input weights (a,b,p):" );
    scanf("%d %d %d",&a,&b,&p);

    LINEFEED

    featureList->features[i].a = a;
    featureList->features[i].b = b;
    featureList->features[i].p = p;

    v1 = featureList->features[i].p1.x-featureList->features[i].p2.x; 
    v2 = featureList->features[i].p1.y-featureList->features[i].p2.y; 
    featureList->features[i].plength = sqrt(v1*v1+v2*v2);

    v1 = featureList->features[i].q1.x-featureList->features[i].q2.x; 
    v2 = featureList->features[i].q1.y-featureList->features[i].q2.y; 
    featureList->features[i].qlength = sqrt(v1*v1+v2*v2);
  }
  
  return;
}


/* ==================================================================== */
/* INIT_BUFFER   */
void init_buffer()
{
  fill_rect(image1,0,0,WIDTH,HEIGHT,120,20,20);
  fill_rect(image1,50,50,10,100,0,0,0);
  fill_rect(image1,50,100,50,10,0,0,0);
  fill_rect(image1,50,150,100,10,0,0,0);
}

/* ==================================================================== */
/* FILL_RECT */
void fill_rect(char *buffer, int x, int y, int dx, int dy, int r, int g, int b)
{
  int   index;
  int	i,j;
  
  for (i=y; i<y+dy; i++) {
    for (j=x; j<x+dx; j++) {
      if ( (i>=0) && (i<HEIGHT) && (j>=0) && (j<WIDTH) ) {
	index = (WIDTH*i+j)*3;
        if ( (index>=0) && (index<BYTESIZE) ) {
	  buffer[index] = (char)r;
	  buffer[index+1] = (char)g;
	  buffer[index+2] = (char)b;
	}
	else
	  printf("\n bad fill data (1): %d,%d,%d,%d,%d,%d",
		 x,y,dx,dy,BYTESIZE,index);
      }
      else
	  printf("\n bad fill data (2): %d,%d,%d,%d",x,y,dx,dy);
	
    }
  }
}

/* ==================================================================== */
/* MORPH */
void morph(featureList_td *featureList)  
{
  float		a,b,p,length;
  xy_td		p1,p2,q1,q2;

  xy_td		vp,wp,vq,v;
  int		ii,jj,indexS,indexD;
  float		t,s;
  int		idisp,jdisp;
  float		weight;
  char		background[3];
  float		fcolor[3];
  int		i,j,k;

  background[0] = 120;
  background[1] = 20;
  background[2] = 20;

  for (i=0; i<HEIGHT; i++) {
    for (j=0; j<WIDTH; j++) {
      fcolor[0] = 0.0; fcolor[1] = 0.0; fcolor[2] = 0.0;
      weight = 0;
      idisp = 0; jdisp = 0;
      for (k=0; k<featureList->num; k++) {
        /* get info about kth feature line */
		a = featureList->features[k].a;
		b = featureList->features[k].b;
		p = featureList->features[k].p;
		p1.x = featureList->features[k].p1.x;
		p1.y = featureList->features[k].p1.y;
		p2.x = featureList->features[k].p2.x;
		p2.y = featureList->features[k].p2.y;
		q1.x = featureList->features[k].q1.x;
		q1.y = featureList->features[k].q1.y;
		q2.x = featureList->features[k].q2.x;
		q2.y = featureList->features[k].q2.y;
		length = featureList->features[k].qlength;

        /* get local feature coordinate system in image1 */
        vp.x = p2.x-p1.x;
        vp.y = p2.y-p1.y;
        wp.x = vp.y;
        wp.y = -vp.x;

        /* get feature vector in image2 */
        vq.x = q2.x-q1.x;
        vq.y = q2.y-q1.y;

        /* get vector from first feature point to pixel (image2) */
        v.x = j-q1.x;
        v.y = i-q1.y;

        /* get perpendicular distance from feature line to pixel (image2) */
        s = (v.x*vq.x + v.y*vq.y)/(length*length);
        t = (v.x*vq.y-v.y*vq.x)/(length*length); 

        /* use (s,t) and vp, wp to map to point in image1 space */
        jj = (int)(p1.x + s*vp.x + t*wp.x);
        ii = (int)(p1.y + s*vp.y + t*wp.y); 
        /* printf("\n %d,%d",ii,jj); */

        t = length/(a+t);
        jdisp += (jj-j)*t;
        idisp += (ii-i)*t;
        weight += t;
      }
      jdisp /= weight;
      idisp /= weight;
      ii = (int)(i+idisp);
      jj = (int)(j+jdisp);
      indexD = (WIDTH*i+j)*3;
      if ( (ii<0) || (ii>=HEIGHT) || (jj<0) || (jj>=WIDTH) ) {
		image2[indexD] = background[0];
		image2[indexD+1] = background[1];
		image2[indexD+2] = background[2];
      }
      else {
        indexS = (WIDTH*ii+jj)*3;
		image2[indexD] = image1[indexS];
		image2[indexD+1] = image1[indexS+1];
		image2[indexD+2] = image1[indexS+2];
      }

    }
  }
  /* imageSave(image2,WIDTH,HEIGHT,"test.bmp");  */
}

/* ============================================================================== */
/* DRAWGL */
static void drawGL(AGLContext ctx, char *values, int numu, int numv)
{
	int		i,j;
	float	xl,xr,yb,yt;
	int		pixel;
	
	/* Clear color buffer to yellow */
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	
	/* Draw a smooth shaded polygon */
	for (i=0; i<numu; i++) {
		for (j=0; j<numv; j++) {
			pixel = (j*numu + i)*3;
			xl = ((float)(i))/numu; xr = ((float)(i+1))/numu;
			yb = ((float)(j))/numv; yt = ((float)(j+1))/numv;
			xl = -1 + xl*2; xr = -1 + xr*2;
			yb = -1 + yb*2; yt = -1 + yt*2;
			glBegin(GL_POLYGON);
			glColor3d(values[pixel]/255.0,values[pixel+1]/255.0,values[pixel+2]/255.0);
			glVertex3d(xl,yb,0.0);
			glVertex3d(xl,yt,0.0);
			glVertex3d(xr,yt,0.0);
			glVertex3d(xr,yb,0.0);
			glEnd();
		}
	}

	/* Ensure completion */
	//glFinish();
	aglSwapBuffers(ctx);
}

/* ==================================================================== */
/* SETUP AGL */
static AGLContext setupAGL(AGLDrawable win)
{
	GLint          attrib[] = { AGL_RGBA, AGL_DOUBLEBUFFER, AGL_NONE };
	AGLPixelFormat fmt;
	AGLContext     ctx;
	GLboolean      ok;

	/* Choose an rgb pixel format */
	fmt = aglChoosePixelFormat(NULL, 0, attrib);
	if(fmt == NULL) return NULL;

	/* Create an AGL context */
	ctx = aglCreateContext(fmt, NULL);
	if(ctx == NULL) return NULL;

	/* Attach the window to the context */
	ok = aglSetDrawable(ctx, win);
	if(!ok) return NULL;
	
	/* Make the context the current context */
	ok = aglSetCurrentContext(ctx);
	if(!ok) return NULL;

	/* Pixel format is no longer needed */
	aglDestroyPixelFormat(fmt);

	return ctx;
}

/* ==================================================================== */
/* CLEANUP AGL */
static void cleanupAGL(AGLContext ctx)
{
	aglSetCurrentContext(NULL);
	aglSetDrawable(ctx, NULL);
	aglDestroyContext(ctx);
}

/* ==================================================================== */
/* SETUP SCREEN */
static CGrafPtr SetupScreen(void)
{
	OSStatus theError;

	CGrafPtr theFrontBuffer;

	theError = DSpStartup();
	if( theError )
		DebugStr("\pUnable to startup\n");
		
	gTheContextAttributes.displayWidth			= SCREEN_WIDTH;
	gTheContextAttributes.displayHeight			= SCREEN_HEIGHT;
	gTheContextAttributes.colorNeeds			= kDSpColorNeeds_Require;
	gTheContextAttributes.displayDepthMask		= kDSpDepthMask_16;
	gTheContextAttributes.displayBestDepth		= 16;
	gTheContextAttributes.pageCount				= 1;
	
	theError = DSpFindBestContext( &gTheContextAttributes, &gTheContext );
	if( theError )
		DebugStr("\pUnable to find a suitable device\n");
	
	theError = DSpContext_Reserve( gTheContext, &gTheContextAttributes );
	if( theError )
		DebugStr("\pUnable to create the display!");

	theError = DSpContext_FadeGammaOut( NULL, NULL );	
	if( theError )
		DebugStr("\pUnable to fade the display!");

	theError = DSpContext_SetState( gTheContext, kDSpContextState_Active );
	if( theError )
		DebugStr("\pUnable to set the display!");
		
	theError = DSpContext_FadeGammaIn( NULL, NULL );	
	if( theError )
		DebugStr("\pUnable to fade the display!");
		
	{
		// create a window to draw into
		Rect r;
		AuxWinHandle awh;
		r.top = r.left = 0;
		DSpContext_LocalToGlobal(gTheContext, (Point *)&r);
		r.right = r.left + SCREEN_WIDTH;
		r.bottom = r.top + SCREEN_HEIGHT;
		
		theFrontBuffer = (CGrafPtr)NewCWindow (NULL, &r, "\p", 0, plainDBox, (WindowPtr)-1, 0, 0);
		
		// set the content color of the window to black to avoid a white flash when the window appears.
		if(GetAuxWin ((WindowPtr)theFrontBuffer, &awh)){
			CTabHandle theColorTable;
			OSErr err;
			
			/*****/
			
			theColorTable = (**awh).awCTable;
			err = HandToHand((Handle*)&theColorTable);
			if(err)
				DebugStr("\pOut of memory!");

			(**theColorTable).ctTable[wContentColor].rgb.red = 0;
			(**theColorTable).ctTable[wContentColor].rgb.green = 0;
			(**theColorTable).ctTable[wContentColor].rgb.blue = 0;
			
			CTabChanged(theColorTable);
			
			// the color table will be disposed by the window manager when the window is disposed
			SetWinColor((WindowPtr)theFrontBuffer, (WCTabHandle)theColorTable);
			
		}
		ShowWindow((GrafPtr)theFrontBuffer);
		SetPort((GrafPtr)theFrontBuffer);
		
		{
			RGBColor b = { 0xFFFF, 0xFFFF, 0xFFFF };
			RGBColor f = { 0x0000, 0x0000, 0x0000 };
			
			RGBForeColor(&f);
			RGBBackColor(&b);
		}
	}
	return theFrontBuffer;
}

/* ==================================================================== */
/* SHUTDOWNSCREEN */
static void ShutdownScreen(CGrafPtr theFrontBuffer)
{
	DSpContext_FadeGammaOut( NULL, NULL );
	DisposeWindow((WindowPtr)theFrontBuffer);
	DSpContext_SetState( gTheContext, kDSpContextState_Inactive );
	DSpContext_FadeGammaIn( NULL, NULL );
	DSpContext_Release( gTheContext );
	DSpShutdown();
}