/* See slowplot.h */
/* Last edited on 2009-08-30 19:38:00 by stolfi */

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

#include <dgbasic.h>
#include <dgtree.h>
#include <dgbezier.h>
#include <dgbezpatch.h>
#include <dgplot.h>
#include <affirm.h>
#include <pswr.h>

#include <slowplot.h>

#define MAX_DDIM BZ_MAX_DDIM
#define MAX_RDIM BZ_MAX_RDIM

/* INTERNAL PROTOTYPES */

bz_patch_t *do_extract_face(bz_patch_t *b, box_face_index_t f);

/* IMPLEMENTATIONS */

void slow_plot(PSStream *ps, bz_patch_t *b)
  { 
    int BSTEPS = 10;
    double R = 1.0, G = 0.9, B = 0.6;
    int NF = ipow(3, b->m);
    int f;
    fprintf(stderr, "+slow_plot dim = %d\n", b->m);
    /* Plot faces */
    for (f = 0; f < NF; f++)
      { if (box_face_dimension(f, b->m) == 2)
        { bz_patch_t *t = do_extract_face(b, f);
          slow_plot_face(ps, t, BSTEPS, R, G, B);
          free(t->c); free(t);
        }
      }
    /* Plot edges */
    pswr_set_pen(ps, 0.0, 0.0, 0.0,   0.15, 0.0, 0.0);
    for (f = 0; f < NF; f++)
      { if (box_face_dimension(f, b->m) == 1)
        { bz_patch_t *t = do_extract_face(b, f);
          slow_plot_edge(ps, t, BSTEPS);
          free(t->c); free(t);
        }
      }
    /* Plot vertices */
    pswr_set_pen(ps, 0.0, 0.0, 0.0,   0.15, 0.0, 0.0);
    for (f = 0; f < NF; f++)
      if (box_face_dimension(f, b->m) == 0) 
        { bz_patch_t *t = do_extract_face(b, f);
          slow_plot_vertex(ps, t, BSTEPS);
          free(t->c); free(t);
        }
    fprintf(stderr, "-slow_plot\n");
  }

void slow_plot_vertex(PSStream *ps, bz_patch_t *b, int steps)
  {
    fprintf(stderr, "+slow_plot_vertex dim = %d\n", b->m);
    affirm(b->m == 0, "invalid vertex patch");
    pswr_set_fill_color(ps, 0.0,0.0,0.0);
    pswr_dot(ps, b->c[0], b->c[1], 0.25, TRUE, FALSE);
    fprintf(stderr, "-slow_plot_vertex\n");
  }

void slow_plot_edge(PSStream *ps, bz_patch_t *b, int steps)
  {
    fprintf(stderr, "+slow_plot_edge dim = %d\n", b->m);
    affirm(b->m == 1, "invalid edge patch");
    double p[2], q[2];
    int i;
    fprintf(stderr, "shape =\n");
    bz_print(stderr, b, "%6.2f");
    for (i = 0; i <= steps; i++)
      { double ui = ((double)i)/((double)steps);
        bz_eval(b, &ui, p);
        if (i > 0) { pswr_segment(ps, q[0], q[1], p[0], p[1]); }
        q[0] = p[0]; q[1] = p[1];
      }
    fprintf(stderr, "-slow_plot_edge\n");
  }

void slow_plot_face(PSStream *ps, bz_patch_t *b, int steps, double R, double G, double B)
  {
    int i, j;
    fprintf(stderr, "+slow_plot_face dim = %d\n", b->m);
    affirm(b->m == 2, "invalid face patch");
    fprintf(stderr, "shape =\n");
    bz_print(stderr, b, "%6.2f");
    double u[2], v[2];
    double p[MAX_RDIM], q[MAX_RDIM], r[MAX_RDIM], s[MAX_RDIM];
    for (i = 1; i <= steps; i++)
      { for (j = 0; j <= steps; j++)
          { u[0] = ((double)i)/((double)steps);
            u[1] = ((double)j)/((double)steps);
            bz_eval(b, u, p);
            v[0] = ((double)i-1)/((double)steps);
            v[1] = ((double)j)/((double)steps);
            bz_eval(b, v, r);
            if (j > 0) 
              { double xm = (p[0]+q[0]+r[0]+s[0])/4.0;
                double ym = (p[1]+q[1]+r[1]+s[1])/4.0;
                pswr_set_fill_color(ps, R,G,B);
                pswr_triangle(ps, p[0], p[1], q[0], q[1], xm, ym, TRUE, FALSE);
                pswr_triangle(ps, p[0], p[1], r[0], r[1], xm, ym, TRUE, FALSE);
                pswr_triangle(ps, s[0], s[1], q[0], q[1], xm, ym, TRUE, FALSE);
                pswr_triangle(ps, s[0], s[1], r[0], r[1], xm, ym, TRUE, FALSE);
              }
            q[0] = p[0]; q[1] = p[1];
            s[0] = r[0]; s[1] = r[1];
          }
      }
    fprintf(stderr, "-slow_plot_face\n");
  }

bz_patch_t *do_extract_face(bz_patch_t *b, box_face_index_t f)
  {
    dg_dim_t bm = b->m, tm = 0;
    box_signed_dir_t loc[MAX_DDIM];
    box_face_signature(f, bm, loc);
    bz_patch_t *t = (bz_patch_t *)notnull(malloc(sizeof(bz_patch_t)), "no mem");
    bz_degree_t tg[MAX_DDIM];
    int i;
    /* Extract degree sequence: */
    for(i = 0; i < bm; i++)
      { if (loc[i] == SMD) { tg[tm] = b->g[i]; tm++; } }
    (*t) = bz_patch_new(tm, b->n, tg);
    bz_get_face(b, loc, t, TRUE);
    return t;
  }