spiro 0.0.1

data/ext/spiro/_spiro.h

@@ -0,0 +1,37 @@
+#ifndef _SPIRO_H
+#define _SPIRO_H
+
+typedef struct {
+/* User passes an array of SpiroCP in this format for Spiro to solve */
+    double x;		/* Spiro CodePoint Xloc */
+    double y;		/* Spiro CodePoint Yloc */
+    char ty;		/* Spiro CodePoint Type */
+} spiro_cp;
+
+struct spiro_seg_s {
+/* run_spiro() uses array of information given in the structure above and */
+/* creates an array in this structure format to use by spiro_to_bpath for */
+/* building bezier curves */
+    double x;		/* SpiroCP segment_chord startX */
+    double y;		/* SpiroCP segment_chord startY */
+    char ty;		/* Spiro CodePoint Type */
+    double bend_th;	/* bend theta between this vector and next vector */
+    double ks[4];
+    double seg_ch;	/* segment_chord distance from xy to next SpiroCP */
+    double seg_th;	/* segment_theta angle for this SpiroCP */
+    double l;
+};
+
+typedef struct spiro_seg_s spiro_seg;
+
+spiro_seg *
+run_spiro(const spiro_cp *src, int n);
+
+void
+free_spiro(spiro_seg *s);
+
+void
+spiro_to_bpath(const spiro_seg *s, int n, bezctx *bc);
+
+double get_knot_th(const spiro_seg *s, int i);
+#endif

data/ext/spiro/bezctx.c

@@ -0,0 +1,68 @@
+/*
+ppedit - A pattern plate editor for Spiro splines.
+Copyright (C) 2007 Raph Levien
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.
+
+*/
+//#include "spiro-config.h"
+#ifdef VERBOSE
+#include <stdio.h>
+#endif
+
+#include "bezctx.h"
+
+void bezctx_moveto(bezctx *bc, double x, double y, int is_open)
+{
+#ifdef VERBOSE
+    printf("moveto(%g,%g)_%d\n",x,y,is_open);
+#endif
+    bc->moveto(bc, x, y, is_open);
+}
+
+void bezctx_lineto(bezctx *bc, double x, double y)
+{
+#ifdef VERBOSE
+    printf("lineto(%g,%g)\n",x,y);
+#endif
+    bc->lineto(bc, x, y);
+}
+
+void bezctx_quadto(bezctx *bc, double x1, double y1, double x2, double y2)
+{
+#ifdef VERBOSE
+    printf("quadto(%g,%g, %g,%g)\n",x1,y1,x2,y2);
+#endif
+    bc->quadto(bc, x1, y1, x2, y2);
+}
+
+void bezctx_curveto(bezctx *bc, double x1, double y1, double x2, double y2,
+		    double x3, double y3)
+{
+#ifdef VERBOSE
+    printf("curveto(%g,%g, %g,%g, %g,%g)\n",x1,y1,x2,y2,x3,y3);
+#endif
+    bc->curveto(bc, x1, y1, x2, y2, x3, y3);
+}
+
+void bezctx_mark_knot(bezctx *bc, int knot_idx)
+{
+#ifdef VERBOSE
+    printf("mark_knot()_%d\n",knot_idx);
+#endif
+    if (bc->mark_knot)
+	bc->mark_knot(bc, knot_idx);
+}

data/ext/spiro/bezctx.h

@@ -0,0 +1,23 @@
+#ifndef _BEZCTX_H
+#define _BEZCTX_H
+#include "bezctx_intf.h"
+
+struct _bezctx {
+    /* Called by spiro to start a contour */
+    void (*moveto)(bezctx *bc, double x, double y, int is_open);
+
+    /* Called by spiro to move from the last point to the next one on a straight line */
+    void (*lineto)(bezctx *bc, double x, double y);
+
+    /* Called by spiro to move from the last point to the next along a quadratic bezier spline */
+    /* (x1,y1) is the quadratic bezier control point and (x2,y2) will be the new end point */
+    void (*quadto)(bezctx *bc, double x1, double y1, double x2, double y2);
+
+    /* Called by spiro to move from the last point to the next along a cubic bezier spline */
+    /* (x1,y1) and (x2,y2) are the two off-curve control point and (x3,y3) will be the new end point */
+    void (*curveto)(bezctx *bc, double x1, double y1, double x2, double y2,
+		    double x3, double y3);
+
+    void (*mark_knot)(bezctx *bc, int knot_idx);
+};
+#endif

