/*
 *  Copyright (c) 2011, Los Alamos National Security, LLC.
 *  All rights Reserved.
 *
 *  Copyright 2011. Los Alamos National Security, LLC. This software was produced 
 *  under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National 
 *  Laboratory (LANL), which is operated by Los Alamos National Security, LLC 
 *  for the U.S. Department of Energy. The U.S. Government has rights to use, 
 *  reproduce, and distribute this software.  NEITHER THE GOVERNMENT NOR LOS 
 *  ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR 
 *  ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE.  If software is modified
 *  to produce derivative works, such modified software should be clearly marked,
 *  so as not to confuse it with the version available from LANL.
 *
 *  Additionally, redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the Los Alamos National Security, LLC, Los Alamos 
 *       National Laboratory, LANL, the U.S. Government, nor the names of its 
 *       contributors may be used to endorse or promote products derived from 
 *       this software without specific prior written permission.
 *  
 *  THIS SOFTWARE IS PROVIDED BY THE LOS ALAMOS NATIONAL SECURITY, LLC 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 LOS ALAMOS NATIONAL
 *  SECURITY, LLC 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.
 *  
 *  CLAMR -- LA-CC-11-094
 *  This research code is being developed as part of the 
 *  2011 X Division Summer Workshop for the express purpose
 *  of a collaborative code for development of ideas in
 *  the implementation of AMR codes for Exascale platforms
 *  
 *  AMR implementation of the Wave code previously developed
 *  as a demonstration code for regular grids on Exascale platforms
 *  as part of the Supercomputing Challenge and Los Alamos 
 *  National Laboratory
 *  
 *  Authors: Bob Robey       XCP-2   brobey@lanl.gov
 *           Neal Davis              davis68@lanl.gov, davis68@illinois.edu
 *           David Nicholaeff        dnic@lanl.gov, mtrxknight@aol.com
 *           Dennis Trujillo         dptrujillo@lanl.gov, dptru10@gmail.com
 * 
 */
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include "graphics.h"

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

static int magick_on = 0;

#ifdef HAVE_MAGICKWAND
#include <wand/MagickWand.h>

#define MAGICK_NCOLORS 1280

void Magick_Scale();

//static int graphics_movie = 0;
static MagickWand *magick_wand = NULL;
static DrawingWand *draw_wand  = NULL;
static PixelWand *pixel_wand   = NULL;

struct MagickColorTable {
   int Red;
   int Blue;
   int Green;
};

static struct MagickColorTable MagickRainbow[MAGICK_NCOLORS];
#endif


#define WINSIZE 800

void DrawSquaresToFile(int graph_num, int ncycle, double simTime, int rollback_img, int rollback_num);

/*
 * Variables that I added to make everything work for getting graphics
 * data output to files while running no graphics with CLAMR
 * Brian Atkinson
*/
static int autoscale = 0;
static double xconversion = 0.0;
static double yconversion = 0.0;
static int Ncolors = 256;
static int iteration = 0;

char *graphics_directory = "graphics_output";
int graphics_type; // type of graphics output

//static int mode = MOVE;

static int width;
static float graphics_xmin=0.0, graphics_xmax=0.0, graphics_ymin=0.0, graphics_ymax=0.0;

static int graphics_outline   = 0;
static int graphics_view_mode = 0;
static int graphics_mysize    = 0;

enum spatial_data_type {SPATIAL_DOUBLE, SPATIAL_FLOAT};
static int spatial_type = SPATIAL_FLOAT;

static double *x_double=NULL, *y_double=NULL, *dx_double=NULL, *dy_double=NULL;
static float *x_float=NULL, *y_float=NULL, *dx_float=NULL, *dy_float=NULL;

enum plot_data_type {DATA_DOUBLE, DATA_FLOAT};
static int data_type = DATA_FLOAT;
static double *data_double=NULL;
static float *data_float=NULL;
static int *graphics_proc=NULL;

