view release on metacpan or  search on metacpan

Aesthetic.xs  view on Meta::CPAN

void
_private_data(aglo_force force, SV *new_private_data=0)
  PPCODE:
    if (GIMME_V != G_VOID)
        XPUSHs(force->private_data ? force->private_data : &PL_sv_undef);
    if (new_private_data) {
        if (force->private_data) sv_2mortal(force->private_data);
        force->private_data = newSVsv(new_private_data);
    }

void
DESTROY(aglo_force force)
  PPCODE:
    if (force->private_data) sv_2mortal(force->private_data);
    if (force->user_data)    sv_2mortal(force->user_data);
    Safefree(force);

MODULE = Graph::Layout::Aesthetic		PACKAGE = Graph::Layout::Aesthetic

SV *
new_state(char *class, SV *topology, aglo_signed nr_dimensions=2)
  PREINIT:
    aglo_graph  gr;
    aglo_state  state;
    aglo_real  *here;
    aglo_vertex i;
  CODE:
    /* This replaces topology by what it references */
    gr = C_OBJECT(topology, "Graph::Layout::Aesthetic::Topology", "topology");
    if (!gr->done) croak("Topology hasn't been finished");
    if (nr_dimensions < 0) croak("Nr_dimensions must not be negative");

    Newc(__LINE__, state, sizeof(struct aglo_state)+
                   (gr->vertices-1)*sizeof(aglo_point),
         char, struct aglo_state);
    New(__LINE__, here, (3*gr->vertices+1) * nr_dimensions, aglo_real);
    for (i=0; i<gr->vertices; i++) {
        state->point[i] = here;
        here += nr_dimensions;
    }

    state->centroid_sequence = 0;
    state->cached_centroid = here;
    here += nr_dimensions;

    state->gradient = here;
    here += nr_dimensions * gr->vertices;
    state->force_gradient = here;
    here += nr_dimensions * gr->vertices;

    state->forces = 0;
    state->dimensions = nr_dimensions;
    state->graph = gr;
    state->graph_sv = newRV(topology);
    /* so it's out of sequence with things that are 0 */
    state->sequence = 1;

    state->temperature = 1e2;
    state->end_temperature = 1e-3;
    state->iterations = 1000;

    state->paused = 0;

    RETVAL = NEWSV(1, 0);
    sv_setref_pv(RETVAL, class, (void*) state);
  OUTPUT:
    RETVAL

void
paused(aglo_state state, aglo_boolean new_paused=0)
  PPCODE:
    if (GIMME_V != G_VOID) XPUSHs(state->paused ? &PL_sv_yes : &PL_sv_no);
    if (items > 1) state->paused = new_paused;

aglo_unsigned
nr_dimensions(aglo_state state)
  CODE:
    RETVAL = state->dimensions;
  OUTPUT:
    RETVAL

aglo_real
temperature(aglo_state state, aglo_real temperature=0, aglo_boolean warner=1)
  CODE:
    RETVAL = state->temperature;
    if (items > 1) {
        if (temperature <= 0)
            croak("Temperature %"NVff" should be > 0", (NV) temperature);
        if (warner && temperature < state->end_temperature)
            warn("Temperature %"NVff" should probably be >= end_temperature %"NVff,
                 (NV) temperature, (NV) state->end_temperature);
        state->temperature = temperature;
    }
  OUTPUT:
    RETVAL

aglo_real
end_temperature(aglo_state state, aglo_real end_temperature=0, aglo_boolean warner=1)
  CODE:
    RETVAL = state->end_temperature;
    if (items > 1) {
        if (end_temperature <= 0)
            croak("End_temperature %"NVff" should be > 0", (NV) end_temperature);
        if (warner && state->temperature < end_temperature)
            warn("Temperature %"NVff" should probably be >= end_temperature %"NVff,
                 (NV) state->temperature, (NV) end_temperature);
        state->end_temperature = end_temperature;
    }
  OUTPUT:
    RETVAL

void
coordinates(aglo_state state, aglo_vertex vertex, ...)
  PREINIT:
    aglo_unsigned i, d;
    aglo_point v;
  PPCODE:
    if (vertex >= state->graph->vertices)
        croak("Vertex number %"UVuf" is invalid, there are only %"UVuf" in the topology",
              (UV) vertex, (UV) state->graph->vertices);

Aesthetic.xs  view on Meta::CPAN

    aglo_state st;
    aglo_force fo;
    use_force  use;
    void *private;
  PPCODE:
    /* This replaces force by what it references */
    fo = C_OBJECT(force, "Graph::Layout::Aesthetic::Force", "force");
    /* This replaces state by what it references */
    st = C_OBJECT(state, "Graph::Layout::Aesthetic", "state");

    sv_2mortal(SvREFCNT_inc(force));
    # Make sure we do this test before allocating anything (permanently)
    private = fo->aesth_setup(aTHX_ force, state, st);

    New(__LINE__, use, 1, struct use_force);

    use->weight = weight;
    use->force = fo;
    use->force_sv = newRV(force);
    use->private = private;
    use->next = st->forces;

    st->forces = use;

void
forces(aglo_state state)
  PREINIT:
    use_force force;
  PPCODE:
    switch(GIMME_V) {
        AV *rav;
      case G_ARRAY:
        for (force = state->forces; force; force = force->next) {
            AV *av = newAV();
            XPUSHs(sv_2mortal(newRV_noinc((SV *) av)));
            av_extend(av, 2-1);
            SvREFCNT_inc(force->force_sv);
            av_push(av, force->force_sv);
            av_push(av, newSVnv(force->weight));
        }
        break;
      case G_SCALAR:
        rav = newAV();
	XPUSHs(sv_2mortal(newRV_noinc((SV *) rav)));
        for (force = state->forces; force; force = force->next) {
            AV *av = newAV();
            av_push(rav, newRV_noinc((SV *) av));

            av_extend(av, 2-1);
            SvREFCNT_inc(force->force_sv);
            av_push(av, force->force_sv);
            av_push(av, newSVnv(force->weight));
        }
        break;
      default:
        break;
    }


