void
gen_interp_frequency(struct curve_points *plot)
{
int i, j, curves;
int first_point, num_points;
double y;
curves = num_curves(plot);
first_point = 0;
for (i = 0; i < curves; i++) {
num_points = next_curve(plot, &first_point);
/* If cumulative, replace the current y-value with the
sum of all previous y-values. This assumes that the
data has already been sorted by x-values. */
if( plot->plot_smooth == SMOOTH_CUMULATIVE ) {
y = 0;
for (j = first_point; j < first_point + num_points; j++) {
if (plot->points[j].type == UNDEFINED)
continue;
y += plot->points[j].y;
plot->points[j].y = y;
}
}
do_freq(plot, first_point, num_points);
first_point += num_points + 1;
}
return;
}
void
gen_interp_unwrap(struct curve_points *plot)
{
int i, j, curves;
int first_point, num_points;
double y, lasty, diff;
curves = num_curves(plot);
first_point = 0;
for (i = 0; i < curves; i++) {
num_points = next_curve(plot, &first_point);
lasty = 0; /* make all plots start the same place */
for (j = first_point; j < first_point + num_points; j++) {
if (plot->points[j].type == UNDEFINED)
continue;
y = plot->points[j].y;
do {
diff = y - lasty;
if (diff > M_PI) y -= 2*M_PI;
if (diff < -M_PI) y += 2*M_PI;
} while (fabs(diff) > M_PI);
plot->points[j].y = y;
lasty = y;
}
do_freq(plot, first_point, num_points);
first_point += num_points + 1;
}
return;
}
void
gen_interp(struct curve_points *plot)
{
spline_coeff *sc;
double *bc;
struct coordinate *new_points;
int i, curves;
int first_point, num_points;
curves = num_curves(plot);
new_points = gp_alloc((samples_1 + 1) * curves * sizeof(struct coordinate),
"interpolation table");
first_point = 0;
for (i = 0; i < curves; i++) {
num_points = next_curve(plot, &first_point);
switch (plot->plot_smooth) {
case SMOOTH_CSPLINES:
sc = cp_tridiag(plot, first_point, num_points);
do_cubic(plot, sc, first_point, num_points,
new_points + i * (samples_1 + 1));
free(sc);
break;
case SMOOTH_ACSPLINES:
sc = cp_approx_spline(plot, first_point, num_points);
do_cubic(plot, sc, first_point, num_points,
new_points + i * (samples_1 + 1));
free(sc);
break;
case SMOOTH_BEZIER:
case SMOOTH_SBEZIER:
bc = cp_binomial(num_points);
do_bezier(plot, bc, first_point, num_points,
new_points + i * (samples_1 + 1));
free((char *) bc);
break;
case SMOOTH_KDENSITY:
do_kdensity( plot, first_point, num_points,
new_points + i * (samples_1 + 1));
break;
default: /* keep gcc -Wall quiet */
;
}
new_points[(i + 1) * (samples_1 + 1) - 1].type = UNDEFINED;
first_point += num_points;
}
free(plot->points);
plot->points = new_points;
plot->p_max = curves * (samples_1 + 1);
plot->p_count = plot->p_max - 1;
return;
}
static int
num_curves(struct curve_points *plot)
{
int curves;
int first_point;
int num_points;
first_point = 0;
curves = 0;
while ((num_points = next_curve(plot, &first_point)) > 0) {
curves++;
first_point += num_points;
}
return (curves);
}
void
sort_points(struct curve_points *plot)
{
int first_point, num_points;
first_point = 0;
while ((num_points = next_curve(plot, &first_point)) > 0) {
/* Sort this set of points, does qsort handle 1 point correctly? */
/* HBB 20010720: removed casts -- they don't help a thing, but
* may hide problems */
qsort(plot->points + first_point, num_points,
sizeof(struct coordinate), compare_points);
first_point += num_points;
}
return;
}
void CompositePoint::get_parents_virt( DLIList<TopologyBridge*>& list )
{
DLIList<TopologyBridge*> point_parents;
realPoint->get_parents_virt( point_parents );
for( int i = point_parents.size(); i--; )
{
TopologyBridge* tb = point_parents.get_and_step();
if( CompositeCurve* curve = dynamic_cast<CompositeCurve*>(tb->owner()) )
{
if( ! dynamic_cast<HiddenEntitySet*>(curve->owner()) )
list.append_unique( curve );
}
else if( ! dynamic_cast<HiddenEntitySet*>(tb->owner()) )
list.append( tb );
}
// get point-curves also
CompositeCurve* curve = 0;
while ((curve = next_curve(curve)))
if (curve->num_curves() == 0)
list.append(curve);
if (stitchNext)
{
point_parents.clean_out();
stitchNext->get_parents_virt( point_parents );
point_parents.reset();
for (int j = point_parents.size(); j--; )
{
TopologyBridge* bridge = point_parents.get_and_step();
CompositeCurve* curv = dynamic_cast<CompositeCurve*>(bridge);
if (curv)
list.append_unique( curv->primary_stitched_curve() );
else
list.append_unique( bridge );
}
}
}
void
gen_interp_frequency(struct curve_points *plot)
{
int i, j, curves;
int first_point, num_points;
double y, y_total;
curves = num_curves(plot);
if (plot->plot_smooth == SMOOTH_CUMULATIVE_NORMALISED) {
y_total = 0.0;
first_point = 0;
for (i = 0; i < curves; i++) {
num_points = next_curve(plot, &first_point);
for (j = first_point; j < first_point + num_points; j++) {
if (plot->points[j].type == UNDEFINED)
continue;
y_total += plot->points[j].y;
}
first_point += num_points + 1;
}
}
first_point = 0;
for (i = 0; i < curves; i++) {
num_points = next_curve(plot, &first_point);
/* If cumulative, replace the current y-value with the
sum of all previous y-values. This assumes that the
data has already been sorted by x-values. */
if( plot->plot_smooth == SMOOTH_CUMULATIVE ) {
y = 0;
for (j = first_point; j < first_point + num_points; j++) {
if (plot->points[j].type == UNDEFINED)
continue;
y += plot->points[j].y;
plot->points[j].y = y;
}
}
/* Alternatively, cumulative normalised means replace the
current y-value with the sum of all previous y-values
divided by the total sum of all values. This assumes the
data is sorted as before. Normalising in this way allows
comparison of the CDF of data sets with differing total
numbers of samples. */
if (plot->plot_smooth == SMOOTH_CUMULATIVE_NORMALISED) {
y = 0;
for (j = first_point; j < first_point + num_points; j++) {
if (plot->points[j].type == UNDEFINED)
continue;
y += plot->points[j].y;
plot->points[j].y = y / y_total;
}
}
do_freq(plot, first_point, num_points);
first_point += num_points + 1;
}
return;
}
void
cp_implode(struct curve_points *cp)
{
int first_point, num_points;
int i, j, k;
double x = 0., y = 0., sux = 0., slx = 0., suy = 0., sly = 0.;
double weight; /* used for acsplines */
TBOOLEAN all_inrange = FALSE;
x_axis = cp->x_axis;
y_axis = cp->y_axis;
j = 0;
first_point = 0;
while ((num_points = next_curve(cp, &first_point)) > 0) {
k = 0;
for (i = first_point; i < first_point + num_points; i++) {
/* HBB 20020801: don't try to use undefined datapoints */
if (cp->points[i].type == UNDEFINED)
continue;
if (!k) {
x = cp->points[i].x;
y = cp->points[i].y;
sux = cp->points[i].xhigh;
slx = cp->points[i].xlow;
suy = cp->points[i].yhigh;
sly = cp->points[i].ylow;
weight = cp->points[i].z;
all_inrange = (cp->points[i].type == INRANGE);
k = 1;
} else if (cp->points[i].x == x) {
y += cp->points[i].y;
sux += cp->points[i].xhigh;
slx += cp->points[i].xlow;
suy += cp->points[i].yhigh;
sly += cp->points[i].ylow;
weight += cp->points[i].z;
if (cp->points[i].type != INRANGE)
all_inrange = FALSE;
k++;
} else {
cp->points[j].x = x;
if ( cp->plot_smooth == SMOOTH_FREQUENCY ||
cp->plot_smooth == SMOOTH_CUMULATIVE ||
cp->plot_smooth == SMOOTH_CUMULATIVE_NORMALISED )
k = 1;
cp->points[j].y = y /= (double) k;
cp->points[j].xhigh = sux / (double) k;
cp->points[j].xlow = slx / (double) k;
cp->points[j].yhigh = suy / (double) k;
cp->points[j].ylow = sly / (double) k;
cp->points[j].z = weight / (double) k;
/* HBB 20000405: I wanted to use STORE_AND_FIXUP_RANGE
* here, but won't: it assumes we want to modify the
* range, and that the range is given in 'input'
* coordinates. For logarithmic axes, the overhead
* would be larger than the possible gain, so write it
* out explicitly, instead:
* */
cp->points[j].type = INRANGE;
if (! all_inrange) {
if (X_AXIS.log) {
if (x <= -VERYLARGE) {
cp->points[j].type = OUTRANGE;
goto is_outrange;
}
x = AXIS_UNDO_LOG(x_axis, x);
}
if (((x < X_AXIS.min) && !(X_AXIS.autoscale & AUTOSCALE_MIN))
|| ((x > X_AXIS.max) && !(X_AXIS.autoscale & AUTOSCALE_MAX))) {
cp->points[j].type = OUTRANGE;
goto is_outrange;
}
if (Y_AXIS.log) {
if (y <= -VERYLARGE) {
cp->points[j].type = OUTRANGE;
goto is_outrange;
}
y = AXIS_UNDO_LOG(y_axis, y);
}
if (((y < Y_AXIS.min) && !(Y_AXIS.autoscale & AUTOSCALE_MIN))
|| ((y > Y_AXIS.max) && !(Y_AXIS.autoscale & AUTOSCALE_MAX)))
cp->points[j].type = OUTRANGE;
is_outrange:
;
} /* if(! all inrange) */
j++; /* next valid entry */
k = 0; /* to read */
i--; /* from this (-> last after for(;;)) entry */
} /* else (same x position) */
} /* for(points in curve) */
if (k) {
cp->points[j].x = x;
if ( cp->plot_smooth == SMOOTH_FREQUENCY ||
cp->plot_smooth == SMOOTH_CUMULATIVE ||
cp->plot_smooth == SMOOTH_CUMULATIVE)
k = 1;
cp->points[j].y = y /= (double) k;
cp->points[j].xhigh = sux / (double) k;
cp->points[j].xlow = slx / (double) k;
cp->points[j].yhigh = suy / (double) k;
cp->points[j].ylow = sly / (double) k;
cp->points[j].z = weight / (double) k;
cp->points[j].type = INRANGE;
if (! all_inrange) {
if (X_AXIS.log) {
if (x <= -VERYLARGE) {
cp->points[j].type = OUTRANGE;
goto is_outrange2;
}
x = AXIS_UNDO_LOG(x_axis, x);
}
if (((x < X_AXIS.min) && !(X_AXIS.autoscale & AUTOSCALE_MIN))
|| ((x > X_AXIS.max) && !(X_AXIS.autoscale & AUTOSCALE_MAX))) {
cp->points[j].type = OUTRANGE;
goto is_outrange2;
}
if (Y_AXIS.log) {
if (y <= -VERYLARGE) {
cp->points[j].type = OUTRANGE;
goto is_outrange2;
}
y = AXIS_UNDO_LOG(y_axis, y);
}
if (((y < Y_AXIS.min) && !(Y_AXIS.autoscale & AUTOSCALE_MIN))
|| ((y > Y_AXIS.max) && !(Y_AXIS.autoscale & AUTOSCALE_MAX)))
cp->points[j].type = OUTRANGE;
is_outrange2:
;
}
j++; /* next valid entry */
}
/* insert invalid point to separate curves */
if (j < cp->p_count) {
cp->points[j].type = UNDEFINED;
j++;
}
first_point += num_points;
} /* end while */
cp->p_count = j;
cp_extend(cp, j);
}
void
cp_implode(struct curve_points *cp)
{
int first_point, num_points;
int i, j, k;
double x = 0., y = 0., sux = 0., slx = 0., suy = 0., sly = 0.;
double weight; /* used for acsplines */
TBOOLEAN all_inrange = FALSE;
x_axis = cp->x_axis;
y_axis = cp->y_axis;
j = 0;
first_point = 0;
while ((num_points = next_curve(cp, &first_point)) > 0) {
k = 0;
for (i = first_point; i < first_point + num_points; i++) {
/* HBB 20020801: don't try to use undefined datapoints */
if (cp->points[i].type == UNDEFINED)
continue;
if (!k) {
x = cp->points[i].x;
y = cp->points[i].y;
sux = cp->points[i].xhigh;
slx = cp->points[i].xlow;
suy = cp->points[i].yhigh;
sly = cp->points[i].ylow;
weight = cp->points[i].z;
all_inrange = (cp->points[i].type == INRANGE);
k = 1;
} else if (cp->points[i].x == x) {
y += cp->points[i].y;
sux += cp->points[i].xhigh;
slx += cp->points[i].xlow;
suy += cp->points[i].yhigh;
sly += cp->points[i].ylow;
weight += cp->points[i].z;
if (cp->points[i].type != INRANGE)
all_inrange = FALSE;
k++;
} else {
cp->points[j].x = x;
if ( cp->plot_smooth == SMOOTH_FREQUENCY ||
cp->plot_smooth == SMOOTH_FREQUENCY_NORMALISED ||
cp->plot_smooth == SMOOTH_CUMULATIVE ||
cp->plot_smooth == SMOOTH_CUMULATIVE_NORMALISED )
k = 1;
cp->points[j].y = y /= (double) k;
cp->points[j].xhigh = sux / (double) k;
cp->points[j].xlow = slx / (double) k;
cp->points[j].yhigh = suy / (double) k;
cp->points[j].ylow = sly / (double) k;
cp->points[j].z = weight / (double) k;
/* HBB 20000405: I wanted to use STORE_AND_FIXUP_RANGE here,
* but won't: it assumes we want to modify the range, and
* that the range is given in 'input' coordinates.
*/
cp->points[j].type = INRANGE;
if (! all_inrange) {
if (((x < X_AXIS.min) && !(X_AXIS.autoscale & AUTOSCALE_MIN))
|| ((x > X_AXIS.max) && !(X_AXIS.autoscale & AUTOSCALE_MAX))) {
cp->points[j].type = OUTRANGE;
goto is_outrange;
}
if (((y < Y_AXIS.min) && !(Y_AXIS.autoscale & AUTOSCALE_MIN))
|| ((y > Y_AXIS.max) && !(Y_AXIS.autoscale & AUTOSCALE_MAX)))
cp->points[j].type = OUTRANGE;
is_outrange:
;
} /* if (! all inrange) */
j++; /* next valid entry */
k = 0; /* to read */
i--; /* from this (-> last after for(;;)) entry */
} /* else (same x position) */
} /* for(points in curve) */
if (k) {
cp->points[j].x = x;
if ( cp->plot_smooth == SMOOTH_FREQUENCY ||
cp->plot_smooth == SMOOTH_FREQUENCY_NORMALISED ||
cp->plot_smooth == SMOOTH_CUMULATIVE ||
cp->plot_smooth == SMOOTH_CUMULATIVE_NORMALISED)
k = 1;
cp->points[j].y = y /= (double) k;
cp->points[j].xhigh = sux / (double) k;
cp->points[j].xlow = slx / (double) k;
cp->points[j].yhigh = suy / (double) k;
cp->points[j].ylow = sly / (double) k;
cp->points[j].z = weight / (double) k;
cp->points[j].type = INRANGE;
if (! all_inrange) {
if (((x < X_AXIS.min) && !(X_AXIS.autoscale & AUTOSCALE_MIN))
|| ((x > X_AXIS.max) && !(X_AXIS.autoscale & AUTOSCALE_MAX))) {
cp->points[j].type = OUTRANGE;
goto is_outrange2;
}
if (((y < Y_AXIS.min) && !(Y_AXIS.autoscale & AUTOSCALE_MIN))
|| ((y > Y_AXIS.max) && !(Y_AXIS.autoscale & AUTOSCALE_MAX)))
cp->points[j].type = OUTRANGE;
is_outrange2:
;
}
j++; /* next valid entry */
}
/* FIXME: Monotonic cubic splines support only a single curve per data set */
if (j < cp->p_count && cp->plot_smooth == SMOOTH_MONOTONE_CSPLINE) {
break;
}
/* insert invalid point to separate curves */
if (j < cp->p_count) {
cp->points[j].type = UNDEFINED;
j++;
}
first_point += num_points;
} /* end while */
cp->p_count = j;
cp_extend(cp, j);
}