void init_graphics_output(void){
   width = (WINSIZE / (graphics_ymax - graphics_ymin)) * (graphics_xmax - graphics_xmin);
   xconversion = (double)WINSIZE/ (graphics_xmax - graphics_xmin);
   yconversion = (double)WINSIZE/(graphics_ymax - graphics_ymin);

   struct stat stat_descriptor;
   if (stat(graphics_directory,&stat_descriptor) == -1){
     mkdir(graphics_directory,0777);
   }

   if (graphics_type != GRAPHICS_DATA && graphics_type != GRAPHICS_NONE) magick_on = 1;

#ifdef HAVE_MAGICKWAND
   if (magick_on){
      //MagickWandGenesis(); 
      // Create wand
      magick_wand = NewMagickWand();

      Magick_Scale();
   }
#endif
}

void terminate_graphics_output(void){
#ifdef HAVE_MAGICKWAND
   if (magick_on){
      magick_wand = DestroyMagickWand(magick_wand);
      MagickWandTerminus();
   }
#endif
}

void set_graphics_window(float graphics_xmin_in, float graphics_xmax_in, float graphics_ymin_in, float graphics_ymax_in){
   graphics_xmin = graphics_xmin_in;
   graphics_xmax = graphics_xmax_in;
   graphics_ymin = graphics_ymin_in;
   graphics_ymax = graphics_ymax_in;
}
void set_graphics_cell_data_double(double *data_in){
   data_type = DATA_DOUBLE;
   data_double = data_in;
}
void set_graphics_cell_data_float(float *data_in){
   data_type = DATA_FLOAT;
   data_float = data_in;
}
void set_graphics_cell_proc(int *graphics_proc_in){
   graphics_proc = graphics_proc_in;
}
void set_graphics_cell_coordinates_double(double *x_in, double *dx_in, double *y_in, double *dy_in){
   spatial_type = SPATIAL_DOUBLE;
   x_double = x_in;
   dx_double = dx_in;
   y_double = y_in;
   dy_double = dy_in;
}
void set_graphics_cell_coordinates_float(float *x_in, float *dx_in, float *y_in, float *dy_in){
   spatial_type = SPATIAL_FLOAT;
   x_float = x_in;
   dx_float = dx_in;
   y_float = y_in;
   dy_float = dy_in;
}
void set_graphics_viewmode(int graphics_view_mode_in){
   graphics_view_mode = graphics_view_mode_in;
}
void set_graphics_mysize(int graphics_mysize_in){
   graphics_mysize = graphics_mysize_in;
}
void set_graphics_outline(int graphics_outline_in){
   graphics_outline = graphics_outline_in;
}