data/ext/spiro/bezctx_intf.h

@@ -0,0 +1,23 @@
+#ifndef _BEZCTX_INTF_H
+#define _BEZCTX_INTF_H
+typedef struct _bezctx bezctx;
+
+bezctx *
+new_bezctx(void);
+
+void
+bezctx_moveto(bezctx *bc, double x, double y, int is_open);
+
+void
+bezctx_lineto(bezctx *bc, double x, double y);
+
+void
+bezctx_quadto(bezctx *bc, double x1, double y1, double x2, double y2);
+
+void
+bezctx_curveto(bezctx *bc, double x1, double y1, double x2, double y2,
+	       double x3, double y3);
+
+void
+bezctx_mark_knot(bezctx *bc, int knot_idx);
+#endif

data/ext/spiro/bezctx_rb.c

@@ -0,0 +1,91 @@
+#include <stdlib.h>
+#include "bezctx_rb.h"
+
+Splines splines;
+
+void initSplines(Splines *a, size_t initialSize) {
+  a->array = (node *)malloc(initialSize * sizeof(node));
+  a->used = 0;
+  a->size = initialSize;
+}
+
+void appendSplines(Splines *a, node element) {
+  if (a->used == a->size) {
+    a->size *= 2;
+    a->array = (node *)realloc(a->array, a->size * sizeof(node));
+  }
+  a->array[a->used++] = element;
+}
+
+void freeSplines(Splines *a) {
+  free(a->array);
+  a->array = NULL;
+  a->used = a->size = 0;
+}
+
+typedef struct {
+  bezctx base; // This is a superclass of bezctx, entry for the base
+  int is_open;
+} bezctx_rb;
+
+/* This routine starts a new contour */
+static void bezctx_rb_moveto(bezctx *z, double x, double y, int is_open) {
+  bezctx_rb *bc = (bezctx_rb *)z;
+
+  bc->is_open = is_open;
+
+  node n = { x, y, SPLINE_CORNER };
+  appendSplines(&splines, n);
+}
+
+/* This routine creates a linear spline from the previous point specified to this one */
+void bezctx_rb_lineto(bezctx *z, double x, double y) {
+  bezctx_rb *bc = (bezctx_rb *)z;
+
+  node n = { x, y, SPLINE_CORNER };
+  appendSplines(&splines, n);
+}
+
+/* This creates a qubic curve */
+void bezctx_rb_quadto(bezctx *z, double xm, double ym, double x3, double y3) {
+  bezctx_rb *bc = (bezctx_rb *)z;
+
+  node n1 = { xm, ym, SPLINE_QUADRATIC };
+  appendSplines(&splines, n1);
+
+  node n2 = { x3, y3, SPLINE_CORNER };
+  appendSplines(&splines, n2);
+}
+
+/* And this creates a cubic */
+void bezctx_rb_curveto(bezctx *z, double x1, double y1, double x2, double y2,
+    double x3, double y3) {
+  bezctx_rb *bc = (bezctx_rb *)z;
+
+  node n1 = { x1, y1, SPLINE_CUBIC };
+  appendSplines(&splines, n1);
+  node n2 = { x2, y2, SPLINE_CUBIC };
+  appendSplines(&splines, n2);
+  node n3 = { x3, y3, SPLINE_CORNER };
+  appendSplines(&splines, n3);
+}
+
+/* Allocates and initializes a new bezier context */
+bezctx * new_bezctx_rb(void) {
+  bezctx_rb *result = (bezctx_rb *)malloc(sizeof(bezctx_rb));
+  initSplines(&splines, 20);
+
+  result->base.moveto = bezctx_rb_moveto;
+  result->base.lineto = bezctx_rb_lineto;
+  result->base.quadto = bezctx_rb_quadto;
+  result->base.curveto = bezctx_rb_curveto;
+  result->base.mark_knot = NULL;
+  result->is_open = 0;
+  return &result->base;
+}
+
+/* Finishes an old bezier context */
+void bezctx_rb_close(bezctx *z) {
+  bezctx_rb *bc = (bezctx_rb *)z;
+  free(bc);
+}

