#include "hisview_view.h"
#include "hisview_misc.h"
#include "hisview_widgets.h"

#include <math.h>
#include <stdio.h>


void hsvimage(startf1, startf2, startf3,
	      xmin, xmax,
	      ymin, ymax,
	      startb, scalex, scaley,
	      clip1, clip2, clip3)

/* Addresses de depart des donnees 2Dfloat a extraire */
float  *startf1, *startf2, *startf3; 

int
  xmin,                /* Borne inferieure sur la 1ere dimension */
  xmax,                /* Borne superieure sur la 1ere dimension */
  ymin,                /* Borne inferieure sur la 2eme dimension */
  ymax;                /* Borne superieure sur la 2eme dimension */

unsigned char *startb; /* Addresse de depart de la zone memoire */
                       /* contenant les valeurs de pixel */

int
  scalex,              /* Facteur d'echelle selon la 1ere dimension */
  scaley;              /* Facteur d'echelle selon la 2eme dimension */

float clip1[2], clip2[2], clip3[2];
{
  int i, j, x, y, nh, ns, nv;
  float h, s, v, r, g, b;
  int width, height;
  float testh, testv, tests;
  float dist, newdist;
  unsigned char *p;

  if ((clip1[1] == clip1[0]) ||
      (clip2[1] == clip2[0]) ||
      (clip3[1] == clip3[0])) return;


  width = (xmax - xmin + 1)*scalex;
  height = (ymax - ymin + 1)*scaley;

  startb = startb + (height-1)*width;

  for (y = ymin ; y <= ymax ; y++) {
    p = startb;
    for (x = xmin ; x <= xmax ; x++) {
      testh = *startf1;
      tests = *startf2;
      testv = *startf3;

      h = ((testh - clip1[0])/(clip1[1] - clip1[0]))*270.;
      s = (tests - clip2[0])/(clip2[1] - clip2[0]);
      v = (testv - clip3[0])/(clip3[1] - clip3[0]);
      
      if (h < 0.)
	h = 0.;
      else {
	if (h > 270.) h =270.;
      }

      if (s < 0.)
	s = 0.;
      else {
	if (s > 1.) s = 1.;
      }
      if (v < 0.)
	v = 0.;
      else {
	if (v > 1.) v = 1.;
      }

      nh = 0;
      dist = (h - valhue[0])*(h - valhue[0]);
      for(i=1; i<nhue; i++) {
	newdist = (h - valhue[i])*(h - valhue[i]); 
	if (newdist < dist) {
	  nh = i;
	  dist = newdist;
	}
      }

      ns = 0;
      dist = (s - valsat[0])*(s - valsat[0]);
      for(i=1; i<nsat; i++) {
	newdist = (s - valsat[i])*(s - valsat[i]); 
	if (newdist < dist) {
	  ns = i;
	  dist = newdist;
	}
      }

      ns = nsat - 1 - ns;

      nv = 0;
      dist = (v - valval[0])*(v - valval[0]);
      for(i=1; i<nval; i++) {
	newdist = (v - valval[i])*(v - valval[i]); 
	if (newdist < dist) {
	  nv = i;
	  dist = newdist;
	}
      }

      j = nh*nsat*nval + nv*nsat + ns;

      memset(startb, colmap[j], scalex);
      startb += scalex;
      startf1++;
      startf2++;
      startf3++;
    }
    startb -=2*width;
    for (i = 1; i < scaley; i++) {
      (void) memcpy(startb, p, width);
      startb -= width;
    }
  }
}

unsigned char savcolmap[200];
extern int mode;
int myowncmap = 1;



