/* Last edited on 2024-12-21 14:02:16 by stolfi */

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>

#include <bool.h>
#include <epswr.h>
#include <affirm.h>
#include <r3.h>
#include <hedge.h>
#include <hedge_draw.h>
#include <toposlice_numdefs.h>

#include <toposlice_hedge_fig.h>

#define debug FALSE

hedge_t *toposlice_hedge_fig_create_mesh(void);
  /* Creates the half-edge mesh structure for th efigure. */

#define sex hedge_set_next

void toposlice_hedge_fig_make(char *name, bool_t nodes)
  { 
    if (debug) { fprintf(stderr, "  > enter %s...\n", __FUNCTION__); }
    
    hedge_t *H = toposlice_hedge_fig_create_mesh();
    double dunit = H->dunit;
        
    double xmin, xmax, ymin, ymax; /* Figure range in mm. */
    hedge_draw_get_plot_bounds(H, &xmin, &xmax, &ymin, &ymax);
    double hsz = (xmax - xmin)*epswr_pt_per_mm;
    double vsz = (ymax - ymin)*epswr_pt_per_mm;
    double mrg = 2*epswr_pt_per_mm;
    epswr_figure_t *eps = epswr_new_named_figure("out", NULL, name, -1, NULL, hsz, vsz, mrg,mrg,mrg,mrg, TRUE);
    epswr_set_client_window(eps, xmin, xmax, ymin, ymax);
    
    if (nodes)
      { /* Draw the mesh lightly: */
        epswr_set_pen(eps, 0.900,0.800,0.700, 1.00, 0,0);
        epswr_set_fill_color(eps, 0.900,0.800,0.700);
        
        bool_t ghosts = TRUE; /* Irrelevant since there are no ghost edges. */
        hedge_draw_mesh(eps, H, ghosts);

        /* Draw the record boxes with white fill: */
        epswr_set_pen(eps, 0,0,0, 0.25, 0,0);
        epswr_set_fill_color(eps, 1.000,1.000,1.000);
        for (uint32_t ka = 0;  ka < H->na; ka++)
          { hedge_draw_arc_record(eps, H->A.e[ka], 1.0); }
        epswr_set_fill_color(eps, 0.800,0.800,0.800);
        for (uint32_t kf = 0;  kf < H->nf; kf++)
          { hedge_draw_face_record(eps, H->F.e[kf], 1.0); }
        epswr_set_fill_color(eps, 1.000,1.000,1.000);
        for (uint32_t kv = 0;  kv < H->nv; kv++)
          { hedge_draw_vert_record(eps, H->V.e[kv], 1.0); }
          
        /* Draw the {next} and {twin} links with solid lines and black fill: */
        epswr_set_pen(eps, 0,0,0, 0.25, 0,0);
        epswr_set_fill_color(eps, 0.000,0.000,0.000);
        for (uint32_t ka = 0;  ka < H->na; ka++)
          { hedge_draw_arc_next_link(eps, H->A.e[ka], dunit);
            hedge_draw_arc_twin_link(eps, H->A.e[ka], dunit);
          }
          
        /* Draw the {side} and {out} links with solid lines and black fill: */
        epswr_set_pen(eps, 0,0,0, 0.25, 0,0);
        epswr_set_fill_color(eps, 0.000,0.000,0.000);
        for (uint32_t kf = 0;  kf < H->nf; kf++)
          { hedge_draw_face_side_link(eps, H->F.e[kf], dunit); }
        for (uint32_t kv = 0;  kv < H->nv; kv++)
          { hedge_draw_vert_out_link(eps, H->V.e[kv], dunit); }
          
        /* Draw the {left} links with dashed lines and black fill: */
        epswr_set_pen_color(eps, 0,0,0);
        epswr_set_pen_width(eps, 0.12*H->dunit);
        epswr_set_fill_color(eps, 0.000,0.000,0.000);
        for (uint32_t ka = 0;  ka < H->na; ka++)
          { epswr_set_pen_dashing(eps, 1.50,1.00);
            hedge_draw_arc_left_link(eps, H->A.e[ka], dunit);
          }
          
        /* Draw the {org} links with dotted lines and black fill: */
        epswr_set_pen_color(eps, 0,0,0);
        epswr_set_pen_width(eps, 0.12*H->dunit);
        epswr_set_fill_color(eps, 0.000,0.000,0.000);
        for (uint32_t ka = 0;  ka < H->na; ka++)
          { epswr_set_pen_dashing(eps, 0.50,0.75);
            hedge_draw_arc_org_link(eps, H->A.e[ka], dunit);
          }
      }
    else
      { /* The reference arc for the operators. */
        hedge_arc_t *e = H->A.e[2]; 
        
        /* Paint the adjacent faces with light tones: */
        epswr_set_fill_color(eps, 0.950,0.950,0.900);
        hedge_fill_face(eps, e->left);
        
        epswr_set_fill_color(eps, 0.900,0.950,0.950);
        hedge_fill_face(eps, e->twin->left);

        epswr_set_pen(eps, 0,0,0, 0.50, 0,0);
        epswr_set_fill_color(eps, 0,0,0);
        bool_t ghosts = TRUE; /* Irrelevant since there are no ghost edges. */
        hedge_draw_mesh(eps, H, ghosts);

        /* Compute {eprev = e.eprev}: */
        hedge_arc_t *eprev = e;
        while(eprev->next != e) { eprev = eprev->next; }
    
        double etim = 0.35;  /* Relative position of arrowhead tip along edge. */
        epswr_set_pen(eps, 0,0,0, 0.50, 0,0);
        epswr_set_fill_color(eps, 0,0,0);
        hedge_draw_arc_arrowhead(eps, e,             etim, dunit);
        hedge_draw_arc_arrowhead(eps, e->twin,       etim, dunit);
        hedge_draw_arc_arrowhead(eps, e->next,       etim, dunit);
        hedge_draw_arc_arrowhead(eps, eprev,         etim, dunit);
        hedge_draw_arc_arrowhead(eps, e->twin->next, etim, dunit);

        double dlab = 4.0; /* Displacement from point on arc and label ref point. */
        epswr_set_pen(eps, 0,0,0, 0.50, 0,0);
        epswr_set_fill_color(eps, 0,0,0);
        epswr_set_label_font(eps, "Times-Italic", 20);
        hedge_draw_arc_label(eps, e,             etim, "e",        1.0,0.0, -0.8*dlab, +1.0*dlab);
        hedge_draw_arc_label(eps, e->twin,       etim, "e.twin",   0.0,1.0, -0.8*dlab, +0.8*dlab);
        hedge_draw_arc_label(eps, e->next,       etim, "e.lnext",  1.0,0.0,         0, -0.7*dlab);
        hedge_draw_arc_label(eps, eprev,         etim, "e.lprev",  1.0,1.0, +1.3*dlab, -0.7*dlab);
        hedge_draw_arc_label(eps, e->twin->next, etim, "e.oprev",  0.0,1.0, +0.2*dlab, -0.8*dlab);

        hedge_draw_vert_label(eps, e->org,             "e.org",    0.0,1.0, +0.5*dlab, -0.5*dlab);
        hedge_draw_vert_label(eps, e->twin->org,       "e.dst",    0.0,0.5, +1.5*dlab,         0);

        /* epswr_set_fill_color(eps, 0.800,0.800,0.800); */
        /*  hedge_draw_smudge(eps, &(e->left->ctr), -3.2*dlab,+2.3*dlab, -1.1*dlab,+1.9*dlab); */
        epswr_set_fill_color(eps, 0,0,0);
        hedge_draw_face_label(eps,  e->left,            "e.left",   0.5,0.5, -0.5*dlab, +0.4*dlab);
        
        /* epswr_set_fill_color(eps, 0.800,0.800,0.800); */
        /* hedge_draw_smudge(eps, &(e->twin->left->ctr), -2.7*dlab,+3.5*dlab, -2.0*dlab,+1.0*dlab); */      
        epswr_set_fill_color(eps, 0,0,0);
        hedge_draw_face_label(eps,  e->twin->left,      "e.right",  0.5,0.5, +0.4*dlab, -0.5*dlab);
      }
          
    epswr_end_figure(eps);
    if (debug) { fprintf(stderr, "  < exit %s...\n", __FUNCTION__); }
  }
  
