/*
libspiro - conversion between spiro control points and bezier's
CopySpiroPointType.RIGHT (C) 2007 Raph Levien
2009 converted to Java by George Williams
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 2
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.
*/
package net.sourceforge.libspiro;
import java.lang.Math;
import java.util.ArrayList;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.IOException;
import static net.sourceforge.libspiro.SpiroPointType.*;
public class Spiro {
// Spiro has no constructors. It simply provides (static) methods to convert
// between a spiro contour (an array of SpiroCP) and a cubic Bezier contour
// and routines for reading/writing plate files
static protected class spiro_seg {
double x;
double y;
SpiroPointType type;
double bend_th;
double [/*4*/] ks;
double seg_ch;
double seg_th;
double l;
}
static protected class bandmat {
double [/*11*/] a; /* band-diagonal matrix */
double [/*5 */] al; /* lower part of band-diagonal decomposition */
void copyfrom(final bandmat from) {
System.arraycopy(a ,0,from.a ,0,11);
System.arraycopy(al,0,from.al,0,5 );
}
static void arraycopy(bandmat [] from, int fromi, bandmat [] to, int toi, int nelem ) {
int i;
for ( i=0; i<nelem; ++i )
to[i+toi].copyfrom( from[i+fromi] );
}
}
static final int N = 4;
/* ORDER = 12; */
/* Integrate polynomial spiral curve over range -.5 .. .5. */
static protected void
integrate_spiro(final double [/*4*/] ks, double [/*2*/] xy) {
double th1 = ks[0];
double th2 = .5 * ks[1];
double th3 = (1./6) * ks[2];
double th4 = (1./24) * ks[3];
double x, y;
double ds = 1. / N;
double ds2 = ds * ds;
double ds3 = ds2 * ds;
double k0 = ks[0] * ds;
double k1 = ks[1] * ds;
double k2 = ks[2] * ds;
double k3 = ks[3] * ds;
int i;
double s = .5 * ds - .5;
x = 0;
y = 0;
for (i = 0; i < N; i++) {
double u, v;
double km0, km1, km2, km3;
km0 = (((1./6) * k3 * s + .5 * k2) * s + k1) * s + k0;
km1 = ((.5 * k3 * s + k2) * s + k1) * ds;
km2 = (k3 * s + k2) * ds2;
km3 = k3 * ds3;
{
double t1_1 = km0;
double t1_2 = .5 * km1;
double t1_3 = (1./6) * km2;
double t1_4 = (1./24) * km3;
double t2_2 = t1_1 * t1_1;
double t2_3 = 2 * (t1_1 * t1_2);
double t2_4 = 2 * (t1_1 * t1_3) + t1_2 * t1_2;
double t2_5 = 2 * (t1_1 * t1_4 + t1_2 * t1_3);
double t2_6 = 2 * (t1_2 * t1_4) + t1_3 * t1_3;
double t2_7 = 2 * (t1_3 * t1_4);
double t2_8 = t1_4 * t1_4;
double t3_4 = t2_2 * t1_2 + t2_3 * t1_1;
double t3_6 = t2_2 * t1_4 + t2_3 * t1_3 + t2_4 * t1_2 + t2_5 * t1_1;
double t3_8 = t2_4 * t1_4 + t2_5 * t1_3 + t2_6 * t1_2 + t2_7 * t1_1;
double t3_10 = t2_6 * t1_4 + t2_7 * t1_3 + t2_8 * t1_2;
double t4_4 = t2_2 * t2_2;
double t4_5 = 2 * (t2_2 * t2_3);
double t4_6 = 2 * (t2_2 * t2_4) + t2_3 * t2_3;
double t4_7 = 2 * (t2_2 * t2_5 + t2_3 * t2_4);
double t4_8 = 2 * (t2_2 * t2_6 + t2_3 * t2_5) + t2_4 * t2_4;
double t4_9 = 2 * (t2_2 * t2_7 + t2_3 * t2_6 + t2_4 * t2_5);
double t4_10 = 2 * (t2_2 * t2_8 + t2_3 * t2_7 + t2_4 * t2_6) + t2_5 * t2_5;
double t5_6 = t4_4 * t1_2 + t4_5 * t1_1;
double t5_8 = t4_4 * t1_4 + t4_5 * t1_3 + t4_6 * t1_2 + t4_7 * t1_1;
double t5_10 = t4_6 * t1_4 + t4_7 * t1_3 + t4_8 * t1_2 + t4_9 * t1_1;
double t6_6 = t4_4 * t2_2;
double t6_7 = t4_4 * t2_3 + t4_5 * t2_2;
double t6_8 = t4_4 * t2_4 + t4_5 * t2_3 + t4_6 * t2_2;
double t6_9 = t4_4 * t2_5 + t4_5 * t2_4 + t4_6 * t2_3 + t4_7 * t2_2;
double t6_10 = t4_4 * t2_6 + t4_5 * t2_5 + t4_6 * t2_4 + t4_7 * t2_3 + t4_8 * t2_2;
double t7_8 = t6_6 * t1_2 + t6_7 * t1_1;
double t7_10 = t6_6 * t1_4 + t6_7 * t1_3 + t6_8 * t1_2 + t6_9 * t1_1;
double t8_8 = t6_6 * t2_2;
double t8_9 = t6_6 * t2_3 + t6_7 * t2_2;
double t8_10 = t6_6 * t2_4 + t6_7 * t2_3 + t6_8 * t2_2;
double t9_10 = t8_8 * t1_2 + t8_9 * t1_1;
double t10_10 = t8_8 * t2_2;
u = 1;
v = 0;
v += (1./12) * t1_2 + (1./80) * t1_4;
u -= (1./24) * t2_2 + (1./160) * t2_4 + (1./896) * t2_6 + (1./4608) * t2_8;
v -= (1./480) * t3_4 + (1./2688) * t3_6 + (1./13824) * t3_8 + (1./67584) * t3_10;
u += (1./1920) * t4_4 + (1./10752) * t4_6 + (1./55296) * t4_8 + (1./270336) * t4_10;
v += (1./53760) * t5_6 + (1./276480) * t5_8 + (1./1.35168e+06) * t5_10;
u -= (1./322560) * t6_6 + (1./1.65888e+06) * t6_8 + (1./8.11008e+06) * t6_10;
v -= (1./1.16122e+07) * t7_8 + (1./5.67706e+07) * t7_10;
u += (1./9.28973e+07) * t8_8 + (1./4.54164e+08) * t8_10;
v += (1./4.08748e+09) * t9_10;
u -= (1./4.08748e+10) * t10_10;
}
{
double th = (((th4 * s + th3) * s + th2) * s + th1) * s;
double cth = Math.cos(th);
double sth = Math.sin(th);
x += cth * u - sth * v;
y += cth * v + sth * u;
s += ds;
}
}
xy[0] = x * ds;
xy[1] = y * ds;
}
static protected double
compute_ends(final double [/*4*/] ks, double [/*2*/][/*4*/] ends, double seg_ch) {
double [/*2*/] xy = new double[2];
double ch, th;
double l, l2, l3;
double th_even, th_odd;
double k0_even, k0_odd;
double k1_even, k1_odd;
double k2_even, k2_odd;
integrate_spiro(ks, xy);
ch = Math.hypot(xy[0], xy[1]);
th = Math.atan2(xy[1], xy[0]);
l = ch / seg_ch;
th_even = .5 * ks[0] + (1./48) * ks[2];
th_odd = .125 * ks[1] + (1./384) * ks[3] - th;
ends[0][0] = th_even - th_odd;
ends[1][0] = th_even + th_odd;
k0_even = l * (ks[0] + .125 * ks[2]);
k0_odd = l * (.5 * ks[1] + (1./48) * ks[3]);
ends[0][1] = k0_even - k0_odd;
ends[1][1] = k0_even + k0_odd;
l2 = l * l;
k1_even = l2 * (ks[1] + .125 * ks[3]);
k1_odd = l2 * .5 * ks[2];
ends[0][2] = k1_even - k1_odd;
ends[1][2] = k1_even + k1_odd;
l3 = l2 * l;
k2_even = l3 * ks[2];
k2_odd = l3 * .5 * ks[3];
ends[0][3] = k2_even - k2_odd;
ends[1][3] = k2_even + k2_odd;
return l;
}
static protected void
compute_pderivs(final spiro_seg s, double [/*2*/][/*4*/] ends,
double [/*4*/][/*2*/][/*4*/] derivs, int jinc) {
double recip_d = 2e6;
double delta = 1./ recip_d;
double [] try_ks = new double[4];
double [][] try_ends = new double [2][4];
int i, j, k;
compute_ends(s.ks, ends, s.seg_ch);
for (i = 0; i < jinc; i++) {
for (j = 0; j < 4; j++)
try_ks[j] = s.ks[j];
try_ks[i] += delta;
compute_ends(try_ks, try_ends, s.seg_ch);
for (k = 0; k < 2; k++)
for (j = 0; j < 4; j++)
derivs[j][k][i] = recip_d * (try_ends[k][j] - ends[k][j]);
}
}
static protected double
mod_2pi(double th) {
double u = th / (2 * Math.PI);
return 2 * Math.PI * (u - Math.floor(u + 0.5));
}
static protected spiro_seg []
setup_path(final SpiroCP [] src, int n) {
int n_seg = src[0].type == OPEN ? n - 1 : n;
spiro_seg [] r = new spiro_seg[n_seg +1];
int i;
int ilast;
for (i = 0; i < n_seg; i++) {
r[i] = new spiro_seg();
r[i].x = src[i].x;
r[i].y = src[i].y;
r[i].type = src[i].type;
r[i].ks = new double[] { 0., 0., 0., 0. };
}
r[n_seg] = new spiro_seg();
r[n_seg].x = src[n_seg % n].x;
r[n_seg].y = src[n_seg % n].y;
r[n_seg].type = src[n_seg % n].type;
for (i = 0; i < n_seg; i++) {
double dx = r[i + 1].x - r[i].x;
double dy = r[i + 1].y - r[i].y;
r[i].seg_ch = Math.hypot(dx, dy);
r[i].seg_th = Math.atan2(dy, dx);
}
ilast = n_seg - 1;
for (i = 0; i < n_seg; i++) {
if (r[i].type == OPEN || r[i].type == OPEN_END || r[i].type == CORNER)
r[i].bend_th = 0.;
else
r[i].bend_th = mod_2pi(r[i].seg_th - r[ilast].seg_th);
ilast = i;
}
return r;
}
static protected void
bandec11(bandmat [] m, int [] perm, int n) {
int i, j, k;
int l;
/* pack top triangle to the LEFT. */
for (i = 0; i < 5; i++) {
for (j = 0; j < i + 6; j++)
m[i].a[j] = m[i].a[j + 5 - i];
for (; j < 11; j++)
m[i].a[j] = 0.;
}
l = 5;
for (k = 0; k < n; k++) {
int pivot = k;
double pivot_val = m[k].a[0];
double pivot_scale;
l = l < n ? l + 1 : n;
for (j = k + 1; j < l; j++)
if (Math.abs(m[j].a[0]) > Math.abs(pivot_val)) {
pivot_val = m[j].a[0];
pivot = j;
}
perm[k] = pivot;
if (pivot != k) {
for (j = 0; j < 11; j++) {
double tmp = m[k].a[j];
m[k].a[j] = m[pivot].a[j];
m[pivot].a[j] = tmp;
}
}
if (Math.abs(pivot_val) < 1e-12) pivot_val = 1e-12;
pivot_scale = 1. / pivot_val;
for (i = k + 1; i < l; i++) {
double x = m[i].a[0] * pivot_scale;
m[k].al[i - k - 1] = x;
for (j = 1; j < 11; j++)
m[i].a[j - 1] = m[i].a[j] - x * m[k].a[j];
m[i].a[10] = 0.;
}
}
}
static protected void
banbks11(final bandmat [] m, final int [] perm, double [] v, int n) {
int i, k, l;
/* forward substitution */
l = 5;
for (k = 0; k < n; k++) {
i = perm[k];
if (i != k) {
double tmp = v[k];
v[k] = v[i];
v[i] = tmp;
}
if (l < n) l++;
for (i = k + 1; i < l; i++)
v[i] -= m[k].al[i - k - 1] * v[k];
}
/* back substitution */
l = 1;
for (i = n - 1; i >= 0; i--) {
double x = v[i];
for (k = 1; k < l; k++)
x -= m[i].a[k] * v[k + i];
v[i] = x / m[i].a[0];
if (l < 11) l++;
}
}
static protected int
compute_jinc(SpiroPointType ty0, SpiroPointType ty1) {
if (ty0 == G4 || ty1 == G4 ||
ty0 == RIGHT || ty1 == LEFT)
return 4;
else if (ty0 == G2 && ty1 == G2)
return 2;
else if (((ty0 == OPEN || ty0 == CORNER || ty0 == LEFT) && ty1 == G2) ||
(ty0 == G2 && (ty1 == OPEN_END || ty1 == CORNER || ty1 == RIGHT)))
return 1;
else
return 0;
}
static protected int
count_vec(final spiro_seg [] s, int nseg) {
int i;
int n = 0;
for (i = 0; i < nseg; i++)
n += compute_jinc(s[i].type, s[i + 1].type);
return n;
}
static protected void
add_mat_line(bandmat [] m, double [] v,
double [/*4*/] derivs, double x, double y, int j, int jj, int jinc,
int nmat) {
int k;
if (jj >= 0) {
int joff = (j + 5 - jj + nmat) % nmat;
if (nmat < 6) {
joff = j + 5 - jj;
} else if (nmat == 6) {
joff = 2 + (j + 3 - jj + nmat) % nmat;
}
v[jj] += x;
for (k = 0; k < jinc; k++)
m[jj].a[joff + k] += y * derivs[k];
}
}
static protected double
spiro_iter(spiro_seg [] s, bandmat [] m, int [] perm, double [] v, int n) {
boolean cyclic = s[0].type != OPEN && s[0].type != CORNER;
int i, j, jj;
int nmat = count_vec(s, n);
double norm;
int n_invert;
for (i = 0; i < nmat; i++) {
v[i] = 0.;
m[i] = new bandmat();
m[i].a = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
m[i].al = new double[] { 0, 0, 0, 0, 0 };
}
j = 0;
if (s[0].type == G4)
jj = nmat - 2;
else if (s[0].type == G2)
jj = nmat - 1;
else
jj = 0;
for (i = 0; i < n; i++) {
SpiroPointType ty0 = s[i].type;
SpiroPointType ty1 = s[i + 1].type;
int jinc = compute_jinc(ty0, ty1);
double th = s[i].bend_th;
double [][] ends = new double[2][4];
double [][][] derivs = new double[4][2][4];
int jthl = -1, jk0l = -1, jk1l = -1, jk2l = -1;
int jthr = -1, jk0r = -1, jk1r = -1, jk2r = -1;
compute_pderivs(s[i], ends, derivs, jinc);
/* constraints crossing LEFT */
if (ty0 == G4 || ty0 == G2 || ty0 == LEFT || ty0 == RIGHT) {
jthl = jj++;
jj %= nmat;
jk0l = jj++;
}
if (ty0 == G4) {
jj %= nmat;
jk1l = jj++;
jk2l = jj++;
}
/* constraints on LEFT */
if ((ty0 == LEFT || ty0 == CORNER || ty0 == OPEN || ty0 == G2) &&
jinc == 4) {
if (ty0 != G2)
jk1l = jj++;
jk2l = jj++;
}
/* constraints on RIGHT */
if ((ty1 == RIGHT || ty1 == CORNER || ty1 == OPEN_END || ty1 == G2) &&
jinc == 4) {
if (ty1 != G2)
jk1r = jj++;
jk2r = jj++;
}
/* constraints crossing RIGHT */
if (ty1 == G4 || ty1 == G2 || ty1 == LEFT || ty1 == RIGHT) {
jthr = jj;
jk0r = (jj + 1) % nmat;
}
if (ty1 == G4) {
jk1r = (jj + 2) % nmat;
jk2r = (jj + 3) % nmat;
}
add_mat_line(m, v, derivs[0][0], th - ends[0][0], 1, j, jthl, jinc, nmat);
add_mat_line(m, v, derivs[1][0], ends[0][1], -1, j, jk0l, jinc, nmat);
add_mat_line(m, v, derivs[2][0], ends[0][2], -1, j, jk1l, jinc, nmat);
add_mat_line(m, v, derivs[3][0], ends[0][3], -1, j, jk2l, jinc, nmat);
add_mat_line(m, v, derivs[0][1], -ends[1][0], 1, j, jthr, jinc, nmat);
add_mat_line(m, v, derivs[1][1], -ends[1][1], 1, j, jk0r, jinc, nmat);
add_mat_line(m, v, derivs[2][1], -ends[1][2], 1, j, jk1r, jinc, nmat);
add_mat_line(m, v, derivs[3][1], -ends[1][3], 1, j, jk2r, jinc, nmat);
j += jinc;
}
if (cyclic) {
bandmat.arraycopy(m, 0, m, nmat, nmat );
bandmat.arraycopy(m, 0, m, 2 * nmat, nmat );
System.arraycopy(v, 0, v, nmat, nmat);
System.arraycopy(v, 0, v, 2 * nmat, nmat);
n_invert = 3 * nmat;
j = nmat;
} else {
n_invert = nmat;
j = 0;
}
bandec11(m, perm, n_invert);
banbks11(m, perm, v, n_invert);
norm = 0.;
for (i = 0; i < n; i++) {
SpiroPointType ty0 = s[i].type;
SpiroPointType ty1 = s[i + 1].type;
int jinc = compute_jinc(ty0, ty1);
int k;
for (k = 0; k < jinc; k++) {
double dk = v[j++];
s[i].ks[k] += dk;
norm += dk * dk;
}
}
return norm;
}
static protected int
solve_spiro(spiro_seg [] s, int nseg) {
bandmat [] m;
double [] v;
int [] perm;
int nmat = count_vec(s, nseg);
int n_alloc = nmat;
double norm;
int i;
if (nmat == 0)
return 0;
if (s[0].type != OPEN && s[0].type != CORNER)
n_alloc *= 3;
if (n_alloc < 5)
n_alloc = 5;
m = new bandmat[n_alloc];
v = new double [n_alloc];
perm = new int [n_alloc];
for (i = 0; i < 10; i++) {
norm = spiro_iter(s, m, perm, v, nseg);
if (norm < 1e-12) break;
}
return 0;
}
static protected void
spiro_seg_to_bpath(final double [/*4*/] ks,
double x0, double y0, double x1, double y1,
SpiroBezierContext bc, int depth) {
double bend = Math.abs(ks[0]) + Math.abs(.5 * ks[1]) + Math.abs(.125 * ks[2]) +
Math.abs((1./48) * ks[3]);
if ( bend <= 1e-8) {
bc.LineTo(x1, y1);
} else {
double seg_ch = Math.hypot(x1 - x0, y1 - y0);
double seg_th = Math.atan2(y1 - y0, x1 - x0);
double [] xy = new double[2];
double ch, th;
double scale, rot;
double th_even, th_odd;
double ul, vl;
double ur, vr;
integrate_spiro(ks, xy);
ch = Math.hypot(xy[0], xy[1]);
th = Math.atan2(xy[1], xy[0]);
scale = seg_ch / ch;
rot = seg_th - th;
if (depth > 5 || bend < 1.) {
th_even = (1./384) * ks[3] + (1./8) * ks[1] + rot;
th_odd = (1./48) * ks[2] + .5 * ks[0];
ul = (scale * (1./3)) * Math.cos(th_even - th_odd);
vl = (scale * (1./3)) * Math.sin(th_even - th_odd);
ur = (scale * (1./3)) * Math.cos(th_even + th_odd);
vr = (scale * (1./3)) * Math.sin(th_even + th_odd);
bc.CubicTo(x0 + ul, y0 + vl, x1 - ur, y1 - vr, x1, y1);
} else {
/* subdivide */
double [] ksub = new double[4];
double thsub;
double [] xysub = new double[2];
double xmid, ymid;
double cth, sth;
ksub[0] = .5 * ks[0] - .125 * ks[1] + (1./64) * ks[2] - (1./768) * ks[3];
ksub[1] = .25 * ks[1] - (1./16) * ks[2] + (1./128) * ks[3];
ksub[2] = .125 * ks[2] - (1./32) * ks[3];
ksub[3] = (1./16) * ks[3];
thsub = rot - .25 * ks[0] + (1./32) * ks[1] - (1./384) * ks[2] + (1./6144) * ks[3];
cth = .5 * scale * Math.cos(thsub);
sth = .5 * scale * Math.sin(thsub);
integrate_spiro(ksub, xysub);
xmid = x0 + cth * xysub[0] - sth * xysub[1];
ymid = y0 + cth * xysub[1] + sth * xysub[0];
spiro_seg_to_bpath(ksub, x0, y0, xmid, ymid, bc, depth + 1);
ksub[0] += .25 * ks[1] + (1./384) * ks[3];
ksub[1] += .125 * ks[2];
ksub[2] += (1./16) * ks[3];
spiro_seg_to_bpath(ksub, xmid, ymid, x1, y1, bc, depth + 1);
}
}
}
static protected spiro_seg []
run_spiro(final SpiroCP []src, int n) {
int nseg = src[0].type == OPEN ? n - 1 : n;
spiro_seg [] s = setup_path(src, n);
if (nseg > 1)
solve_spiro(s, nseg);
return s;
}
static protected void
spiro_to_bpath(final spiro_seg []s, int n, SpiroBezierContext bc) {
int i;
int nsegs = s[n - 1].type == OPEN_END ? n - 1 : n;
for (i = 0; i < nsegs; i++) {
double x0 = s[i].x;
double y0 = s[i].y;
double x1 = s[i + 1].x;
double y1 = s[i + 1].y;
if (i == 0)
bc.MoveTo(x0, y0, s[0].type == OPEN);
bc.MarkKnot(i);
spiro_seg_to_bpath(s[i].ks, x0, y0, x1, y1, bc, 0);
}
}
static protected double
get_knot_th(final spiro_seg []s, int i) {
double [][] ends = new double[2][4];
if (i == 0) {
compute_ends(s[i].ks, ends, s[i].seg_ch);
return s[i].seg_th - ends[0][0];
} else {
compute_ends(s[i - 1].ks, ends, s[i - 1].seg_ch);
return s[i - 1].seg_th + ends[1][0];
}
}
/* ************************************************************************* */
/* *************************** public interface **************************** */
/* ************************************************************************* */
static public void
SpiroCPsToBezier(SpiroCP [] spiros,int n,boolean isclosed,SpiroBezierContext bc) {
spiro_seg []s;
if ( n<1 )
return;
if ( !isclosed ) {
SpiroPointType oldty_start = spiros[0].type;
SpiroPointType oldty_end = spiros[n-1].type;
spiros[0].type= OPEN;
spiros[n-1].type= OPEN_END;
s = run_spiro(spiros,n);
spiros[n-1].type= oldty_end;
spiros[0].type= oldty_start;
} else
s = run_spiro(spiros,n);
spiro_to_bpath(s,n,bc);
}
static public void
TaggedSpiroCPsToBezier(SpiroCP [] spiros,SpiroBezierContext bc) {
spiro_seg []s;
int n;
for ( n=0; spiros[n].type!=END && spiros[n].type!=OPEN_END; ++n );
if ( spiros[n].type == OPEN_END ) ++n;
if ( n<1 )
return;
s = run_spiro(spiros,n);
spiro_to_bpath(s,n,bc);
}
/* ************************************************************************* */
/* ***************************** plate file IO ***************************** */
/* ************************************************************************* */
static public void
SavePlateFile(Writer output,SpiroCP [][] spirocontours) throws IOException {
int i,j;
output.write("(plate\n");
for ( i=0; i<spirocontours.length; ++i ) {
SpiroCP [] spiros = spirocontours[i];
for ( j=0; j<spiros.length; ++j ) {
if ( spiros[j].type==END )
break;
output.write(" " + spiros[j].toString() + "\n" );
}
if ( spiros.length>0 && spiros[0].type!=OPEN )
output.write(" (z)\n");
}
output.write(")\n");
}
static public SpiroCP [][]
ReadPlateFile(BufferedReader input) throws IOException {
ArrayList<SpiroCP []> sofar;
ArrayList<SpiroCP> contour;
int i,j;
String str;
char ch;
SpiroPointType pt;
double x,y;
str = input.readLine();
if ( str==null )
return( null ); /* EOF already? */
if ( !str.trim().equals("(plate") ) {
// Doesn't look like a plate file
return( null );
}
sofar = new ArrayList<SpiroCP []>();
contour = new ArrayList<SpiroCP>();
while ( true ) {
while( true ) {
str = input.readLine();
if ( str==null )
break;
str = str.trim();
if ( str.equals(")") || str.equals("(z)") )
break;
if ( str.charAt(0)!='(' )
return( null );
for ( i=1; i<str.length() && str.charAt(i)==' ' ; ++i );
if ( i>=str.length())
return( null );
ch = str.charAt(i);
if ( ch=='v' )
pt = CORNER;
else if ( ch=='o' )
pt = G4;
else if ( ch=='c' )
pt = G2;
else if ( ch=='[' )
pt = LEFT;
else if ( ch==']' )
pt = RIGHT;
else if ( ch=='{' )
pt = OPEN;
else if ( ch=='}' )
pt = OPEN_END;
else
return( null );
for ( ++i ; i<str.length() && str.charAt(i)==' ' ; ++i );
for ( j=i ; j<str.length() && str.charAt(j)!=' ' ; ++j );
if ( j>=str.length() )
return( null );
try {
x = Double.parseDouble(str.substring(i,j-1));
} catch ( NumberFormatException e ) {
return( null );
}
for ( i=j+1 ; i<str.length() && str.charAt(i)==' ' ; ++i );
for ( j=i ; j<str.length() && str.charAt(j)!=' ' && str.charAt(j)!=')'; ++j );
if ( j>=str.length() )
return( null );
try {
y = Double.parseDouble(str.substring(i,j-1));
} catch ( NumberFormatException e ) {
return( null );
}
contour.add( new SpiroCP(x,y,pt));
}
contour.add( new SpiroCP(0,0,END));
sofar.add( contour.toArray(new SpiroCP[contour.size()]));
contour.clear();
if ( str==null || str.equals(")") )
break;
}
return ( sofar.toArray( new SpiroCP [sofar.size()][] ) );
}
}