/***********************************/
void allocROColors()
{
  int i, j, c, unique, p2alloc, third;
  int numcols = 200, nfcols=0; 

  XColor   defs[200];
  XColor   ctab[256];
  int      fc2pcol[200], failed[200], colAllocOrder[200];
  unsigned long freecols[200];

  unique = p2alloc = third = 0;

  for (i=0; i<200; i++) {
    failed[i] = 1;
    colAllocOrder[i] = i;
  }

  /* FIRST PASS */
  for (i=0; i<numcols; i++) {
    c = colAllocOrder[i];
    defs[c].red   = (unsigned short) (65535.*red[c]);
    defs[c].green = (unsigned short) (65535.*green[c]);
    defs[c].blue  = (unsigned short) (65535.*blue[c]);
    
    defs[c].flags = DoRed | DoGreen | DoBlue;

    if (XAllocColor(display,default_cmap,&defs[c])) {
      unsigned long *fcptr;

      colmap[c] = (unsigned char) defs[c].pixel;
      failed[c]=0;

      /* see if the newly allocated color is new and different */
      for (j=0,fcptr=freecols; j<nfcols && *fcptr!=defs[c].pixel; j++,fcptr++);
      if (j==nfcols) unique++;

      fc2pcol[nfcols] = c;
      freecols[nfcols++] = defs[c].pixel;
    }
    else {
      failed[c] = 1;
    }
  }
  
  
  if (nfcols==numcols) {
    if (numcols != unique)
      fprintf(stderr, "Got all %d colors.  (%d unique)", numcols,
	      unique);
    else 
      fprintf(stderr,"Got all %d colors.", numcols);
    return;
  }



  /* SECOND PASS COLOR ALLOCATION */
  fprintf(stderr,"Got %d of %d colors.  (%d unique)", 
	  nfcols,numcols,unique);

  unique = 0;

  for (i=0; i<256; i++) ctab[i].pixel = (unsigned long) i;
  XQueryColors(display, default_cmap, ctab, 256);
    
  for (i=0; i<numcols; i++) {
    c = colAllocOrder[i];
    
    if (failed[c]) {  /* an unallocated pixel */
      int d, mdist, close;
      int rd, gd, bd, ri, gi, bi;
      
      mdist = 1000000;   close = -1;
      ri = 255*red[c];  gi = 255*green[c];  bi = 255*blue[c];
      
      for (j=0; j<256; j++) {
	rd = ri - (ctab[j].red  >>8);
	gd = gi - (ctab[j].green>>8);
	bd = bi - (ctab[j].blue >>8);
	
	d = rd*rd + gd*gd + bd*bd;
	if (d<mdist) { mdist=d; close=j; }
      }
      
      if (close<0) fprintf(stderr, "%s\n", "This Can't Happen");
      if (XAllocColor(display,default_cmap,&ctab[close])) {
	unsigned long *fcptr;

	memcpy((char *) &defs[c], (char *) &ctab[close], sizeof(XColor));
	failed[c]= 0;
	colmap[c]  = (unsigned char) ctab[close].pixel;
	fc2pcol[nfcols] = c;
	freecols[nfcols++] = ctab[close].pixel;
	p2alloc++;

	/* see if the newly allocated color is new and different */
	for (j=0,fcptr=freecols; 
	     j<nfcols && *fcptr!=defs[c].pixel; j++,fcptr++);
	if (j==nfcols) unique++;
      }
    }
  }

  /*
  if (p2alloc) fprintf(stderr,"\nGot %d 'close' color%s.(%d unique)\n",
		       p2alloc, (p2alloc>1) ? "s" : "", unique);
		       */
  if (p2alloc) fprintf(stderr,"\nGot %d 'close' color%s.\n",
		       p2alloc, (p2alloc>1) ? "s" : "");

  
  if (nfcols == numcols) {
    return;
  }


  /* THIRD PASS COLOR ALLOCATION*/
  for (i=0; i<numcols; i++) {
    c = colAllocOrder[i];
    
    if (failed[c]) {  /* an unallocated pixel */
      int d, k, mdist, close;
      int rd,gd,bd, ri,gi,bi;
      
      mdist = 1000000;   close = -1;
      ri = 255*red[c];  gi = 255*green[c];  bi = 255*blue[c];
      
      /* search the alloc'd colors */
      for (j=0; j<nfcols; j++) {
	k = fc2pcol[j];
	rd = ri - (defs[k].red  >>8);
	gd = gi - (defs[k].green>>8);
	bd = bi - (defs[k].blue >>8);
	
	d = rd*rd + gd*gd + bd*bd;
	
	if (d<mdist) { mdist=d;  close=k; }
      }
      
      if (close<0) 
	fprintf(stderr, "%s\n", "Pass3: Failed to alloc ANY colors!");
      memcpy((char *) &defs[c], (char *) &defs[close], sizeof(XColor));
      failed[c]= 0;
      colmap[c]  = (unsigned char) defs[c].pixel;
      third++;
    }
  }
  if (third) 
    fprintf(stderr,
	    "Map %d remaining unalloced pixels into colors that we DID get\n",
	    third);
  
}


