/* See pswr_stream.h */
/* Last edited on 2003-09-29 17:20:49 by stolfi */

#include <pswr_stream.h>

#include <pswr.h>
#include <vec.h>
#include <js.h>
#include <math.h>
#include <values.h>
#include <stdio.h>

#define TwoPi (2.0 * Pi)

#define Invisible ((Color){{-1,-1,-1}})

/* FILE AND PAGE CONTROL */

SOPlot_PageState *SOPlot_PageState_New
  ( bool eps, 
    char *paperSize,                       
    double hFigSize,    /* Figure width (in mm). */
    double vFigSize,    /* Figure height (in mm). */
    double hFigMargin,  /* Left/right margin for each figure (in mm). */
    double vFigMargin,  /* Top/bottom margin for each figure (in mm). */
    int captionLines,   /* Number of caption lines below each figure. */
    int hCount,         /* Number of figures in each row. */   
    int vCount          /* Number of figures in each column. */
  )
  { double mm = 72.0/25.4; 
  }

SOPlot_File *SOPlot_BeginFigure
  ( SOPlot_File *fps,
    SOPlot_PageState *pgs, 
    char *docName,
    char *figName, 
    double xmin, double xmax, 
    double ymin, double ymax
  )
  { 
  }
  
double SOPlot_DefaultFigSize
  ( bool eps, 
    char *paperSize, 
    int nRows, 
    int nCols,
    int captionLines
  )
  { if (nRows <= 0) { nRows = 1; }
    if (nCols <= 0) { nCols = 1; }
    if (eps)
      { return 150.0 / (nRows < nCols ? nRows : nCols); }
    else
      { double hsize, vsize;
        ps_get_paper_dimensions(paperSize, &hsize, &vsize);
        hsize = (hsize/72.0 - 2.0)*25.0/nCols; 
        vsize = ((vsize - 10.0*nRows*captionLines)/72.0 - 2.0)*25.0/nRows;
        if (hsize < 0.0) { hsize = 10.0; }
        if (vsize < 0.0) { vsize = 10.0; }
        return (hsize < vsize ? hsize : vsize);
      }
  }

double SOPlot_Brightness(Color *C)
  { 
    return 0.299 * C->c[0] + 0.587 * C->c[1] + 0.114 * C->c[2];
  }

Color SOPlot_ColorScale(double s, Color *A, Color *B)
  { double yA = SOPlot_Brightness(A) + 0.02;
    double yB = SOPlot_Brightness(B) + 0.02;
    double u, v;
    if (fabs(yA - yB) < 0.00001)
      { /* Same brightness, use linear interpolation: */
        v = s;
      }
    else
      { /* Interpolate brigtnesses in log scale: */
        double y = yA*exp(s*log(yB/yA));
        v = (y - yA)/(yB - yA);
        if (v < 0.0) { v = 0.0; }
        if (v > 1.0) { v = 1.0; }
      }
    u = 1.0 - v;
    return (Color)
      {{
        u*A->c[0] + v*B->c[0],
        u*A->c[1] + v*B->c[1],
        u*A->c[2] + v*B->c[2]
      }};
  }

Color SOPlot_InterpolateColor
  ( double f,         /* Function value */
    double fPlotMin,  /* Minimum function value. */
    Color *CMin,      /* Color to use for {fPlotMin}. */
    bool clipMin,     /* TRUE maps values below {fPlotMin} to invisible. */
    double fPlotMax,  /* Maximum function VALUE. */
    Color *CMax,      /* Color to use for {fPlotMax}. */
    bool clipMax      /* TRUE maps values above {fPlotMax} to invisible. */
  )
  { if (f < fPlotMin)
      { if (clipMin) { return Invisible; } else { return *CMin; } }
    else if (f > fPlotMax)
      { if (clipMax) { return Invisible; } else { return *CMax; } }
    else
      { double s = (f - fPlotMin)/(fPlotMax - fPlotMin);
        double t = 1.0 - s;
        return (Color)
          {{
            s*CMax->c[0] + t*CMin->c[0],
            s*CMax->c[1] + t*CMin->c[1],
            s*CMax->c[2] + t*CMin->c[2]
          }};
      }
  }
  
Color SOPlot_ClipColor(Color *C)
  { 
    double m = 0; int i;
    for (i = 0; i < 3; i++) 
      { double ci = fabs(C->c[i]); if (ci > m) { m = ci; } }
    if (m <= 1.0)
      { return *C; } 
    else
      { Color A = (Color){{C->c[0]/m, C->c[1]/m, C->c[2]/m}};
        double yC = SOPlot_Brightness(C);
        double yA = yC/m;
        double s = (yC < 1.0 ? yC : 1.0) - yA;
        return (Color)
          {{
            A.c[0] + s*(1.0 - A.c[0]),
            A.c[1] + s*(1.0 - A.c[1]),
            A.c[2] + s*(1.0 - A.c[2])
          }};
      }
  }