/* Copyright (C) 2001-2007 Peter Selinger.
   This file is part of Potrace. It is free software and it is covered
   by the GNU General Public License. See the file COPYING for details. */

#include <stdlib.h>
#include <string.h>
#include <glib/gstrfuncs.h>

#include "potracelib.h"
#include "inkscape-version.h"
#include "curve.h"
#include "decompose.h"
#include "trace.h"
#include "progress.h"

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

/* default parameters */
static const potrace_param_t param_default = {
  2,                             /* turdsize */
  POTRACE_TURNPOLICY_MINORITY,   /* turnpolicy */
  1.0,                           /* alphamax */
  1,                             /* opticurve */
  0.2,                           /* opttolerance */
  {
    NULL,                        /* callback function */
    NULL,                        /* callback data */
    0.0, 1.0,                    /* progress range */
    0.0,                         /* granularity */
  },
};

/* Return a fresh copy of the set of default parameters, or NULL on
   failure with errno set. */
potrace_param_t *potrace_param_default(void) {
    potrace_param_t *p;

    p = (potrace_param_t *) malloc(sizeof(potrace_param_t));
    if (!p) {
        return NULL;
    }
    memcpy(p, &param_default, sizeof(potrace_param_t));
    return p;
}

/* On success, returns a Potrace state st with st->status ==
   POTRACE_STATUS_OK. On failure, returns NULL if no Potrace state
   could be created (with errno set), or returns an incomplete Potrace
   state (with st->status == POTRACE_STATUS_INCOMPLETE). Complete or
   incomplete Potrace state can be freed with potrace_state_free(). */
potrace_state_t *potrace_trace(const potrace_param_t *param, const potrace_bitmap_t *bm) {
    int r;
    path_t *plist = NULL;
    potrace_state_t *st;
    progress_t prog;
    progress_t subprog;

    /* prepare private progress bar state */
    prog.callback = param->progress.callback;
    prog.data = param->progress.data;
    prog.min = param->progress.min;
    prog.max = param->progress.max;
    prog.epsilon = param->progress.epsilon;
    prog.d_prev = param->progress.min;

    /* allocate state object */
    st = (potrace_state_t *)malloc(sizeof(potrace_state_t));
    if (!st) {
        return NULL;
    }

    progress_subrange_start(0.0, 0.1, &prog, &subprog);

    /* process the image */
    r = bm_to_pathlist(bm, &plist, param, &subprog);
    if (r) {
        free(st);
        return NULL;
    }

    st->status = POTRACE_STATUS_OK;
    st->plist = plist;
    st->priv = NULL;  /* private state currently unused */

    progress_subrange_end(&prog, &subprog);

    progress_subrange_start(0.1, 1.0, &prog, &subprog);

    /* partial success. */
    r = process_path(plist, param, &subprog);
    if (r) {
        st->status = POTRACE_STATUS_INCOMPLETE;
    }

    progress_subrange_end(&prog, &subprog);

    return st;
}

/* free a Potrace state, without disturbing errno. */
void potrace_state_free(potrace_state_t *st) {
    pathlist_free(st->plist);
    free(st);
}

/* free a parameter list, without disturbing errno. */
void potrace_param_free(potrace_param_t *p) {
    free(p);
}

char *potrace_version(void) {
    static char *ver = g_strdup_printf("potracelib %s", Inkscape::version_string);
    return ver;
}

/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