hedge_t *toposlice_hedge_fig_create_mesh(void)
  {
    if (debug) { fprintf(stderr, "  > enter %s...\n", __FUNCTION__); }
    hedge_t *H = hedge_new(100, 100, 100);
    H->dunit = 1.0; 

    hedge_arc_t **a = H->A.e;
    hedge_vert_t **v = H->V.e; 
    hedge_face_t **f = H->F.e;
    
    /* Vertices: */
    bool_t vvis = FALSE;  /* Show out-of-frame vertices? */                        
    (void)hedge_add_vert(H, 280, 245, 0, TRUE); /* v00 */
    (void)hedge_add_vert(H, 215, 230, 0, TRUE); /* v01 */
    (void)hedge_add_vert(H, 220, 285, 0, TRUE); /* v02 */
    (void)hedge_add_vert(H, 180, 270, 0, TRUE); /* v03 */
    (void)hedge_add_vert(H, 175, 240, 0, TRUE); /* v04 */
    (void)hedge_add_vert(H, 160, 205, 0, vvis); /* v05 */
    (void)hedge_add_vert(H, 165, 180, 0, vvis); /* v06 */
    (void)hedge_add_vert(H, 175, 190, 0, vvis); /* v07 */
    (void)hedge_add_vert(H, 300, 175, 0, vvis); /* v08 */
    (void)hedge_add_vert(H, 320, 260, 0, vvis); /* v09 */
    (void)hedge_add_vert(H, 265, 320, 0, vvis); /* v10 */
    (void)hedge_add_vert(H, 215, 320, 0, vvis); /* v11 */
    (void)hedge_add_vert(H, 160, 300, 0, vvis); /* v12 */
    (void)hedge_add_vert(H, 145, 245, 0, vvis); /* v13 */
    (void)hedge_add_vert(H, 130, 195, 0, vvis); /* v14 */
    (void)hedge_add_vert(H, 175, 140, 0, vvis); /* v15 */
    (void)hedge_add_vert(H, 350, 155, 0, vvis); /* v16 */
    (void)hedge_add_vert(H, 237, 183, 0, vvis); /* v17 */
                                                  
    /* Edges: */
    (void)hedge_add_edge(H, v01, v00, 0); /* e00 */
    (void)hedge_add_edge(H, v01, v02, 0); /* e01 */
    (void)hedge_add_edge(H, v01, v04, 0); /* e02 */
    (void)hedge_add_edge(H, v01, v07, 0); /* e03 */
    (void)hedge_add_edge(H, v05, v04, 0); /* e04 */
    (void)hedge_add_edge(H, v06, v05, 0); /* e05 */
    (void)hedge_add_edge(H, v07, v06, 0); /* e06 */
    (void)hedge_add_edge(H, v17, v07, 0); /* e07 */ 
    (void)hedge_add_edge(H, v08, v00, 0); /* e08 */
    (void)hedge_add_edge(H, v00, v02, 0); /* e09 */
    (void)hedge_add_edge(H, v02, v03, 0); /* e10 */
    (void)hedge_add_edge(H, v04, v03, 0); /* e11 */
    (void)hedge_add_edge(H, v04, v13, 0); /* e12 */
    (void)hedge_add_edge(H, v05, v14, 0); /* e13 */
    (void)hedge_add_edge(H, v06, v15, 0); /* e14 */
    (void)hedge_add_edge(H, v08, v16, 0); /* e15 */
    (void)hedge_add_edge(H, v00, v09, 0); /* e16 */
    (void)hedge_add_edge(H, v00, v10, 0); /* e17 */
    (void)hedge_add_edge(H, v02, v10, 0); /* e18 */
    (void)hedge_add_edge(H, v02, v11, 0); /* e19 */
    (void)hedge_add_edge(H, v03, v12, 0); /* e20 */
    (void)hedge_add_edge(H, v12, v13, 0); /* e21 */
    (void)hedge_add_edge(H, v13, v14, 0); /* e22 */
    (void)hedge_add_edge(H, v14, v15, 0); /* e23 */
    (void)hedge_add_edge(H, v15, v16, 0); /* e24 */
    (void)hedge_add_edge(H, v16, v09, 0); /* e25 */
    (void)hedge_add_edge(H, v09, v10, 0); /* e26 */
    (void)hedge_add_edge(H, v10, v11, 0); /* e27 */
    (void)hedge_add_edge(H, v11, v12, 0); /* e28 */
    (void)hedge_add_edge(H, v08, v17, 0); /* e29 */
    
    /* Faces: */                                  
    bool_t fvis = vvis;  /* Don't paint faces that extend outsde the frame. */                      

    /* f00 */
    sex( e00,       e09        );
    sex( e09,       e01->twin  );
    sex( e01->twin, e00        );
    (void)hedge_add_face(H, 240, 240, 0, TRUE, e00); /* f00 */
    assert(H->nf-1 == f00->id);
    
    /* f01 */
    sex( e01,       e10        );
    sex( e10,       e11->twin  );
    sex( e11->twin, e02->twin  );
    sex( e02->twin, e01        );
    (void)hedge_add_face(H, 185, 255, 0, TRUE, e01); /* f01 */
    assert(H->nf-1 == f01->id);
    
    /* f02 */
    sex( e02,       e04->twin  );
    sex( e04->twin, e05->twin  );
    sex( e05->twin, e06->twin  );
    sex( e06->twin, e03->twin  );
    sex( e03->twin, e02        );
    (void)hedge_add_face(H, 170, 185, 0, fvis, e02); /* f02 */
    assert(H->nf-1 == f02->id);
 
    /* f03 */
    sex( e08,       e00->twin );
    sex( e00->twin, e03       );
    sex( e03,       e07->twin );
    sex( e07->twin, e29->twin ); /* Patched */
    sex( e29->twin, e08       ); /* Patched */
   (void)hedge_add_face(H, 240, 195, 0, fvis, e08); /* f03 */
    assert(H->nf-1 == f03->id);

    /* f04 */
    sex( e07,       e06       );
    sex( e06,       e14       );
    sex( e14,       e24       );
    sex( e24,       e15->twin );
    sex( e15->twin, e29       ); /* Patched */
    sex( e29,       e07       ); /* Patched */
    (void)hedge_add_face(H, 205, 115, 0, fvis, e07); /* f04 */
    assert(H->nf-1 == f04->id);

    /* f05 */
    sex( e15,       e25       );
    sex( e25,       e16->twin );
    sex( e16->twin, e08->twin );
    sex( e08->twin, e15       );
    (void)hedge_add_face(H, 330, 190, 0, fvis, e15); /* f05 */
    assert(H->nf-1 == f05->id);

    /* f06 */
    sex( e16,       e26       );
    sex( e26,       e17->twin );
    sex( e17->twin, e16       );
    (void)hedge_add_face(H, 350, 255, 0, fvis, e16); /* f06 */
    assert(H->nf-1 == f06->id);

    /* f07 */
    sex( e17,       e18->twin );
    sex( e18->twin, e09->twin );
    sex( e09->twin, e17       );
    (void)hedge_add_face(H, 280, 280, 0, fvis, e17); /* f07 */
    assert(H->nf-1 == f07->id);

    /* f08 */
    sex( e18,       e27       );
    sex( e27,       e19->twin );
    sex( e19->twin, e18       );
    (void)hedge_add_face(H, 255, 315, 0, fvis, e18); /* f08 */
    assert(H->nf-1 == f08->id);

    /* f09 */
    sex( e19,       e28       );
    sex( e28,       e20->twin );
    sex( e20->twin, e10->twin );
    sex( e10->twin, e19       );
    (void)hedge_add_face(H, 200, 315, 0, fvis, e19); /* f09 */
    assert(H->nf-1 == f09->id);
 
    /* f10 */
    sex( e11,       e20       );
    sex( e20,       e21       );
    sex( e21,       e12->twin );
    sex( e12->twin, e11       );
   (void)hedge_add_face(H, 130, 260, 0, fvis, e11); /* f10 */
    assert(H->nf-1 == f10->id);

    /* f11 */
    sex( e04,       e12       );
    sex( e12,       e22       );
    sex( e22,       e13->twin );
    sex( e13->twin, e04       );
    (void)hedge_add_face(H,  95, 190, 0, fvis, e04); /* f11 */
    assert(H->nf-1 == f11->id);

    /* f12 */
    sex( e05,       e13       );
    sex( e13,       e23       );
    sex( e23,       e14->twin );
    sex( e14->twin, e05       );
    (void)hedge_add_face(H, 120, 120, 0, fvis, e05); /* f12 */
    assert(H->nf-1 == f12->id);

    /* f13 */
    sex( e28->twin, e27->twin );
    sex( e27->twin, e26->twin );
    sex( e26->twin, e25->twin );
    sex( e25->twin, e24->twin );
    sex( e24->twin, e23->twin );
    sex( e23->twin, e22->twin );
    sex( e22->twin, e21->twin );
    sex( e21->twin, e28->twin );
    (void)hedge_add_face(H, 240,   5, 0, FALSE, e28->twin); /* f13 */
    assert(H->nf-1 == f13->id);

    hedge_check_topology(H);
    
    /* Recompute face centers: */
    for (uint32_t kf = 0;  kf < H->nf; kf++)
      { hedge_face_t *f = H->F.e[kf];
        r3_t ctr = (r3_t){{ 0,0,0 }};
        int32_t deg = 0;
        hedge_arc_t *e = f->side;
        do
          { hedge_vert_t *org = e->org;
            r3_add(&(org->pos), &ctr, &ctr);
            deg++;
            e = e->next;
          }
        while (e != f->side);
        demand(deg >= 3, "face degree must be 3 or more");
        r3_scale(1.0/deg, &ctr, &(f->ctr));
      }
    
    if (debug) { fprintf(stderr, "  < exit %s...\n", __FUNCTION__); }
    return H;
    
  }