/*
 * Created this function get graphics data while running
 * the no graphic version of CLAMR. The output for the main
 * cell data is written out to graph#.data files and the gridline
 * data is writeen out to outline#.lin files.
 * Brian Atkinson
*/
void DrawSquaresToFile(int graph_num, int ncycle, double simTime, int rollback_img, int rollback_num){
#ifdef HAVE_MAGICKWAND
   if (magick_on) {
      draw_wand   = NewDrawingWand();
      pixel_wand  = NewPixelWand();

      MagickSetSize(magick_wand,WINSIZE,WINSIZE);
      MagickSetColorspace(magick_wand,sRGBColorspace);
      MagickReadImage(magick_wand,"xc:white");

      DrawSetViewbox(draw_wand, 0, 0, WINSIZE, WINSIZE);
      DrawScale(draw_wand, xconversion, -yconversion);
      DrawTranslate(draw_wand, -graphics_xmin, graphics_ymin);

      int npart = graphics_mysize/16;
      for (int i=0; i<graphics_mysize; i++){
         graphics_proc[i] = i/npart;
      }

      int magick_step = MAGICK_NCOLORS/(graphics_proc[graphics_mysize-1]+1);

      if (graphics_outline) {
         PixelGetBlack(pixel_wand);

         DrawSetStrokeColor(draw_wand,pixel_wand);
         DrawSetStrokeWidth(draw_wand,0.01);
         DrawSetStrokeAntialias(draw_wand,1);
         DrawSetStrokeOpacity(draw_wand,1);
      }

      if (data_type == DATA_DOUBLE){

         for(int i = 0; i < graphics_mysize; i++) {
            int magick_color = graphics_proc[i]*magick_step;
            char cstring[40];
            sprintf(cstring,"rgba(%d,%d,%d,%d)",MagickRainbow[magick_color].Red,
                                                MagickRainbow[magick_color].Green,
                                                MagickRainbow[magick_color].Blue,120);
            PixelSetColor(pixel_wand, cstring);
            

            DrawSetFillColor(draw_wand, pixel_wand); 

            DrawRectangle(draw_wand, x_double[i],              y_double[i],
                                     x_double[i]+dx_double[i], y_double[i]+dy_double[i]);
/*
           printf("DEBUG -- i %d magick_color %d magick_step %d graphics_proc %d cstring %s corners %lg %lg %lg %lg\n",
               i,magick_color,magick_step,graphics_proc[i],cstring,
               x_double[i],              y_double[i],
               x_double[i]+dx_double[i], y_double[i]+dy_double[i]);
*/
         }

         if (graphics_outline) {
	    PixelSetColor(pixel_wand,"black");
	    DrawSetStrokeColor(draw_wand,pixel_wand);
	    DrawSetStrokeWidth(draw_wand,0.01);

            double xold = x_double[0]+0.5*dx_double[0];
            double yold = y_double[0]+0.5*dy_double[0];

            for(int i = 0; i < graphics_mysize; i++) {
               char cstring[40];
               sprintf(cstring,"%d",i);

               double xnew = x_double[i]+0.5*dx_double[i];
               double ynew = y_double[i]+0.5*dy_double[i];

               DrawLine(draw_wand, xold, yold, xnew, ynew);

               xold = xnew;
               yold = ynew;
            }
         }

/*
         // Set up a 12 point black font 
	 PixelSetColor(pixel_wand,"black");
	 DrawSetFillColor(draw_wand,pixel_wand);
	 DrawSetFont (draw_wand, "Courier" ) ;
	 DrawSetFontSize(draw_wand,0.01);
	 DrawSetStrokeColor(draw_wand,pixel_wand);
	 DrawSetStrokeWidth(draw_wand,0.01);
         DrawSetTextDirection(draw_wand, RightToLeftDirection);
         DrawSetTextAlignment(draw_wand, CenterAlign);
         DrawSetTextAntialias(draw_wand,MagickTrue);

         for(int i = 1; i < graphics_mysize; i++) {
            char cstring[40];
            sprintf(cstring,"%d",i);


            DrawAnnotation(draw_wand, x_double[i]+0.5*dx_double[i], y_double[i]+0.5*dy_double[i], cstring);
         }
*/

      } else {

         for(int i = 0; i < graphics_mysize; i++) {
            int magick_color = graphics_proc[i]*magick_step;
            char cstring[40];
            sprintf(cstring,"rgba(%d,%d,%d,%d)",MagickRainbow[magick_color].Red,
                                                MagickRainbow[magick_color].Green,
                                                MagickRainbow[magick_color].Blue,120);
            PixelSetColor(pixel_wand, cstring);

            DrawSetFillColor(draw_wand, pixel_wand);

            DrawRectangle(draw_wand, x_float[i],             y_float[i],
                                     x_float[i]+dx_float[i], y_float[i]+dy_float[i]);
         }

         if (graphics_outline) {
	    PixelSetColor(pixel_wand,"black");
	    DrawSetStrokeColor(draw_wand,pixel_wand);
	    DrawSetStrokeWidth(draw_wand,0.01);

            float xold = x_float[0]+0.5*dx_float[0];
            float yold = y_float[0]+0.5*dy_float[0];

            for(int i = 0; i < graphics_mysize; i++) {
               char cstring[40];
               sprintf(cstring,"%d",i);

               float xnew = x_float[i]+0.5*dx_float[i];
               float ynew = y_float[i]+0.5*dy_float[i];

               DrawLine(draw_wand, xold, yold, xnew, ynew);

               xold = xnew;
               yold = ynew;
            }
         }

      }

      MagickDrawImage(magick_wand, draw_wand);

      char filename[50];
      char graphics_file_extension[10];
      if (graphics_type == GRAPHICS_BMP)  strcpy(graphics_file_extension,".bmp");
      if (graphics_type == GRAPHICS_GIF)  strcpy(graphics_file_extension,".gif");
      if (graphics_type == GRAPHICS_JPEG) strcpy(graphics_file_extension,".jpeg");
      if (graphics_type == GRAPHICS_MPEG) strcpy(graphics_file_extension,".mpeg");
      if (graphics_type == GRAPHICS_PDF)  strcpy(graphics_file_extension,".pdf");
      if (graphics_type == GRAPHICS_PNG)  strcpy(graphics_file_extension,".png");
      if (graphics_type == GRAPHICS_SVG)  strcpy(graphics_file_extension,".svg");
      sprintf(filename,"%s/graph%05d%s", graphics_directory, graph_num, graphics_file_extension);
      MagickWriteImage(magick_wand, filename);
      //MagickDisplayImage(magick_wand, "x:");

      draw_wand = DestroyDrawingWand(draw_wand);
      pixel_wand = DestroyPixelWand(pixel_wand);
   }
#endif

   if (graphics_type == GRAPHICS_DATA){
      int i, color;
      int step = Ncolors/(graphics_proc[graphics_mysize-1]+1);
      int xloc, xwid, yloc, ywid;
      int xloc1, xloc2, yloc1, yloc2;
      char filename[50], filename2[50];
   
      if(rollback_img){
         sprintf(filename,"%s/graph%dcp%05d.data", graphics_directory, graph_num, rollback_num);
         sprintf(filename2,"%s/outline%dcp%05d.lin",graphics_directory, graph_num, rollback_num);
      }
      else{
         sprintf(filename,"%s/graph%05d.data", graphics_directory, graph_num);
         sprintf(filename2,"%s/outline%05d.lin",graphics_directory, graph_num);
      }
      FILE *fp = fopen(filename,"w");
      FILE *fp2 = fopen(filename2,"w");
      if(fp && fp2){
         fprintf(fp,"%d,%lf\n",ncycle,simTime);
         if (data_type == DATA_DOUBLE){
            for(i = 0; i < graphics_mysize; i++) {
               xloc = (int)((x_double[i]-graphics_xmin)*xconversion);
               xwid = (int)((x_double[i]+dx_double[i]-graphics_xmin)*xconversion-xloc);
               yloc = (int)((graphics_ymax-(y_double[i]+dy_double[i]))*yconversion);
               ywid = (int)((graphics_ymax-y_double[i])*yconversion);
               ywid -= yloc;
               color = graphics_proc[i]*step;
               //fprintf(fp,"%d,%d,%d,%d,%f\n",xloc,yloc,xwid,ywid,data[i]);
               fprintf(fp,"%d,%d,%d,%d,%d\n",xloc,yloc,xwid,ywid,color);
            
               xloc1 = (int)((x_double[i]-graphics_xmin)*xconversion);
               xloc2 = (int)((x_double[i]+dx_double[i]-graphics_xmin)*xconversion);
               yloc1 = (int)((graphics_ymax-y_double[i])*yconversion);
               yloc2 = (int)((graphics_ymax-(y_double[i]+dy_double[i]))*yconversion);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc2,xloc2,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc2,yloc1);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc1,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc2,yloc1,xloc2,yloc2);
            }
         } else {
            for(i = 0; i < graphics_mysize; i++) {
               xloc = (int)((x_float[i]-graphics_xmin)*xconversion);
               xwid = (int)((x_float[i]+dx_float[i]-graphics_xmin)*xconversion-xloc);
               yloc = (int)((graphics_ymax-(y_float[i]+dy_float[i]))*yconversion);
               ywid = (int)((graphics_ymax-y_float[i])*yconversion);
               ywid -= yloc;
               color = graphics_proc[i]*step;
               //fprintf(fp,"%d,%d,%d,%d,%f\n",xloc,yloc,xwid,ywid,data[i]);
               fprintf(fp,"%d,%d,%d,%d,%d\n",xloc,yloc,xwid,ywid,color);
         
               xloc1 = (int)((x_float[i]-graphics_xmin)*xconversion);
               xloc2 = (int)((x_float[i]+dx_float[i]-graphics_xmin)*xconversion);
               yloc1 = (int)((graphics_ymax-y_float[i])*yconversion);
               yloc2 = (int)((graphics_ymax-(y_float[i]+dy_float[i]))*yconversion);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc2,xloc2,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc2,yloc1);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc1,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc2,yloc1,xloc2,yloc2);
            }
         }
         fclose(fp);
         fclose(fp2);
         iteration++;
      }   
      else{
            if(fp == NULL){
               printf("Could not create %s in DrawSqaures\n", filename);
            }
            else{
               printf("Could not create %s in DrawSqaures\n", filename2);
            }
      }
   }
}