data/ext/spiro/bezctx_rb.h

@@ -0,0 +1,32 @@
+#include "spiroentrypoints.h"
+#include "bezctx.h"
+
+// Possible values of the "ty" field.
+#define SPLINE_CORNER	1
+#define SPLINE_CUBIC 3
+#define SPLINE_QUADRATIC 4
+
+typedef struct {
+  double x;
+  double y;
+  int ty;
+} node;
+
+typedef struct Splines {
+  node *array;
+  size_t used;
+  size_t size;
+} Splines;
+
+extern Splines splines;
+
+
+bezctx *new_bezctx_rb(void);
+
+//struct splineset;
+//struct Splines;
+
+void freeSplines(Splines *a);
+
+//struct splineset *bezctx_rb_close(bezctx *bc);
+void bezctx_rb_close(bezctx *z);

data/ext/spiro/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+#CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+#dir_config('spiro')
+create_makefile('spiro/spiro')

data/ext/spiro/spiro.c

@@ -0,0 +1,121 @@
+#include <ruby.h>
+#include "spiroentrypoints.h"	// call spiro through here
+#include "bezctx_rb.h"		// bezctx structure
+#include "_spiro.h"
+
+static ID id_corner;
+static ID id_g4;
+static ID id_g2;
+static ID id_left;
+static ID id_right;
+
+static inline char sym_to_spiro_type(VALUE sym) {
+  ID inp = rb_to_id(sym);
+
+  if (inp == id_corner) {
+    return SPIRO_CORNER;
+  } else if (inp == id_g2) {
+    return SPIRO_G2;
+  } else if (inp == id_g4) {
+    return SPIRO_G4;
+  } else if (inp == id_left) {
+    return SPIRO_LEFT;
+  } else if (inp == id_right) {
+    return SPIRO_RIGHT;
+  }
+
+  rb_raise(rb_eArgError, "%s", "Expected :g2, :g4, :node, :left or :right");
+}
+
+static inline VALUE spline_type_to_sym(int ty) {
+  if (ty == SPLINE_CORNER) {
+    return ID2SYM(rb_intern("node"));
+  } else if (ty == SPLINE_CUBIC) {
+    return ID2SYM(rb_intern("cubic"));
+  } else if (ty == SPLINE_QUADRATIC) {
+    return ID2SYM(rb_intern("quadratic"));
+  }
+}
+
+static inline int bool_to_int(VALUE b) {
+  switch (TYPE(b)) {
+    case T_TRUE:
+      return 1;
+      break;
+    case T_FALSE:
+      return 0;
+      break;
+    default:
+      rb_raise(rb_eTypeError, "not a boolean");
+      break;
+  }
+}
+
+static VALUE spiros_to_splines(VALUE mod, VALUE spirosValue, VALUE closedValue) {
+  Check_Type(spirosValue, T_ARRAY);
+
+  // Take Ruby array of points and turn into Spiro C struct array
+  spiro_cp spiros[RARRAY_LEN(spirosValue)];
+  for (int i = 0; i != RARRAY_LEN(spirosValue); i++) {
+    VALUE nodeValue = rb_ary_entry(spirosValue, i);
+    // Validate node is an array and length 3 (x, y, type)
+    Check_Type(nodeValue, T_ARRAY);
+    if (RARRAY_LEN(nodeValue) != 3) rb_raise(rb_eArgError, "%s", "Invalid node");
+
+    // Validate individual node elements
+    VALUE xValue = rb_ary_entry(nodeValue, 0);
+    if (TYPE(xValue) != T_FIXNUM && TYPE(xValue) != T_FLOAT) {
+      rb_raise(rb_eTypeError, "x coord must be float or fixnum");
+    }
+    VALUE yValue = rb_ary_entry(nodeValue, 1);
+    if (TYPE(yValue) != T_FIXNUM && TYPE(yValue) != T_FLOAT) {
+      rb_raise(rb_eTypeError, "y coord must be float or fixnum");
+    }
+    VALUE typeValue = rb_ary_entry(nodeValue, 2);
+    Check_Type(typeValue, T_SYMBOL);
+
+    spiros[i].x  = (long)(NUM2DBL(xValue));
+    spiros[i].y  = (long)(NUM2DBL(yValue));
+    spiros[i].ty = sym_to_spiro_type(typeValue);
+  }
+
+  int closed = bool_to_int(closedValue);
+
+  // bezctx_rb is custom, stores the result of running Spiro
+  bezctx *bc = new_bezctx_rb();
+  // Run Spiro on the Spiros array and populate custom struct with splines array
+  int success = SpiroCPsToBezier0(spiros, RARRAY_LEN(spirosValue), closed, bc);
+
+  if (success) {
+    // Build Ruby array from Spiro array
+    VALUE splinesValue = rb_ary_new();
+    // Free memory from the custom struct
+    bezctx_rb_close(bc);
+    for (int i = 0; i < splines.used; i++) {
+      VALUE x = rb_float_new(splines.array[i].x);
+      VALUE y = rb_float_new(splines.array[i].y);
+      VALUE ty = spline_type_to_sym(splines.array[i].ty);
+      VALUE nodeValue = rb_ary_new3(3, x, y, ty);
+      rb_ary_push(splinesValue, nodeValue);
+    }
+    freeSplines(&splines);
+
+    return splinesValue;
+  }
+  else {
+    bezctx_rb_close(bc);
+    freeSplines(&splines);
+    return Qnil;
+  }
+}
+
+void Init_spiro(void) {
+  id_corner = rb_intern("node");
+  id_g4 = rb_intern("g4");
+  id_g2 = rb_intern("g2");
+  id_left = rb_intern("left");
+  id_right = rb_intern("right");
+
+  VALUE mSpiro = rb_define_module("Spiro");
+  rb_define_singleton_method(mSpiro, "spiros_to_splines", spiros_to_splines, 2);
+}

