Merge pull request #2 from saurabhb17/develop

Remaining files transfered

1 files changed, 129 insertions, 0 deletions

diff --git a/potrace/potracelib.cpp b/potrace/potracelib.cpp
new file mode 100644
index 0000000..26c1aa7
--- /dev/null
+++ b/potrace/potracelib.cpp
@@ -0,0 +1,129 @@
+/* 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 <potracelib.h>
+#include <curve.h>
+#include <decompose.h>
+#include <trace.h>
+#include <progress.h>
+#include <potrace_version.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 );
+}
+
+
+const char* potrace_version( void )
+{
+    return POTRACELIB_VERSION;
+}