/*
 * Created this function get graphics data while running
 * the no graphic version of CLAMR. The output for the main
 * cell data is written out to graph#.data files and the gridline
 * data is writeen out to outline#.lin files.
 * Brian Atkinson
*/
void DisplayStateToFile(int graph_num, int ncycle, double simTime, int rollback_img, int rollback_num){
#ifdef HAVE_MAGICKWAND
   if (magick_on) {
      double scaleMax = 25.0, scaleMin = 0.0;

      draw_wand   = NewDrawingWand();
      pixel_wand  = NewPixelWand();

      MagickSetSize(magick_wand,WINSIZE,WINSIZE);
      MagickSetColorspace(magick_wand,sRGBColorspace);
      MagickReadImage(magick_wand,"xc:white");

      DrawSetViewbox(draw_wand, 0, 0, WINSIZE, WINSIZE);
      DrawScale(draw_wand, xconversion, -yconversion);
      DrawTranslate(draw_wand, -graphics_xmin, graphics_ymin);

      if (autoscale) {
         scaleMax=-1.0e30;
         scaleMin=1.0e30;
         if (data_type == DATA_DOUBLE){
            for(int i = 0; i<graphics_mysize; i++) {
               if (data_double[i] > scaleMax) scaleMax = data_double[i];
               if (data_double[i] < scaleMin) scaleMin = data_double[i];
            }
         } else {
            for(int i = 0; i<graphics_mysize; i++) {
               if (data_float[i] > scaleMax) scaleMax = data_float[i];
               if (data_float[i] < scaleMin) scaleMin = data_float[i];
            }
         }
      }

      int magick_step = MAGICK_NCOLORS/(scaleMax - scaleMin);

      if (graphics_outline) {
         PixelGetBlack(pixel_wand);

         DrawSetStrokeColor(draw_wand,pixel_wand);
         DrawSetStrokeWidth(draw_wand,0.01);
         DrawSetStrokeAntialias(draw_wand,1);
         DrawSetStrokeOpacity(draw_wand,1);
      }

      if (data_type == DATA_DOUBLE){

         for(int i = 0; i < graphics_mysize; i++) {
            int magick_color;
            if (data_type == DATA_DOUBLE){
               magick_color = (int)(data_double[i]-scaleMin)*magick_step;
            } else {
               magick_color = (int)(data_float[i]-scaleMin)*magick_step;
            }
            magick_color = MAGICK_NCOLORS-magick_color;
            if (magick_color < 0) {
               magick_color=0;
            }
            if (magick_color >= MAGICK_NCOLORS) magick_color = MAGICK_NCOLORS-1;

            char cstring[40];
            sprintf(cstring,"rgba(%d,%d,%d,%d)",MagickRainbow[magick_color].Red,
                                                MagickRainbow[magick_color].Green,
                                                MagickRainbow[magick_color].Blue,120);
            PixelSetColor(pixel_wand, cstring);

            DrawSetFillColor(draw_wand, pixel_wand);

            DrawRectangle(draw_wand, x_double[i],              y_double[i],
                                     x_double[i]+dx_double[i], y_double[i]+dy_double[i]);
/*
           printf("DEBUG -- i %d magick_color %d magick_step %d graphics_proc %d cstring %s corners %lg %lg %lg %lg\n",
               i,magick_color,magick_step,graphics_proc[i],cstring,
               x_double[i],              y_double[i],
               x_double[i]+dx_double[i], y_double[i]+dy_double[i]);
*/
         }
      } else {

         for(int i = 0; i < graphics_mysize; i++) {
            int magick_color;
            if (data_type == DATA_DOUBLE){
               magick_color = (int)(data_double[i]-scaleMin)*magick_step;
            } else {
               magick_color = (int)(data_float[i]-scaleMin)*magick_step;
            }
            magick_color = MAGICK_NCOLORS-magick_color;
            if (magick_color < 0) {
               magick_color=0;
            }
            if (magick_color >= MAGICK_NCOLORS) magick_color = MAGICK_NCOLORS-1;

            char cstring[40];
            sprintf(cstring,"rgba(%d,%d,%d,%d)",MagickRainbow[magick_color].Red,
                                                MagickRainbow[magick_color].Green,
                                                MagickRainbow[magick_color].Blue,120);
            PixelSetColor(pixel_wand, cstring);

            DrawSetFillColor(draw_wand, pixel_wand);

            DrawRectangle(draw_wand, x_float[i],             y_float[i],
                                     x_float[i]+dx_float[i], y_float[i]+dy_float[i]);
         }
      }

      MagickDrawImage(magick_wand, draw_wand);

      char filename[50];
      char graphics_file_extension[10];
      if (graphics_type == GRAPHICS_BMP)  strcpy(graphics_file_extension,".bmp");
      if (graphics_type == GRAPHICS_GIF)  strcpy(graphics_file_extension,".gif");
      if (graphics_type == GRAPHICS_JPEG) strcpy(graphics_file_extension,".jpeg");
      if (graphics_type == GRAPHICS_MPEG) strcpy(graphics_file_extension,".mpeg");
      if (graphics_type == GRAPHICS_PDF)  strcpy(graphics_file_extension,".pdf");
      if (graphics_type == GRAPHICS_PNG)  strcpy(graphics_file_extension,".png");
      if (graphics_type == GRAPHICS_SVG)  strcpy(graphics_file_extension,".svg");
      sprintf(filename,"%s/graph%05d%s", graphics_directory, graph_num, graphics_file_extension);
      MagickWriteImage(magick_wand, filename);
      //MagickDisplayImage(magick_wand, "x:");

      draw_wand = DestroyDrawingWand(draw_wand);
      pixel_wand = DestroyPixelWand(pixel_wand);
   }
#endif
   if (graphics_type == GRAPHICS_DATA){
      double scaleMax = 25.0, scaleMin = 0.0;
      int i;
      int color;
      char filename[50], filename2[50];
   
      if(rollback_img){
         sprintf(filename,"%s/graph%dcp%05d.data", graphics_directory, graph_num, rollback_num);
         sprintf(filename2,"%s/outline%dcp%05d.lin",graphics_directory, graph_num, rollback_num);
      }
      else{
         sprintf(filename,"%s/graph%05d.data", graphics_directory, graph_num);
         sprintf(filename2,"%s/outline%05d.lin",graphics_directory, graph_num);
      }
      FILE *fp = fopen(filename,"w");
      FILE *fp2 = fopen(filename2,"w");
      if(fp && fp2){
         fprintf(fp,"%d,%lf\n",ncycle,simTime);
         if (autoscale) {
            scaleMax=-1.0e30;
            scaleMin=1.0e30;
            if (data_type == DATA_DOUBLE){
               for(i = 0; i<graphics_mysize; i++) {
                  if (data_double[i] > scaleMax) scaleMax = data_double[i];
                  if (data_double[i] < scaleMin) scaleMin = data_double[i];
               }
            } else {
               for(i = 0; i<graphics_mysize; i++) {
                  if (data_float[i] > scaleMax) scaleMax = data_float[i];
                  if (data_float[i] < scaleMin) scaleMin = data_float[i];
               }
            }
         }

         double step = Ncolors/(scaleMax - scaleMin);
         int xloc, xwid, yloc, ywid;
         int xloc1, xloc2, yloc1, yloc2;
         for(i = 0; i < graphics_mysize; i++) {
            if (data_type == DATA_DOUBLE){
               color = (int)(data_double[i]-scaleMin)*step;
            } else {
               color = (int)(data_float[i]-scaleMin)*step;
            }
            color = Ncolors-color;
            if (color < 0) {
               color=0;
            }
            if (color >= Ncolors) color = Ncolors-1;

            if (data_type == DATA_DOUBLE){
               xloc = (int)((x_double[i]-graphics_xmin)*xconversion);
               xwid = (int)((x_double[i]+dx_double[i]-graphics_xmin)*xconversion-xloc);
               yloc = (int)((graphics_ymax-(y_double[i]+dy_double[i]))*yconversion);
               ywid = (int)((graphics_ymax-y_double[i])*yconversion);
               ywid -= yloc;
               //fprintf(fp,"%d,%d,%d,%d,%f\n",xloc,yloc,xwid,ywid,data[i]);
               fprintf(fp,"%d,%d,%d,%d,%d\n",xloc,yloc,xwid,ywid,color);
         
               xloc1 = (int)((x_double[i]-graphics_xmin)*xconversion);
               xloc2 = (int)((x_double[i]+dx_double[i]-graphics_xmin)*xconversion);
               yloc1 = (int)((graphics_ymax-y_double[i])*yconversion);
               yloc2 = (int)((graphics_ymax-(y_double[i]+dy_double[i]))*yconversion);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc2,xloc2,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc2,yloc1);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc1,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc2,yloc1,xloc2,yloc2);
            } else {
               xloc = (int)((x_float[i]-graphics_xmin)*xconversion);
               xwid = (int)((x_float[i]+dx_float[i]-graphics_xmin)*xconversion-xloc);
               yloc = (int)((graphics_ymax-(y_float[i]+dy_float[i]))*yconversion);
               ywid = (int)((graphics_ymax-y_float[i])*yconversion);
               ywid -= yloc;
               //fprintf(fp,"%d,%d,%d,%d,%f\n",xloc,yloc,xwid,ywid,data[i]);
               fprintf(fp,"%d,%d,%d,%d,%d\n",xloc,yloc,xwid,ywid,color);
         
               xloc1 = (int)((x_float[i]-graphics_xmin)*xconversion);
               xloc2 = (int)((x_float[i]+dx_float[i]-graphics_xmin)*xconversion);
               yloc1 = (int)((graphics_ymax-y_float[i])*yconversion);
               yloc2 = (int)((graphics_ymax-(y_float[i]+dy_float[i]))*yconversion);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc2,xloc2,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc2,yloc1);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc1,yloc1,xloc1,yloc2);
               fprintf(fp2,"%d,%d,%d,%d\n",xloc2,yloc1,xloc2,yloc2);
            }
         }
         fclose(fp);
         fclose(fp2);   
         iteration++;
     }
     else{
        if(fp == NULL){
            printf("Could not open %s in DisplayStateToFile\n", filename);
        }
        else{
            printf("Could not open %s in DisplayStateToFile\n", filename2);
        }
     }
  }
}