data/ext/spiro/spiroentrypoints.c

@@ -0,0 +1,83 @@
+/*
+libspiro - conversion between spiro control points and bezier's
+Copyright (C) 2007 Raph Levien
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.
+
+*/
+/* Interface routines to Raph's spiro package. */
+
+#include "spiroentrypoints.h"
+
+/* These two functions are kept for backwards compatibility */
+void SpiroCPsToBezier(spiro_cp *spiros,int n,int isclosed,bezctx *bc) {
+    SpiroCPsToBezier0(spiros,n,isclosed,bc);
+}
+void TaggedSpiroCPsToBezier(spiro_cp *spiros,bezctx *bc) {
+    TaggedSpiroCPsToBezier0(spiros,bc);
+}
+
+int
+SpiroCPsToBezier0(spiro_cp *spiros,int n,int isclosed,bezctx *bc)
+{
+    spiro_seg *s;
+
+    if ( n<=0 )
+	return 0;
+    if ( isclosed )
+	s = run_spiro(spiros,n);
+    else {
+	char oldty_start = spiros[0].ty;
+	char oldty_end   = spiros[n-1].ty;
+	spiros[0].ty = '{';
+	spiros[n-1].ty = '}';
+	s = run_spiro(spiros,n);
+	spiros[n-1].ty = oldty_end;
+	spiros[0].ty = oldty_start;
+    }
+    if (s) {
+	spiro_to_bpath(s,n,bc);
+	free_spiro(s);
+	return 1; /* success */
+    }
+    return 0 ; /* spiro did not converge or encountered non-finite values */
+}
+
+int
+TaggedSpiroCPsToBezier0(spiro_cp *spiros,bezctx *bc)
+{
+    spiro_seg *s;
+    int n;
+
+    for ( n=0; spiros[n].ty!='z' && spiros[n].ty!='}'; ++n );
+    if ( spiros[n].ty == '}' ) ++n;
+
+    if ( n<=0 ) return 0; /* invalid input */
+    s = run_spiro(spiros,n);
+    if (s) {
+	spiro_to_bpath(s,n,bc);
+	free_spiro(s);
+	return 1; /* success */
+    }
+    return 0 ; /* spiro did not converge or encountered non-finite values */
+}
+
+void SpiroCPsToBezier1(spiro_cp *spiros,int n,int isclosed,bezctx *bc,int *done) {
+    *done = SpiroCPsToBezier0(spiros,n,isclosed,bc);
+}
+void TaggedSpiroCPsToBezier1(spiro_cp *spiros,bezctx *bc,int *done) {
+    *done = TaggedSpiroCPsToBezier0(spiros,bc);
+}