/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
//HERMITE: p1=p0 p2=p1 p3=r0 p4=r1
//BEZIER: p1 = p0 p2 = other point 2 p3 = other point 1 p4 = p1
struct matrix * coefs = new_matrix(4, 1);
struct matrix * inverse = new_matrix(4, 4);
if (type == HERMITE_MODE){
coefs->m[0][0] = p1;
coefs->m[1][0] = p2;
coefs->m[2][0] = p3-p1;
coefs->m[3][0] = p4-p2;
inverse = make_hermite();
}
else if (type == BEZIER_MODE){
coefs->m[0][0] = p1;
coefs->m[1][0] = p3;
coefs->m[2][0] = p2;
coefs->m[3][0] = p4;
inverse = make_bezier();
}
matrix_mult(inverse, coefs);
free_matrix(inverse);
return coefs;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix *temp;
temp = new_matrix(4,1);
//Bezier Curve co
if(type == 1){
temp->m[0][0] = p1;
temp->m[1][0] = p2;
temp->m[2][0] = p3;
temp->m[3][0] = p4;
struct matrix *newBez;
newBez = make_bezier();
matrix_mult(newBez,temp);
}
if(type == 0){
temp->m[0][0] = p1;
temp->m[1][0] = p3;
temp->m[2][0] = p2-p1;
temp->m[3][0] = p4-p3;
struct matrix *newHerm;
newHerm = make_hermite();
matrix_mult(newHerm,temp);
}
return temp;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * inverse;
struct matrix * coefs;
if ( type == BEZIER_MODE )
inverse = make_bezier();
else
inverse = make_hermite();
coefs = new_matrix(4, 1);
if ( type == BEZIER_MODE ) {
coefs->m[0][0] = p1;
coefs->m[1][0] = p2;
coefs->m[2][0] = p3;
coefs->m[3][0] = p4;
}
else {
coefs->m[0][0] = p1;
coefs->m[1][0] = p3;
coefs->m[2][0] = p2 - p1;
coefs->m[3][0] = p4 - p3;
}
matrix_mult(inverse, coefs);
free_matrix(inverse);
return coefs;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * bh;;
struct matrix * given = new_matrix(4, 1);
given->lastcol = 1;
if (type == 0){
bh = make_bezier();
given->m[0][0] = p1;
given->m[1][0] = p2;
given->m[2][0] = p3;
given->m[3][0] = p4;
}
else{
bh = make_hermite();
given->m[0][0] = p1;
given->m[1][0] = p3;
given->m[2][0] = p1 - p2;
given->m[3][0] = p3 - p4;
}
matrix_mult(bh, given);
free_matrix(bh);
return given;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * coeffs = new_matrix(4, 1);
//Hermite Curve
if (type == 0) {
struct matrix *h = make_hermite();
coeffs->m[0][0] = p1;
coeffs->m[1][0] = p3;
coeffs->m[2][0] = p2-p1;
coeffs->m[3][0] = p4-p3;
matrix_mult(h, coeffs);
free_matrix(h);
}
//Bezier Curve
if (type == 1) {
struct matrix *b = make_bezier();
coeffs->m[0][0] = p1;
coeffs->m[1][0] = p2;
coeffs->m[2][0] = p3;
coeffs->m[3][0] = p4;
matrix_mult(b, coeffs);
free_matrix(b);
}
return coeffs;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * m = new_matrix(4, 1);
m->m[0][0] = p1;
m->m[1][0] = p2;
m->m[2][0] = p3;
m->m[3][0] = p4;
if (type == HERMITE_MODE) {
matrix_mult(make_hermite(),m);
}
else {
matrix_mult(make_bezier(),m);
}
return m;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix* coefs = new_matrix(4, 1);
coefs -> m[0][0] = p1;
coefs -> m[1][0] = p2;
coefs -> m[2][0] = p3;
coefs -> m[3][0] = p4;
if (type == HERMITE_MODE)
matrix_mult(make_hermite(), coefs);
else
matrix_mult(make_bezier(), coefs);
return coefs;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs(
/*Hermite: p0 Bezier:p0*/ double p1,
/*Hermite: p1 Bezier: p1*/ double p2,
/*Hermite: r1 Bezier: p2*/ double p3,
/*Hermite: r2 Bezier: p3*/ double p4, int type) {
struct matrix *curve_coefs = new_matrix(4,1);
curve_coefs->m[0][0] = p1;
curve_coefs->m[1][0] = p2;
curve_coefs->m[2][0] = p3;
curve_coefs->m[3][0] = p4;
if(type == HERMITE_MODE)
matrix_mult(make_hermite(),curve_coefs);
if(type == BEZIER_MODE)
matrix_mult(make_bezier(),curve_coefs);
return curve_coefs;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * g = new_matrix(4, 1);
g->m[0][0] = p1;
g->m[1][0] = p2;
g->m[2][0] = p3;
g->m[3][0] = p4;
struct matrix *c;
if (type == HERMITE_MODE) {
c = make_hermite();
}
if (type == BEZIER_MODE) {
c = make_bezier();
}
matrix_mult(c, g);
return g;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * m = new_matrix(4, 4);
if (type){
m->m[0][0]=p1;
m->m[1][0]=p2;
m->m[2][0]=p3;
m->m[3][0]=p4;
matrix_mult(make_bezier(),m);
}
else{
m->m[0][0]=p1;
m->m[1][0]=p3;
m->m[2][0]=p2-p1;
m->m[3][0]=p4-p3;
matrix_mult(make_hermite(),m);
}
m->lastcol=1;
return m;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * m = new_matrix(1, 4);
struct matrix * hermite = make_hermite();
struct matrix * bezier = make_bezier();
m->m[0][0] = p1;
m->m[0][0] = p2;
m->m[0][0] = p3;
m->m[0][0] = p4;
if (type == 0) { //Hermite
matrix_mult( hermite, m );
}
else { //Bezier
matrix_mult( bezier, m );
}
return m;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * m = new_matrix(1,4);
if(HERMITE_MODE == type) {
m->m[0][0] = p1;
m->m[0][1] = p3;
m->m[0][2] = (p2 - p1);
m->m[0][3] = (p4 - p3);
matrix_mult(make_hermite(), m);
}
else{
m->m[0][0] = p1;
m->m[0][1] = p2;
m->m[0][2] = p3;
m->m[0][3] = p4;
matrix_mult(make_bezier(), m);
}
return m;
}
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix *m;
struct matrix *a = new_matrix(4,1);
a->lastcol = 1;
if(type==0){//hermite
m = make_hermite();
a->m[0][0] = p1;//p0
a->m[1][0] = p3;//p1
a->m[2][0] = p2;//r0
a->m[3][0] = p4;//r1
}else{//bezier
m = make_bezier();
a->m[0][0] = p1;
a->m[1][0] = p2;
a->m[2][0] = p3;
a->m[3][0] = p4;
}
matrix_mult(m,a);
return a;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * k = new_matrix(4,4);
struct matrix * m = new_matrix(4, 1);
if(type == 0){ //hermite
m->m[0][0] = p1;
m->m[1][0] = p2;
m->m[2][0] = p3 - p1;
m->m[3][0] = p4 - p2;
k = make_hermite();
}
else if(type == 1){ //bezier
m->m[0][0] = p1;
m->m[1][0] = p3;
m->m[2][0] = p2;
m->m[3][0] = p4;
k = make_bezier();
}
matrix_mult(k, m);
free_matrix(k);
return m;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * m = new_matrix(4,4);
ident(m);
struct matrix * points = new_matrix(4,1);
if (type == 0 ){
points->m[0][0] = p1;
points->m[1][0] = p2;
points->m[2][0] = p2-p1;
points->m[3][0] = p4-p3;
matrix_mult(make_hermite(), points);
}
if (type == 1 ){
points->m[0][0] = p1;
points->m[1][0] = p2;
points->m[2][0] = p3;
points->m[3][0] = p4;
matrix_mult(make_bezier(), points);
}
return m;
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * inverse = new_matrix(4, 4);
struct matrix * m = new_matrix(4, 1);
m -> m[0][0] = p1;
m -> m[1][0] = p4;
m -> m[2][0] = (p2 - p1);
m -> m[3][0] = (p4 - p3);
if (type == 0) {
inverse = make_hermite();
matrix_mult(inverse, m);
return m;
}
else {
inverse = make_bezier();
matrix_mult(inverse, m);
return m;
}
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix *B= new_matrix(4,1);
B->m[0][0]=p1;
B->m[0][1]=p2;
B->m[0][2]=p3;
B->m[0][3]=p4;
struct matrix *A;
if (type){//zero means hermite,1 is bezier
A =make_bezier();
}
else{
A = make_hermite();
}
matrix_mult(A,B);
return B;
//now Matrtix B is in the form
/*
[a]
[b]
[c]
[d] */
}
/*======== struct matrix * generate_curve_coefs() ==========
Inputs: double p1
double p2
double p3
double p4
int type
Returns:
A matrix containing the values for a, b, c and d of the
equation at^3 + bt^2 + ct + d for the curve defined
by p1, p2, p3 and p4.
Type determines whether the curve is bezier or hermite
03/16/12 14:42:46
jdyrlandweaver
====================*/
struct matrix * generate_curve_coefs( double p1, double p2,
double p3, double p4, int type) {
struct matrix * coef = new_matrix(4,1);
coef->m[0][0] = p1;
coef->m[1][0] = p2;
coef->m[2][0] = p3;
coef->m[3][0] = p4;
if(type == HERMITE_MODE){
struct matrix * herm = make_hermite();
matrix_mult(herm, coef);
free_matrix(herm);
return coef;
}
else if(type == BEZIER_MODE){
struct matrix * bez = make_bezier();
matrix_mult(bez, coef);
free_matrix(bez);
return coef;
}
else{
return NULL;
}
}
void parsePath(std::istream &in, std::vector<std::vector<carve::geom2d::P2> > &paths) {
carve::geom2d::P2 curr, curr_ctrl;
std::string pathname;
// while (in.good() && !std::isspace(in.peek())) pathname.push_back(in.get());
in >> pathname;
std::cerr << "parsing: [" << pathname << "]" << std::endl;
std::vector<double> vals;
std::vector<carve::geom2d::P2> points;
while (in.good()) {
char c;
in >> c;
if (in.eof()) break;
if (std::isspace(c)) continue;
std::cerr << "[" << c << "]";
vals.clear();
switch (c) {
case 'M': {
readVals(in, vals);
points.clear();
for (unsigned i = 0; i < vals.size(); i += 2) {
curr = carve::geom::VECTOR(vals[i], vals[i+1]);
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'm': {
readVals(in, vals);
points.clear();
curr = carve::geom::VECTOR(0.0, 0.0);
for (unsigned i = 0; i < vals.size(); i += 2) {
curr += carve::geom::VECTOR(vals[i], vals[i+1]);
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'L': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); i += 2) {
curr = carve::geom::VECTOR(vals[i], vals[i+1]);
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'l': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); i += 2) {
curr += carve::geom::VECTOR(vals[i], vals[i+1]);
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'H': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); ++i) {
curr.x = vals[i];
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'h': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); ++i) {
curr.x += vals[i];
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'V': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); ++i) {
curr.y = vals[i];
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'v': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); ++i) {
curr.y += vals[i];
add(points, curr);
}
curr_ctrl = curr;
break;
}
case 'S': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); i += 4) {
carve::geom2d::P2 c1 = curr - (curr_ctrl - curr);
carve::geom2d::P2 c2 = carve::geom::VECTOR(vals[i+0], vals[i+1]);
carve::geom2d::P2 p2 = carve::geom::VECTOR(vals[i+2], vals[i+3]);
add(points, make_bezier(curr, c1, c2, p2));
curr_ctrl = c2;
curr = p2;
}
break;
}
case 's': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); i += 4) {
carve::geom2d::P2 c1 = curr - (curr_ctrl - curr);
carve::geom2d::P2 c2 = curr + carve::geom::VECTOR(vals[i+0], vals[i+1]);
carve::geom2d::P2 p2 = curr + carve::geom::VECTOR(vals[i+2], vals[i+3]);
add(points, make_bezier(curr, c1, c2, p2));
curr_ctrl = c2;
curr = p2;
}
break;
}
case 'C': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); i += 6) {
carve::geom2d::P2 c1 = carve::geom::VECTOR(vals[i+0], vals[i+1]);
carve::geom2d::P2 c2 = carve::geom::VECTOR(vals[i+2], vals[i+3]);
carve::geom2d::P2 p2 = carve::geom::VECTOR(vals[i+4], vals[i+5]);
add(points, make_bezier(curr, c1, c2, p2));
curr_ctrl = c2;
curr = p2;
}
break;
}
case 'c': {
readVals(in, vals);
for (unsigned i = 0; i < vals.size(); i += 6) {
carve::geom2d::P2 c1 = curr + carve::geom::VECTOR(vals[i+0], vals[i+1]);
carve::geom2d::P2 c2 = curr + carve::geom::VECTOR(vals[i+2], vals[i+3]);
carve::geom2d::P2 p2 = curr + carve::geom::VECTOR(vals[i+4], vals[i+5]);
add(points, make_bezier(curr, c1, c2, p2));
curr_ctrl = c2;
curr = p2;
}
break;
}
case 'Z':
case 'z': {
std::cerr << "path coords: " << std::endl;
for (size_t i = 0; i < points.size(); ++i) {
std::cerr << " " << i << ": " << points[i].x << "," << points[i].y;
}
if (points.back() == points.front()) points.pop_back();
std::cerr << std::endl;
paths.push_back(points);
curr = curr_ctrl = carve::geom::VECTOR(0.0, 0.0);
break;
}
default: {
std::cerr << "unhandled path op: [" << c << "]" << std::endl;
throw std::runtime_error("failed");
}
}
}
}