void write_graphics_info(int graph_num, int ncycle, double simTime, int rollback_img, int rollback_num){
   if (graphics_view_mode == 0) {
      DrawSquaresToFile(graph_num, ncycle, simTime, rollback_img, rollback_num);
   } else {
      DisplayStateToFile(graph_num, ncycle, simTime, rollback_img, rollback_num);
   }
}

#ifdef HAVE_MAGICKWAND
void Magick_Scale() {
   int i, r;
   for (i=0, r=0;   i<256; i++, r++) {
         MagickRainbow[     i].Red   = 0;
         MagickRainbow[     i].Green = r;
         MagickRainbow[     i].Blue  = 255;
   }
   for (i=0, r=255; i<256; i++, r--) {
         MagickRainbow[ 256+i].Red   = 0;
         MagickRainbow[ 256+i].Green = 255;
         MagickRainbow[ 256+i].Blue  = r;
   }
   for (i=0, r=0;   i<256; i++, r++) {
         MagickRainbow[ 512+i].Red   = r;
         MagickRainbow[ 512+i].Green = 255;
         MagickRainbow[ 512+i].Blue  = 0;
   }
   for (i=0, r=255; i<256; i++, r--) {
         MagickRainbow[ 768+i].Red   = 255;
         MagickRainbow[ 768+i].Green = r;
         MagickRainbow[ 768+i].Blue  = 0;
   }
   for (i=0, r=0;   i<256; i++, r++) {
         MagickRainbow[1024+i].Red   = 255;
         MagickRainbow[1024+i].Green = 0;
         MagickRainbow[1024+i].Blue  = r;
   }
}
#endif