void change_mode(w, w_code, cbs)
Widget w;
int *w_code;
XmPushButtonCallbackStruct *cbs;
{
  XImage *image;
  char *pixels;
  
  int i;
  static int bool=0;

  if (bool)
    for (i = 0; i<200; i++) colmap[i] = savcolmap[i];
  else {
    for (i = 0; i<200; i++) savcolmap[i] = colmap[i];
    allocROColors();
  }

  pixels = (char*) malloc(size[0]*size[1]*sizeof(char));
  
  hsvimage(Himage, Simage, Vimage,
	   1, npix[0],
	   1, npix[1],
	   pixels, zoom, zoom,
	   Hclip, Sclip, Vclip);
  
  image = XCreateImage(display, visual, depth,
		       ZPixmap, 0, pixels, size[0], size[1], 8, 0);
  
  XPutImage(display, HSVpixmap, gc, image, 0, 0, 0, 0, size[0], size[1]);
  XFree(image);
    
  
  _2DfloatTo2Dbyte(Himage,
		   1, npix[0],
		   1, npix[1],
		   pixels, zoom, zoom,
		   Hclip); 
  
  image = XCreateImage(display, visual, depth,
		       ZPixmap, 0, pixels, size[0], size[1], 8, 0);
  
  
  XPutImage(display, Hpixmap, gc, image, 0, 0, 0, 0, size[0], size[1]);
  XFree(image);

  _2DfloatTo2Dbyte(Simage,
		   1, npix[0],
		   1, npix[1],
		   pixels, zoom, zoom,
		   Sclip); 
  
  image = XCreateImage(display, visual, depth,
		       ZPixmap, 0, pixels, size[0], size[1], 8, 0);
  
  XPutImage(display, Spixmap, gc, image, 0, 0, 0, 0, size[0], size[1]);
  
  _2DfloatTo2Dbyte(Vimage,
		   1, npix[0],
		   1, npix[1],
		   pixels, zoom, zoom,
		   Vclip); 
  
  image = XCreateImage(display, visual, depth,
		       ZPixmap, 0, pixels, size[0], size[1], 8, 0);
  
  XPutImage(display, Vpixmap, gc, image, 0, 0, 0, 0, size[0], size[1]);
  XFree(image);

  
  fprintf(stderr, "mode %d\n", mode);

  switch(mode) {
  case 0:
    XCopyArea(display, HSVpixmap, pixmap, gc,
	      0, 0, pixmapdim[0], pixmapdim[1], 0, 0);
    draw_wedge(Hclip);
    if (bool) hsvcolor_mode();
    break;
  case 1:
    XCopyArea(display, Hpixmap, pixmap, gc,
	      0, 0, pixmapdim[0], pixmapdim[1], 0, 0);
    draw_wedge(Hclip);
    if (bool) fullcolor_mode();
    break;
  case 2:
    XCopyArea(display, Spixmap, pixmap, gc,
	      0, 0, pixmapdim[0], pixmapdim[1], 0, 0);
    draw_wedge(Sclip);
    if (bool) gray_mode();
    break;
  case 3:
    XCopyArea(display, Vpixmap, pixmap, gc,
	      0, 0, pixmapdim[0], pixmapdim[1], 0, 0);
    draw_wedge(Vclip);
    if (bool) gray_mode();
    break;
  }

  free(pixels);

  XCopyArea(display, cpixmap, XtWindow(wedge), gc,
	    0, 0, cpixmapdim[0], pixmapdim[1], 0, 0);

  XCopyArea(display, pixmap, XtWindow(radec), gc,
	    0, 0, pixmapdim[0], pixmapdim[1], 0, 0);

   
  if (bool) {
    myowncmap = 1;
    bool = 0;
    XSetWindowColormap(display, XtWindow(toplevel), cmap);
  }
  else {
    myowncmap = 0;
    bool = 1;
    XSetWindowColormap(display, XtWindow(toplevel), default_cmap); 
  }
}