void
init_gloss(aglo_state state, aglo_real temperature, aglo_real end_temperature, aglo_signed iterations, aglo_real randomize_size=1)
  PPCODE:
    if (temperature <= 0)
        croak("Temperature %"NVff" should be > 0", (NV) temperature);
    if (end_temperature <= 0)
        croak("End_temperature %"NVff" should be > 0", (NV) end_temperature);
    if (temperature < end_temperature)
        warn("Temperature %"NVff" should probably be >= end_temperature %"NVff,
              (NV) temperature, (NV) end_temperature);
    if (iterations < 0)
        croak("Iterations %"IVdf" should be >= 0", (IV) iterations);
    state->temperature = temperature;
    state->end_temperature = end_temperature;
    state->iterations = iterations;
    if (randomize_size > 0) aglo_randomize(aTHX_ state, randomize_size);

void
_gloss(aglo_state state, aglo_real pause_time=1e50)
  PREINIT:
    time_t now;
    aglo_real lambda;
  PPCODE:
    if (state->iterations <= 0) croak("No more iterations left");
    lambda = pow(state->temperature / state->end_temperature, 1.0 / state->iterations);
    state->paused = 0;
    while (state->iterations > 0 && !state->paused) {
        aglo_step(aTHX_ state, state->temperature,
                  state->temperature < 1e-5 ? state->temperature : 1e-5);

        state->temperature /= lambda;
        state->iterations--;

        if (items > 1) {
            time(&now);
            if (pause_time <= now) break;
        }
    }
    /* We lose the value anyways on exception in gradient,
       but restore is just a nicity, not part of the API */

void
step(aglo_state state, aglo_real temperature = state->temperature, aglo_real jitter_size = 1e-5)
  PPCODE:
    if (items < 3 && temperature < jitter_size) jitter_size = temperature;
    aglo_step(aTHX_ state, temperature, jitter_size);

void gradient(aglo_state state)
  PREINIT:
    aglo_unsigned i, d;
    aglo_vertex p, v;
    aglo_gradient gradient;
  PPCODE:
    calculate_aesth_forces(aTHX_ state);

    gradient = state->gradient;
    d = state->dimensions;
    v = state->graph->vertices;
    switch(GIMME_V) {
        AV *rav, *av;
      case G_ARRAY:
        EXTEND(SP, v);
        for (p=0; p<v; p++) {
            av = newAV();
            av_extend(av, d-1);
            PUSHs(sv_2mortal(newRV_noinc((SV *) av)));
            for (i=0; i<d; i++, gradient++) av_push(av, newSVnv(*gradient));
        }
        break;
      case G_SCALAR:
        rav = newAV();
	XPUSHs(sv_2mortal(newRV_noinc((SV *) rav)));

	av_extend(rav, v-1);
        for (p=0; p<v; p++) {
            av = newAV();
            av_extend(av, d-1);
            av_push(rav, newRV_noinc((SV *) av));
            for (i=0; i<d; i++, gradient++) av_push(av, newSVnv(*gradient));
        }
        break;
      default:
        break;
    }

aglo_real
stress(aglo_state state)
  CODE:
    calculate_aesth_forces(aTHX_ state);
    RETVAL = aglo_point_mag(state->dimensions*state->graph->vertices, state->gradient);
  OUTPUT:
    RETVAL

aglo_unsigned
iterations(aglo_state state, aglo_signed iterations=0)
  CODE:
    RETVAL = state->iterations;
    if (items > 1) {
        if (iterations < 0)
            croak("Iterations %"IVdf" should be >= 0", (IV) iterations);
        state->iterations = iterations;
    }
  OUTPUT:
    RETVAL

SV *
topology(aglo_state state)
  CODE:
    SvREFCNT_inc(state->graph_sv);
    RETVAL = state->graph_sv;
  OUTPUT:
    RETVAL

void
DESTROY(SV *state)
  PREINIT:
    use_force here;
    aglo_state st;
    aglo_boolean warned;
  PPCODE:
    /* This replaces state by what it references */
    st = C_OBJECT(state, "Graph::Layout::Aesthetic", "state");

    warned = 0;
    ENTER;
    EXTEND(SP, 1);
    while (st->forces) {
        I32 count;
        here = st->forces;
        SAVETMPS;

        PUSHMARK(SP);
        PUSHs(sv_2mortal(newRV(state)));
        PUTBACK ;

        /* This is an infinite loop if clear_forces makes no progress.
           So be it, it will indicate a bug anyways, and it's better than
           leaking memory */
        count = call_method("clear_forces", G_EVAL|G_KEEPERR|G_VOID);
        SPAGAIN;
        if (count) {
            if (count < 0) croak("Forced void context call 'clear_forces' succeeded in returning %d values. This is impossible", (int) count);
            SP -= count;
        }
        FREETMPS;
        if (here == st->forces && !warned) {
            warned = 1;
            warn("clear_forces is making no progress during DESTROY");
        }
    }
    LEAVE;
    sv_2mortal(st->graph_sv);
    Safefree(st->point[0]);
    Safefree(st);

void
clear_forces(aglo_state state)
  PREINIT:
    use_force here;
    aglo_aesth_cleanup_fx *cleanup;
    void *private;